ai

type APIKeyAuth struct {
	Name    string
	Login   func(ProviderAuthInteraction, ...*OAuthLoginOptions) (any, error)
	Check   func(APIKeyAuthInput) (any, error)
	Resolve func(APIKeyAuthInput) (any, error)
}

type APIKeyAuthInput struct {
	Context     context.Context
	AuthContext *AuthContext
	Credential  any
}

type AnthropicClientError struct {
	Status  int
	Headers http.Header
	Message string
}

type AnthropicCompat struct {
	SupportsEagerToolInputStreaming bool    `json:"supportsEagerToolInputStreaming"`
	SupportsLongCacheRetention      bool    `json:"supportsLongCacheRetention"`
	SendSessionAffinityHeaders      bool    `json:"sendSessionAffinityHeaders"`
	SessionAffinityFormat           *string `json:"sessionAffinityFormat,omitempty"`
	SupportsCacheControlOnTools     bool    `json:"supportsCacheControlOnTools"`
	SupportsTemperature             bool    `json:"supportsTemperature"`
	AllowEmptySignature             bool    `json:"allowEmptySignature"`
	SupportsStrictTools             bool    `json:"supportsStrictTools"`
	SupportsMidConvoSystemMessages  bool    `json:"supportsMidConvoSystemMessages"`
	SupportsMidConvoToolChanges     bool    `json:"supportsMidConvoToolChanges"`
}

type AnthropicConvertedMessages struct {
	Messages        json.RawMessage `json:"messages"`
	AssistantLevels map[int]string  `json:"assistantLevels"`
}

type AnthropicMessageClient struct {
	CreateResponse func(context.Context, json.RawMessage, AnthropicRequestOptions) (*http.Response, error)
}

type AnthropicMessagesOptions struct {
	OAuth                  bool                                  `json:"oauth"`
	CacheControl           json.RawMessage                       `json:"cacheControl,omitempty"`
	AllowEmptySignature    bool                                  `json:"allowEmptySignature"`
	ManagedProvider        *string                               `json:"managedProvider,omitempty"`
	ConvertToolDefinitions func([]Tool) (json.RawMessage, error) `json:"-"`
}

type AnthropicOAuthOptions struct {
	Client         *http.Client
	PKCE           func() (PKCE, error)
	StartCallback  func(*OAuthCallbackServerOptions) (*OAuthCallbackServer, error)
	CallbackHost   *string
	Now            func() float64
	RequestTimeout time.Duration
	ErrorStack     func(name, message string) string
}

type AnthropicProvider struct {
	APIKey string

	BaseURL string
	// OAuth marks the claude-code subscription mode: the credential is an OAuth
	// access token sent as Authorization: Bearer (never x-api-key), the request
	// carries the Claude Code client fingerprint (User-Agent, x-app, the fixed
	// beta set), and the system prompt gains the Claude Code identity block.
	OAuth bool
	// HTTP serves the non-streamed Chat path (absolute cap, no header deadline).
	HTTP *http.Client
	// StreamHTTP serves the SSE path, where a header deadline is meaningful. Nil
	// falls back to HTTP, so a caller that overrides only HTTP still works.
	StreamHTTP *http.Client
	// contains filtered or unexported fields
}

type AnthropicRequestOptions struct {
	// Raw JSON preserves absent/null/fractional timeout values. Validation belongs
	// to the injected client, just as it does for a prebuilt SDK client in Pi.
	TimeoutMS  json.RawMessage `json:"timeout,omitempty"`
	MaxRetries int             `json:"maxRetries"`
}

type AnthropicStreamOptions = OpenAICompletionsStreamOptions

type AnthropicToolsOptions struct {
	OAuth               bool            `json:"oauth"`
	EagerInputStreaming bool            `json:"eagerInputStreaming"`
	StrictTools         bool            `json:"strictTools"`
	CacheControl        json.RawMessage `json:"cacheControl,omitempty"`
}

type AntigravityOAuthOptions struct {
	Client        *http.Client
	RandomValue   func() (string, error)
	CallbackHost  func() string
	StartCallback func(*OAuthCallbackServerOptions) (*OAuthCallbackServer, error)
	Now           func() float64
}

type AntigravityProvider struct {
	// BaseURL, when set, replaces the endpoint failover list with a single
	// endpoint (tests, proxies). Empty tries daily then sandbox.
	BaseURL string
	// HTTP serves the list-models path.
	HTTP *http.Client
	// StreamHTTP serves the SSE path. Nil falls back to HTTP.
	StreamHTTP *http.Client
	// contains filtered or unexported fields
}

type Array = jsonjs.Array

type AssistantMessageEvent struct {
	Type         string                     `json:"type"`
	ContentIndex int                        `json:"contentIndex,omitempty"`
	Delta        string                     `json:"delta,omitempty"`
	Content      string                     `json:"content,omitempty"`
	ToolCall     *ContentBlock              `json:"toolCall,omitempty"`
	Partial      *Message                   `json:"partial,omitempty"`
	Reason       string                     `json:"reason,omitempty"`
	Message      *Message                   `json:"message,omitempty"`
	Error        *Message                   `json:"error,omitempty"`
	Extra        map[string]json.RawMessage `json:"-"`
	// contains filtered or unexported fields
}

type AssistantMessageEventStream struct {
	*EventStream[AssistantMessageEvent, *Message]
	// contains filtered or unexported fields
}

type AssistantStreamHooks struct {
	Result   func(context.Context) (*Message, error)
	AfterEnd func(context.Context) error
}

type AttemptOutcome struct {
	AdmissionError error
	Terminal       AssistantMessageEvent

	Committed bool
	// contains filtered or unexported fields
}

type AttemptTrace struct {
	// contains filtered or unexported fields
}

type AuthContext struct {
	Env        func(context.Context, string) (any, error)
	FileExists func(context.Context, string) (bool, error)
}

type AuthResolutionOverrides struct {
	APIKey             any
	Env                any
	MinOAuthValidityMS any
	Now                func() int64
}

type AzureResponsesConfig struct {
	BaseURL        string `json:"baseUrl"`
	APIVersion     string `json:"apiVersion"`
	DeploymentName string `json:"deploymentName"`
}

type AzureResponsesStreamOptions = OpenAICompletionsStreamOptions

type BlockList struct {
	// contains filtered or unexported fields
}

type ChatGPTOAuthAuthorization struct{ Code, ClientID string }

type ChatGPTOAuthCallback struct {
	URL    string
	Ready  <-chan struct{}
	Result func() (ChatGPTOAuthAuthorization, error)
	Close  func()
}

type ChatGPTOAuthCallbackOptions struct {
	Host, State string
	Port        int
}

type ClientSpec struct {
	Name    string // "openai" | "anthropic" | an OAuth vendor | any OpenAI-compatible vendor
	APIKey  string
	BaseURL string
	Compat  Compat // optional; zero value falls back to the vendor default
	// OpenAIWire chooses the transport for an OpenAI provider identity. Empty
	// and OpenAIWireChat use Chat Completions; OpenAIWireResponses uses the
	// public Responses API while Name() remains "openai". Keeping provider
	// identity separate from wire format lets one workspace row serve models
	// with different API contracts, matching the model.api split in OMP.
	OpenAIWire OpenAIWire
	// SessionScope distinguishes independently configured provider rows that use
	// the same vendor/base URL. OAuth account-rotation state must never confuse
	// two sibling pools just because both speak (for example) openai-codex.
	SessionScope string
	// TokenSource is the OAuth account pool a subscription vendor
	// (claude-code | openai-codex | google-antigravity) draws per-request
	// credentials from. Required for those vendors, ignored by the rest.
	TokenSource TokenSource
}

type CodexProvider struct {
	// BaseURL overrides the backend origin; empty uses codexBaseURL. The
	// /codex/responses suffix is appended by responsesURL, so a test server
	// can point BaseURL at itself.
	BaseURL string
	// HTTP serves the list-models path.
	HTTP *http.Client
	// StreamHTTP serves the SSE path (the only chat transport this backend
	// offers). Nil falls back to HTTP.
	StreamHTTP *http.Client
	// contains filtered or unexported fields
}

type CodexResponsesStreamOptions = OpenAICompletionsStreamOptions

type CodexWebSocketDebugStats struct {
	Requests                int             `json:"requests"`
	ConnectionsCreated      int             `json:"connectionsCreated"`
	ConnectionsReused       int             `json:"connectionsReused"`
	CachedContextRequests   int             `json:"cachedContextRequests"`
	StoreTrueRequests       int             `json:"storeTrueRequests"`
	FullContextRequests     int             `json:"fullContextRequests"`
	DeltaRequests           int             `json:"deltaRequests"`
	LastInputItems          int             `json:"lastInputItems"`
	LastDeltaInputItems     *int            `json:"lastDeltaInputItems,omitempty"`
	LastPreviousResponseID  json.RawMessage `json:"lastPreviousResponseId,omitempty"`
	WebSocketFailures       int             `json:"websocketFailures"`
	SSEFallbacks            int             `json:"sseFallbacks"`
	WebSocketFallbackActive *bool           `json:"websocketFallbackActive,omitempty"`
	LastWebSocketError      *string         `json:"lastWebSocketError,omitempty"`
}

type Collection struct {
	// contains filtered or unexported fields
}

type Compat struct {
	// MaxTokensField is "max_tokens" or "max_completion_tokens".
	MaxTokensField string
	// SupportsTools indicates the vendor accepts the tools/tool_calls fields.
	SupportsTools bool
}

type CompletionsResponse struct {
	Status  int               `json:"status"`
	Headers map[string]string `json:"headers"`
}

type ContentBlock struct {
	Type              string                     `json:"type"`
	Text              string                     `json:"text,omitempty"`
	TextSignature     *string                    `json:"textSignature,omitempty"`
	Thinking          string                     `json:"thinking,omitempty"`
	ThinkingSignature *string                    `json:"thinkingSignature,omitempty"`
	Redacted          *bool                      `json:"redacted,omitempty"`
	Data              string                     `json:"data,omitempty"`
	MIMEType          string                     `json:"mimeType,omitempty"`
	ID                string                     `json:"id,omitempty"`
	Name              string                     `json:"name,omitempty"`
	Arguments         json.RawMessage            `json:"arguments,omitempty"`
	ThoughtSignature  *string                    `json:"thoughtSignature,omitempty"`
	Namespace         *string                    `json:"namespace,omitempty"`
	Extra             map[string]json.RawMessage `json:"-"`
	// contains filtered or unexported fields
}

type Context struct {
	SystemPrompt string    `json:"systemPrompt,omitempty"`
	Messages     []Message `json:"messages"`
	Tools        []Tool    `json:"tools,omitempty"`
}

type ContextUsageEstimate struct {
	Tokens         float64 `json:"tokens"`
	UsageTokens    float64 `json:"usageTokens"`
	TrailingTokens float64 `json:"trailingTokens"`
	LastUsageIndex *int    `json:"lastUsageIndex"`
}

type CredentialPersistence struct {
	Read   func(context.Context, string) (any, error)
	List   func(context.Context) (*Array, error)
	Modify func(context.Context, string, func(any) (any, error)) (any, error)
	Delete func(context.Context, string) error
}

type DataCloneError struct{}

type DeferredStreamFunc func(context.Context, any, any, *Object) (*ProviderEventSource, error)

type DevinOAuthOptions struct {
	Client        *http.Client
	PKCE          func() (PKCE, error)
	CallbackHost  func() string
	StartCallback func(*OAuthCallbackServerOptions) (*OAuthCallbackServer, error)
	Now           func() float64
	// contains filtered or unexported fields
}

type DevinProvider struct {
	// BaseURL overrides the Cascade origin; empty uses DevinDefaultBaseURL.
	BaseURL string
	// HTTP serves listing and unary calls.
	HTTP *http.Client
	// StreamHTTP serves the chat stream; nil falls back to HTTP.
	StreamHTTP *http.Client
	// contains filtered or unexported fields
}

type EventStream[T, R any] struct {
	// contains filtered or unexported fields
}

type FallbackAttempt struct {
	Number      int
	Outcome     AttemptOutcome
	Failure     error
	FailureKind string
}

type FallbackCandidate struct {
	SafeLabels telemetry.SafeLabels
	Model      json.RawMessage
	Stream     StreamFn
}

type FallbackProvider struct {
	Candidates []FallbackCandidate
	Retry      protocol.RetryPolicy
	// Wait optionally supplies a clock for backoff. Nil uses a cancellable timer.
	Wait func(context.Context, time.Duration) error
}

type FallbackRequest struct {
	// SafeLabels is an optional immutable host-approved binding per candidate.
	// An omitted entry uses the corresponding candidate's approved labels.
	SafeLabels    []telemetry.SafeLabels
	Start         int
	Candidates    int
	Open          func(context.Context, int, int) (*AssistantMessageEventStream, error)
	Commit        func(context.Context, int) error
	Observe       func(context.Context, int, FallbackAttempt) error
	Validate      func() error
	BeforePublish func(AttemptOutcome) error
	// Recover may repair one confirmed pre-output provider rejection per rung.
	// AI still owns replay safety and the hard one-recovery bound.
	Recover func(context.Context, int, FallbackAttempt) (bool, error)
}

type FallbackSelection struct {
	Version    int             `json:"version"`
	Generation uint64          `json:"generation"`
	Rung       int             `json:"rung"`
	ProviderID string          `json:"providerId"`
	Model      json.RawMessage `json:"model"`
}

type GitHubCopilotOAuthOptions struct {
	KnownModels    *Object
	Client         *http.Client
	Now            func() float64
	Sleep          func(float64, context.Context) error
	PollSleep      func(float64, context.Context, string) error
	RequestTimeout time.Duration
	RetryBudget    time.Duration
}

type GrammarConstrainedSampling struct {
	Format        string `json:"format"`
	Definition    string `json:"definition"`
	InputProperty string `json:"inputProperty"`
}

type GrammarToolInputJSONBuffer struct {
	Input   string `json:"input"`
	Started bool   `json:"started"`
	Closed  bool   `json:"closed"`
}

type HTTPDoer interface {
	Do(*http.Request) (*http.Response, error)
}

type InMemoryCredentialStore struct {
	// contains filtered or unexported fields
}

type InMemoryModelsStore struct {
	// contains filtered or unexported fields
}

type JSONMethod = jsonjs.JSONMethod

type KimiCodingOAuthOptions struct {
	Client         *http.Client
	Env            func(string) string
	Now            func() float64
	PollSleep      func(float64, context.Context, string) error
	RetrySleep     func(float64, context.Context) error
	RequestTimeout time.Duration
}

type LazyAPICapabilities struct{ FetchDeferred, CancelDeferred bool }

type LazyOAuthOptions struct {
	Name           string
	IsSubscription *bool
	LoginLabel     *string
	Load           func() (*OAuthAuth, error)
}

type ListError struct {
	ProviderID string `json:"provider_id"`
	Error      string `json:"error"`
}

type ListResult struct {
	Models []Model     `json:"models"`
	Errors []ListError `json:"errors,omitempty"`
}

type Message struct {
	Role                  string          `json:"role"`
	Content               MessageContent  `json:"content"`
	Timestamp             int64           `json:"timestamp"`
	Sections              SystemSections  `json:"sections,omitempty"`
	ToolsAdded            []Tool          `json:"toolsAdded,omitempty"`
	ToolsRemoved          []ToolReference `json:"toolsRemoved,omitempty"`
	API                   string          `json:"api,omitempty"`
	Provider              string          `json:"provider,omitempty"`
	Model                 string          `json:"model,omitempty"`
	ResponseModel         *string         `json:"responseModel,omitempty"`
	ResponseID            *string         `json:"responseId,omitempty"`
	ProviderThinkingLevel *string         `json:"providerThinkingLevel,omitempty"`
	ThinkingLevel         *string         `json:"thinkingLevel,omitempty"`
	Diagnostics           json.RawMessage `json:"diagnostics,omitempty"`
	Usage                 *Usage          `json:"usage,omitempty"`
	StopReason            string          `json:"stopReason,omitempty"`
	Deferred              json.RawMessage `json:"deferred,omitempty"`
	ErrorMessage          *string         `json:"errorMessage,omitempty"`
	RawStopReason         *string         `json:"rawStopReason,omitempty"`
	EndTurn               *bool           `json:"endTurn,omitempty"`
	ToolCallID            string          `json:"toolCallId,omitempty"`
	ToolName              string          `json:"toolName,omitempty"`
	// Details is a live JSON-shaped value. nil/Undefined mean absent; Null is explicit null.
	Details     any                        `json:"-"`
	NestedCalls json.RawMessage            `json:"nestedCalls,omitempty"`
	IsError     bool                       `json:"isError,omitempty"`
	Extra       map[string]json.RawMessage `json:"-"`
	// contains filtered or unexported fields
}

type MessageContent struct {
	Text   *string
	Blocks *BlockList
	// contains filtered or unexported fields
}

type MetaOAuthOptions struct {
	Client         *http.Client
	Now            func() float64
	PollSleep      func(float64, context.Context, string) error
	RequestTimeout time.Duration
}

type Model struct {
	// API and Provider identify Pi's wire implementation and provider separately.
	// Input declares supported modalities for transcript replay. The workspace
	// catalog fields below remain available to existing Go callers.
	API            string   `json:"api,omitempty"`
	Provider       string   `json:"provider,omitempty"`
	Input          []string `json:"input,omitempty"`
	ProviderID     string   `json:"provider_id"`
	ProviderVendor string   `json:"provider_vendor"`
	ProviderName   string   `json:"provider_name"`
	ID             string   `json:"id"`
	// ContextWindow is the model's input window in tokens: the vendor's own
	// figure when its list-models response carried one, otherwise this package's
	// fallback, otherwise 0 for "unknown". It is what the compaction budget is
	// capped against, so 0 must stay distinguishable from a real number.
	ContextWindow int `json:"context_window,omitempty"`
	// Capabilities is sparse tri-state metadata. Missing fields mean unknown,
	// not unsupported; explicit live discovery values refine adapter defaults.
	Capabilities protocol.ModelCapabilities `json:"capabilities,omitempty"`
}

type ModelPrice struct {
	InputPerM  float64 `json:"input_per_m"`  // USD per 1M input tokens
	OutputPerM float64 `json:"output_per_m"` // USD per 1M output tokens
	// CacheReadPerM / CacheWritePerM are optional explicit cache rates; zero means
	// "derive from InputPerM" (see Cost).
	CacheReadPerM  float64 `json:"cache_read_per_m,omitempty"`
	CacheWritePerM float64 `json:"cache_write_per_m,omitempty"`
}

type ModelProvider struct {
	ID              string
	Name            string
	BaseURL         any
	Headers         any
	Auth            *ProviderAuth
	GetModels       func() (*Array, error)
	GetAllModels    func() (*Array, error)
	RefreshModels   func(ModelRefreshContext) error
	FilterModels    func(*Array, any) (*Array, error)
	FilterAllModels func(*Array, any) (*Array, error)
	Stream          ModelStreamFunc
	StreamSimple    ModelStreamFunc
	FetchDeferred   DeferredStreamFunc
	CancelDeferred  func(context.Context, any, any, *Object) error
	GenerateImages  func(context.Context, any, any, *Object) (any, error)
	Classify        func(context.Context, any, any, *Object) (any, error)
}

type ModelRefreshContext struct {
	Context      context.Context
	Credential   any
	Stored       *Object
	Publish      func(ModelsPublication) (bool, error)
	AllowNetwork bool
	Force        *bool
}

type ModelStreamFunc func(context.Context, any, TranscriptContext, *Object) (*ProviderEventSource, error)

type Models struct {
	// contains filtered or unexported fields
}

type ModelsError struct {
	Code    string
	Message string
	Cause   error
}

type ModelsOptions struct {
	Persistence *ModelsPersistence
	Credentials *CredentialPersistence
	AuthContext *AuthContext
}

type ModelsPersistence struct {
	Read   func(context.Context, string) (any, error)
	Write  func(context.Context, string, any) error
	Delete func(context.Context, string) error
}

type ModelsPublication struct {
	Persist any
	Update  func() error
}

type ModelsPublicationScope struct {
	Context context.Context
	// contains filtered or unexported fields
}

type ModelsPublisher struct {
	// contains filtered or unexported fields
}

type ModelsRefreshFailure struct {
	ProviderID string
	Error      error
}

type ModelsRefreshOptions struct {
	AllowNetwork *bool
	// nil selects all providers; an empty non-nil slice selects none.
	Providers []string
	Force     *bool
	Now       func() int64
}

type ModelsRefreshResult struct {
	Aborted bool
	// Errors retain completion order, like Pi's Map, and original error identity.
	Errors []ModelsRefreshFailure
}

type ModelsRequestOptions struct {
	Values           any
	TransformHeaders func(any) (any, error)
	Now              func() int64
}

type NativeClient struct {
	// contains filtered or unexported fields
}

type NativeGenerationControls struct {
	ToolChoice        protocol.ToolChoice
	ParallelToolCalls *bool
	OutputSchema      *protocol.OutputSchema
}

type NativeProvider struct{ Tokens TokenSource }

type NativeProviderFailure struct {
	// contains filtered or unexported fields
}

type OAuthAuth struct {
	Name           string
	IsSubscription *bool
	LoginLabel     *string
	Login          func(ProviderAuthInteraction, *OAuthLoginOptions) (any, error)
	Refresh        func(context.Context, any) (any, error)
	ToAuth         func(any) (any, error)
}

type OAuthCallbackServer struct {
	RedirectURI string
	Wait        func() (any, error)
	Cancel      func()
	Close       func()
}

type OAuthCallbackServerOptions struct {
	ProviderName string
	Host         string
	Port         int
	Path         string
	RedirectHost *string
	State        *string
	Complete     func(string) (any, error)
	Context      context.Context
	TimeoutMS    *float64
}

type OAuthDeviceCodePollOptions struct {
	IntervalSeconds     any
	ExpiresInSeconds    any
	WaitBeforeFirstPoll bool
	Poll                func() (OAuthDeviceCodePollResult, error)
	Context             context.Context
	Now                 func() float64
	Sleep               func(float64, context.Context, string) error
}

type OAuthDeviceCodePollResult struct {
	Status          string
	Value           any
	Message         string
	IntervalSeconds any
}

type OAuthDiagnosticError struct {
	Name    *string
	Message string
	Code    any
	Errno   any
	Cause   any
	Stack   string
	// contains filtered or unexported fields
}

type OAuthLoginOptions struct{ GetDeviceID func() string }

type OAuthManualPrompt struct{ Message, Placeholder string }

type OAuthToken struct {
	// AccountID is the workspace_provider_accounts row id — the handle Report
	// uses to block/disable the account that served a failed request.
	AccountID string
	// AccessToken is the OAuth access token sent as the Bearer credential.
	AccessToken string
	// ProviderAccountID is the vendor-side account id (Codex chatgpt_account_id).
	ProviderAccountID string
	// ProjectID is the Cloud Code Assist project (Antigravity only).
	ProjectID string
	// Email is the account's login email, for diagnostics.
	Email string
}

type Object = jsonjs.Object

type OpenAIChatGPTOAuthOptions struct {
	Client        *http.Client
	PKCE          func() (PKCE, error)
	RandomValue   func() (string, error)
	StartCallback func(ChatGPTOAuthCallbackOptions) (*ChatGPTOAuthCallback, error)
	CallbackHost  *string
	Now           func() float64
}

type OpenAICodexOAuthOptions struct {
	Client        *http.Client
	PKCE          func() (PKCE, error)
	State         func() (string, error)
	CallbackHost  func() string
	StartCallback func(*OAuthCallbackServerOptions) (*OAuthCallbackServer, error)
	Now           func() float64
	Sleep         func(float64, context.Context, string) error
}

type OpenAICompletionsCompat struct {
	SupportsStore                               bool            `json:"supportsStore"`
	SupportsDeveloperRole                       bool            `json:"supportsDeveloperRole"`
	SupportsReasoningEffort                     bool            `json:"supportsReasoningEffort"`
	SupportsUsageInStreaming                    bool            `json:"supportsUsageInStreaming"`
	SupportsFinishReason                        bool            `json:"supportsFinishReason"`
	MaxTokensField                              string          `json:"maxTokensField"`
	RequiresToolResultName                      bool            `json:"requiresToolResultName"`
	RequiresAssistantAfterToolResult            bool            `json:"requiresAssistantAfterToolResult"`
	RequiresThinkingAsText                      bool            `json:"requiresThinkingAsText"`
	RequiresReasoningContentOnAssistantMessages bool            `json:"requiresReasoningContentOnAssistantMessages"`
	ThinkingFormat                              string          `json:"thinkingFormat"`
	OpenRouterRouting                           json.RawMessage `json:"openRouterRouting"`
	VercelGatewayRouting                        json.RawMessage `json:"vercelGatewayRouting"`
	ChatTemplateKwargs                          json.RawMessage `json:"chatTemplateKwargs"`
	ChatTemplateArgs                            json.RawMessage `json:"chatTemplateArgs"`
	ZaiToolStream                               bool            `json:"zaiToolStream"`
	SupportsThinkingTokenBudget                 bool            `json:"supportsThinkingTokenBudget"`
	ThinkingTokenBudgetField                    string          `json:"thinkingTokenBudgetField,omitempty"`
	SupportsStrictMode                          bool            `json:"supportsStrictMode"`
	SupportsOpenAIGrammarTools                  bool            `json:"supportsOpenAIGrammarTools"`
	SupportsMidConvoSystemMessages              bool            `json:"supportsMidConvoSystemMessages"`
	SupportsMidConvoToolAdditions               bool            `json:"supportsMidConvoToolAdditions"`
	CacheControlFormat                          string          `json:"cacheControlFormat,omitempty"`
	SendSessionAffinityHeaders                  bool            `json:"sendSessionAffinityHeaders"`
	SessionAffinityFormat                       string          `json:"sessionAffinityFormat"`
	SupportsLongCacheRetention                  bool            `json:"supportsLongCacheRetention"`
	VLLMPriority                                json.RawMessage `json:"vllmPriority,omitempty"`
}

type OpenAICompletionsStreamOptions struct {
	Options               json.RawMessage
	Client                *http.Client
	OnPayload             func(context.Context, json.RawMessage, json.RawMessage) (json.RawMessage, error)
	OnResponse            func(context.Context, CompletionsResponse, json.RawMessage) error
	OnProviderStreamEvent func(context.Context, *json.RawMessage, json.RawMessage) error
	Now                   func() int64
}

type OpenAIEmbedder struct {
	APIKey  string
	BaseURL string
	Model   string
	HTTP    *http.Client
}

type OpenAIProvider struct {
	APIKey string

	BaseURL string
	Compat  Compat
	// HTTP serves the non-streamed Chat path (absolute cap, no header deadline —
	// a buffered completion's headers arrive only once generation is done).
	HTTP *http.Client
	// StreamHTTP serves the SSE path, where a header deadline is meaningful. Nil
	// falls back to HTTP, so a caller that overrides only HTTP still works.
	StreamHTTP *http.Client
	// Vendor, when set, overrides Name() for OpenAI-compatible vendors served
	// through this wire (the pi-ai pattern: most providers are this API at a
	// different base URL). Empty keeps the stock "openai" identity.
	Vendor string
	// contains filtered or unexported fields
}

type OpenAIResponsesCompat struct {
	SupportsDeveloperRole           bool   `json:"supportsDeveloperRole"`
	SupportsMidConvoSystemMessages  bool   `json:"supportsMidConvoSystemMessages"`
	SessionAffinityFormat           string `json:"sessionAffinityFormat"`
	SupportsLongCacheRetention      bool   `json:"supportsLongCacheRetention"`
	SupportsStrictMode              bool   `json:"supportsStrictMode"`
	SupportsOpenAIGrammarTools      bool   `json:"supportsOpenAIGrammarTools"`
	SupportsAdditionalTools         bool   `json:"supportsAdditionalTools"`
	SupportsToolSearch              bool   `json:"supportsToolSearch"`
	SupportsExplicitPromptCacheMode bool   `json:"supportsExplicitPromptCacheMode"`
	SupportsMaxOutputTokens         bool   `json:"supportsMaxOutputTokens"`
}

type OpenAIResponsesProvider struct {
	APIKey string

	BaseURL    string
	HTTP       *http.Client
	StreamHTTP *http.Client
	// Vendor overrides Name() when this Responses wire is selected for a model
	// belonging to an ordinary OpenAI provider row. Empty preserves the explicit
	// openai-responses identity.
	Vendor string
	// contains filtered or unexported fields
}

type OpenAIResponsesStreamOptions = OpenAICompletionsStreamOptions

type OpenAIWire string

type OpenRouterOAuthOptions struct {
	Client          *http.Client
	PKCE            func() (PKCE, error)
	RandomUUID      func() (string, error)
	StartCallback   func(*OAuthCallbackServerOptions) (*OAuthCallbackServer, error)
	CallbackHost    func() string
	LoginTimeoutMS  *float64
	ExchangeTimeout time.Duration
}

type PKCE struct {
	Verifier  string `json:"verifier"`
	Challenge string `json:"challenge"`
}

type PayloadYield func(work func() error) error

type PiMessagesResponseError struct {
	Message           string
	Code              *string
	DiagnosticDetails *Object
	Status            int
	Headers           http.Header
}

type PiMessagesStreamOptions struct {
	Values                *Object
	Client                *http.Client
	OnPayload             func(context.Context, any, *Object) (any, error)
	OnResponse            func(context.Context, CompletionsResponse, *Object) error
	OnProviderStreamEvent func(context.Context, any, *Object) error
	Now                   func() float64
	ErrorStack            func(error) string
	// contains filtered or unexported fields
}

type PreparationError struct{ Cause error }

type Pricing map[string]ModelPrice

type Property = jsonjs.Property

type Provider interface {
	protocol.LLMProvider
	ID() string
	Vendor() string
	DisplayName() string
	BaseURL() string
	APIKey() string
	ListModels(ctx context.Context) ([]Model, error)
}

type ProviderAuth struct {
	APIKey *APIKeyAuth
	OAuth  *OAuthAuth
}

type ProviderAuthInteraction struct {
	Context context.Context
	Prompt  func(context.Context, *Object) (any, error)
	Notify  func(*Object)
}

type ProviderClassifier struct {
	Classify func(context.Context, any, any, *Object) (any, error)
}

type ProviderEventSource struct {
	Next   func(context.Context) (AssistantMessageEvent, bool, error)
	Result func(context.Context) (*Message, bool, error)
}

type ProviderFactoryOptions struct {
	ID              string
	Name            *string
	BaseURL         any
	Headers         any
	Auth            *ProviderAuth
	Models          *Array
	FetchModels     func(ModelRefreshContext) (*Array, error)
	FilterModels    func(*Array, any) (*Array, error)
	FilterAllModels func(*Array, any) (*Array, error)
	API             *ProviderStreams
	APIs            map[string]*ProviderStreams
	Images          map[string]*ProviderImages
	Classifiers     map[string]*ProviderClassifier
	Now             func() int64
}

type ProviderImages struct {
	GenerateImages func(context.Context, any, any, *Object) (any, error)
}

type ProviderModelCatalog struct {
	RefreshModels func(ModelRefreshContext) error
	// contains filtered or unexported fields
}

type ProviderOption struct {
	ID      string `json:"id"`
	Label   string `json:"label"`
	Auth    string `json:"auth"`
	Purpose string `json:"purpose"`
	BaseURL string `json:"base_url,omitempty"`
}

type ProviderStreams struct {
	Stream         ModelStreamFunc
	StreamSimple   ModelStreamFunc
	FetchDeferred  DeferredStreamFunc
	CancelDeferred func(context.Context, any, any, *Object) error
}