pigo

type API string

type APIModule struct {
	API          API
	Stream       APIStreamFunc
	StreamSimple APISimpleStreamFunc
	Capabilities ModelCapabilities
}

type APIModuleFactory func() APIModule

type APIOptionValidation struct {
	ValidateOptions       func(Model, ProviderStreamOptions) error
	ValidateSimpleOptions func(Model, SimpleStreamOptions) error
}

type APISimpleStreamFunc func(Model, Context, SimpleStreamOptions) *AssistantMessageEventStream

type APIStreamFunc func(Model, Context, ProviderStreamOptions) *AssistantMessageEventStream

type AnthropicMessagesCompat struct {
	SupportsEagerToolInputStreaming *bool
	ForceAdaptiveThinking           *bool
	SupportsLongCacheRetention      *bool
	AllowEmptySignature             *bool
}

type AnthropicMessagesProviderOptions struct {
	StreamOptions
}

type AssistantMessage struct {
	Content              []ContentBlock
	HostedToolExecutions []HostedToolExecution
	API                  API
	Provider             Provider
	Model                string
	ResponseModel        string
	ResponseID           string
	ThinkingLevel        ModelThinkingLevel
	Usage                Usage
	UsageReported        bool
	StopReason           StopReason
	ErrorMessage         string
	Diagnostics          []AssistantMessageDiagnostic
	Timestamp            time.Time
}

type AssistantMessageDiagnostic struct {
	Type      string
	Timestamp time.Time
	Error     *DiagnosticErrorInfo
	Details   map[string]any
}

type AssistantMessageEvent struct {
	Type          AssistantMessageEventType
	ContentIndex  int
	Delta         string
	Content       string
	ToolCall      ToolCall
	Partial       AssistantMessage
	Reason        StopReason
	Message       AssistantMessage
	Error         AssistantMessage
	DroppedEvents int
}

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

type AssistantMessageEventType string

type AuthConfig struct {
	Type   AuthType
	APIKey string
	OAuth  *OAuthCredentials

	// OnOAuthCredentialsRefreshed is called synchronously after OAuth
	// credentials are refreshed. The callback owns any persistence. The
	// refreshed credentials are passed by value, and the library does not
	// mutate OAuth or the caller's auth map. Concurrent authorization calls
	// may invoke the callback concurrently, so external storage must provide
	// its own synchronization.
	OnOAuthCredentialsRefreshed func(provider Provider, credentials OAuthCredentials)
}

type AuthType string

type CacheRetention string

type CapabilitySupport string

type CommandCodeCompat struct {
	API API
}

type CommandCodeModelsResult struct {
	Models  []Model
	Source  CommandCodeModelsSource
	Warning string
}

type CommandCodeModelsSource string

type CommonProviderOptions struct {
	APIKey                string
	Auth                  map[Provider]AuthConfig
	HTTPClient            *http.Client
	Headers               map[string]string
	MaxTokens             int
	Temperature           *float64
	Transport             Transport
	CacheRetention        CacheRetention
	SessionID             string
	OnPayload             func(payload any, model Model) any
	OnResponse            func(response ProviderResponse, model Model)
	OnProviderStreamEvent func(data json.RawMessage, model Model) error
	ServiceTier           string
	TimeoutMs             int
	MaxRetries            int
	MaxRetryDelay         int
	Metadata              map[string]any
	RequestContext        context.Context
	PreviousResponseID    string
	Truncation            string
	Observer              Observer
	ResponseFormat        *ResponseFormat
}

type ContentBlock interface {
	// contains filtered or unexported methods
}

type Context struct {
	SystemPrompt string
	Messages     []Message
	Tools        []Tool
	HostedTools  []HostedTool
}

type DeepSeekProviderOptions struct {
	StreamOptions
}

type DiagnosticErrorInfo struct {
	Name    string
	Message string
	Stack   string
	Code    any
}

type GoogleProviderOptions struct {
	StreamOptions
	ToolChoice string
	Thinking   *GoogleThinkingConfig
}

type GoogleThinkingConfig struct {
	Enabled      bool
	BudgetTokens int // -1 for dynamic, 0 to disable
	Level        string
}

type HTTPDelivery string

type HTTPObservation struct {
	Delivery           HTTPDelivery
	StatusCode         int
	ErrorType          string
	ErrorCode          string
	ErrorBodyTruncated bool
	Err                error
}

type HTTPStreamClient struct {
	HTTPClient     *http.Client
	MaxRetries     int
	BaseRetryDelay time.Duration
	MaxRetryDelay  time.Duration
}

type HandoffCredentials struct {
	Version   int                              `json:"version"`
	Providers map[Provider]HandoffProviderAuth `json:"providers"`
}

type HandoffOAuthCredentials struct {
	AccessToken  string `json:"accessToken,omitempty"`
	RefreshToken string `json:"refreshToken,omitempty"`
	ExpiresUnix  int64  `json:"expiresUnix,omitempty"`
}

type HandoffProviderAuth struct {
	Type   AuthType                 `json:"type"`
	APIKey string                   `json:"apiKey,omitempty"`
	OAuth  *HandoffOAuthCredentials `json:"oauth,omitempty"`
}

type HostedTool struct {
	Type HostedToolType
	Name string
}

type HostedToolCapabilities struct {
	WebSearch  bool
	Fetch      bool
	CodeRunner bool
	Excel      bool
}

type HostedToolExecution struct {
	ID               string
	Type             HostedToolType
	Name             string
	ProviderToolName string
	Arguments        map[string]any
	Result           map[string]any
}

type HostedToolType string

type ImageContent struct {
	Data     string
	MIMEType string
}

type InputType string

type KimiCodingProviderOptions struct {
	AnthropicMessagesProviderOptions
}

type KiroBufferedConfig struct {
	API                                   API
	Provider                              Provider
	Region, ProfileARN, Origin, UserAgent string
	SystemPromptPolicy                    string
	Schemas                               map[string]json.RawMessage
	RequestIDs                            func(context.Context) (KiroRequestIDs, error)
	Credentials                           func(context.Context, KiroCredentialScope) (KiroScopedCredential, error)
	RoundTrip                             func(*http.Request) (*http.Response, error)
}

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

type KiroCatalogFetchConfig struct {
	Scope               KiroCredentialScope
	Origin, UserAgent   string
	MaxBytes, MaxModels int
	Clock               func(context.Context) (time.Time, error)
	Credentials         func(context.Context, KiroCredentialScope) (KiroScopedCredential, error)
	RoundTrip           func(*http.Request) (*http.Response, error)
}

type KiroCatalogIDKind = kiroCatalogIDKind

type KiroCredentialKind = kiroCredentialKind

type KiroCredentialScope = kiroCredentialScope

type KiroDesktopRefreshConfig struct {
	Scope                             KiroCredentialScope
	UserAgent                         string
	RefreshToken                      string `json:"-"`
	MaxRequestBytes, MaxResponseBytes int
	MaxLifetime, RefreshSkew          time.Duration
	Clock                             func(context.Context) (time.Time, error)
	RoundTrip                         func(*http.Request) (*http.Response, error)
}

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

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

type KiroIDCRefreshConfig struct {
	Scope                             KiroCredentialScope
	UserAgent                         string
	ClientID                          string `json:"-"`
	ClientSecret                      string `json:"-"`
	RefreshToken                      string `json:"-"`
	MaxRequestBytes, MaxResponseBytes int
	MaxLifetime, RefreshSkew          time.Duration
	Clock                             func(context.Context) (time.Time, error)
	RoundTrip                         func(*http.Request) (*http.Response, error)
}

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

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

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

type KiroIncrementalConfig KiroBufferedConfig

type KiroIncrementalOptions KiroLiveTextOptions

type KiroLiveTextConfig struct {
	API                                   API
	Provider                              Provider
	Region, ProfileARN, Origin, UserAgent string
	SystemPromptPolicy                    string
	RequestIDs                            func(context.Context) (KiroRequestIDs, error)
	Credentials                           func(context.Context, KiroCredentialScope) (KiroScopedCredential, error)
	RoundTrip                             func(*http.Request) (*http.Response, error)
}

type KiroLiveTextOptions struct {
	AutoHTTP        bool
	SessionAffinity *KiroSessionAffinity
}

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

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

type KiroRequestIDs struct{ ConversationID, InvocationID string }

type KiroScopedCredential = kiroScopedCredential

type KiroSessionAffinity struct {
	Tenant string
	Key    []byte `json:"-"`
}

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

type Message interface {
	// contains filtered or unexported methods
}

type MessageTransformer func(transformContext, []Message) []Message

type MistralProviderOptions struct {
	StreamOptions
	ToolChoice      string
	PromptMode      string
	ReasoningEffort string
}

type Model struct {
	ID                            string
	Name                          string
	API                           API
	Provider                      Provider
	BaseURL                       string
	Reasoning                     bool
	ThinkingLevelMap              ThinkingLevelMap
	SamplingParams                SamplingParams
	SamplingParamsByThinkingLevel SamplingParamsByThinkingLevel
	Capabilities                  ModelCapabilities
	Input                         []InputType
	HostedTools                   HostedToolCapabilities
	Cost                          UsageCost
	CostTiers                     []ModelCostTier
	ContextWindow                 int
	MaxTokens                     int
	Headers                       map[string]string
	Compat                        ProviderCompat
}

type ModelCapabilities struct {
	Streaming CapabilitySupport `json:"streaming"`
	Tools     CapabilitySupport `json:"tools"`
	// Native custom input and Lark/regex grammars are model-only facts. API and
	// provider defaults never grant these capabilities to an entire catalog.
	CustomTools  CapabilitySupport `json:"custom_tools"`
	GrammarTools CapabilitySupport `json:"grammar_tools"`
	// ToolAdditions permits position-anchored function declarations on Responses.
	// Like custom tools, it is granted only by exact registered model facts.
	ToolAdditions              CapabilitySupport    `json:"tool_additions"`
	StrictTools                CapabilitySupport    `json:"strict_tools"`
	ToolChoice                 CapabilitySupport    `json:"tool_choice"`
	Reasoning                  CapabilitySupport    `json:"reasoning"`
	ReasoningLevels            CapabilitySupport    `json:"reasoning_levels"`
	SupportedReasoningLevels   []ModelThinkingLevel `json:"supported_reasoning_levels,omitempty"`
	DefaultReasoningLevel      ModelThinkingLevel   `json:"default_reasoning_level,omitempty"`
	Temperature                CapabilitySupport    `json:"temperature"`
	TemperatureReasoningLevels []ModelThinkingLevel `json:"temperature_reasoning_levels,omitempty"`
	TopP                       CapabilitySupport    `json:"top_p"`
	TopPReasoningLevels        []ModelThinkingLevel `json:"top_p_reasoning_levels,omitempty"`
	ParallelToolCalls          CapabilitySupport    `json:"parallel_tool_calls"`
}

type ModelCapabilitySnapshot struct {
	Provider        Provider                   `json:"provider"`
	ModelID         string                     `json:"model_id"`
	WireAPI         API                        `json:"wire_api"`
	BaseURL         string                     `json:"base_url"`
	Input           []InputType                `json:"input,omitempty"`
	ContextWindow   int                        `json:"context_window,omitempty"`
	MaxOutputTokens int                        `json:"max_output_tokens,omitempty"`
	Capabilities    ModelCapabilities          `json:"capabilities"`
	ResponseFormats ResponseFormatCapabilities `json:"response_formats"`
	HostedTools     []HostedToolType           `json:"hosted_tools,omitempty"`
}

type ModelCostTier struct {
	InputTokensAbove int
	Rates            UsageCost
}

type ModelThinkingLevel string

type OAuthCredentials struct {
	AccessToken  string
	RefreshToken string
	ExpiresUnix  int64
}

type Observer interface {
	RequestObserver
	StreamObserver
}

type OpenAICodexProviderOptions struct {
	StreamOptions
}

type OpenAICompletionsCompat struct {
	SupportsMidConvoSystemMessages              *bool
	SupportsStore                               *bool
	SupportsDeveloperRole                       *bool
	SupportsReasoningEffort                     *bool
	SupportsUsageInStreaming                    *bool
	MaxTokensField                              string
	RequiresToolResultName                      *bool
	RequiresAssistantAfterToolResult            *bool
	RequiresThinkingAsText                      *bool
	RequiresReasoningContentOnAssistantMessages *bool
	ThinkingFormat                              string
	OpenRouterRouting                           *OpenRouterRouting
	VercelGatewayRouting                        *VercelGatewayRouting
	ZaiToolStream                               *bool
	SupportsStrictMode                          *bool
	CacheControlFormat                          string
	SendSessionAffinityHeaders                  *bool
	SupportsLongCacheRetention                  *bool
}

type OpenAICompletionsProviderOptions struct {
	StreamOptions
}

type OpenAIResponsesCompat struct {
	SupportsDeveloperRole           *bool
	SupportsMidConvoSystemMessages  *bool
	SendSessionIdHeader             *bool
	SupportsLongCacheRetention      *bool
	SupportsExplicitPromptCacheMode *bool
	SupportsMaxOutputTokens         *bool
	SupportsJSONOutput              bool
	SupportsJSONSchema              bool
}

type OpenAIResponsesProviderOptions struct {
	StreamOptions
}

type OpenRouterRouting struct {
	AllowFallbacks         *bool
	RequireParameters      *bool
	DataCollection         string
	ZDR                    *bool
	EnforceDistillableText *bool
	Order                  []string
	Only                   []string
	Ignore                 []string
	Quantizations          []string
	Sort                   any
	MaxPrice               map[string]any
	PreferredMinThroughput any
	PreferredMaxLatency    any
}

type Option func(*StreamOptions)

type Provider string

type ProviderAuth struct {
	RequiresOAuth        bool
	EnvAPIKeyName        string
	EnvAPIKeyNames       []string
	ResolveAuthorization ProviderAuthResolveFunc
}

type ProviderAuthResolveFunc func(Provider, AuthConfig, *http.Client, context.Context) (string, error)

type ProviderCapabilities struct {
	SupportsStreaming          bool
	SupportsJSONOutput         bool
	SupportsJSONSchema         bool
	SupportsSession            bool
	SupportsPromptCacheKey     bool
	SupportsPromptCacheControl bool
	SupportsReasoningSummary   bool
	SupportsTextVerbosity      bool
	SupportsThinkingBudget     bool
	SupportsToolChoice         bool
	HostedTools                HostedToolCapabilities
}

type ProviderCapabilitySnapshot struct {
	Provider Provider                  `json:"provider"`
	Models   []ModelCapabilitySnapshot `json:"models"`
}

type ProviderCompat interface {
	// contains filtered or unexported methods
}

type ProviderFailure struct {
	Kind    string
	Reason  string
	Message string
	// Code and Type retain decoded OpenAI Responses error fields when present.
	// Empty values also cover other protocols and older stored diagnostics.
	Code string
	Type string
}

type ProviderHTTPPolicy struct {
	// Non-positive limits use DefaultMaxProviderErrorBytes.
	MaxErrorBodyBytes int64
	Observe           func(HTTPObservation)
}

type ProviderModule struct {
	Provider          Provider
	Models            map[string]Model
	Auth              ProviderAuth
	Quota             QuotaQuerier
	Capabilities      ProviderCapabilities
	ModelCapabilities ModelCapabilities
	BuildOptions      ProviderOptionsBuildFunc
	NormalizeOptions  ProviderOptionsNormalizeFunc
}

type ProviderModuleFactory func() ProviderModule

type ProviderOptionsBuildFunc func(Model, SimpleStreamOptions) ProviderStreamOptions

type ProviderOptionsNormalizeFunc func(Model, ProviderStreamOptions) ProviderStreamOptions

type ProviderResponse struct {
	Status  int
	Headers map[string]string
}

type QuotaBalance struct {
	ID        string   `json:"id"`
	Unit      string   `json:"unit"`
	Total     *float64 `json:"total,omitempty"`
	Used      *float64 `json:"used,omitempty"`
	Remaining *float64 `json:"remaining,omitempty"`
}

type QuotaIssue struct {
	Section    string `json:"section"`
	Message    string `json:"message"`
	HTTPStatus int    `json:"httpStatus,omitempty"`
}

type QuotaQuerier interface {
	QueryQuota(context.Context, QuotaQueryOptions) (QuotaResult, error)
}

type QuotaQueryError struct {
	Provider   Provider
	Section    string
	HTTPStatus int
	Err        error
}

type QuotaQueryOptions struct {
	APIKey     string
	Auth       map[Provider]AuthConfig
	BaseURL    string
	HTTPClient *http.Client
}

type QuotaResult struct {
	Provider     Provider           `json:"provider"`
	QueriedAt    time.Time          `json:"queriedAt"`
	Balances     []QuotaBalance     `json:"balances"`
	Windows      []QuotaWindow      `json:"windows"`
	Subscription *QuotaSubscription `json:"subscription,omitempty"`
	Unavailable  []QuotaIssue       `json:"unavailable,omitempty"`
}

type QuotaSubscription struct {
	Plan        string     `json:"plan"`
	Status      string     `json:"status"`
	PeriodStart *time.Time `json:"periodStart,omitempty"`
	PeriodEnd   *time.Time `json:"periodEnd,omitempty"`
}

type QuotaWindow struct {
	// BalanceIDs identifies the pools affected by this window. Nil means the
	// provider did not report a pool scope; it does not mean all balances.
	BalanceIDs []string   `json:"balanceIds,omitempty"`
	ID         string     `json:"id"`
	Unit       string     `json:"unit"`
	Limit      *float64   `json:"limit,omitempty"`
	Used       *float64   `json:"used,omitempty"`
	Remaining  *float64   `json:"remaining,omitempty"`
	ResetsAt   *time.Time `json:"resetsAt,omitempty"`
}

type Registry[K comparable, V any] struct {
	// contains filtered or unexported fields
}

type RequestObserver interface {
	OnRequestStart(ctx context.Context, model Model, payload any) context.Context
	OnRequestComplete(ctx context.Context, model Model, result AssistantMessage, duration time.Duration)
	OnRequestError(ctx context.Context, model Model, err error, duration time.Duration)
}

type ResponseFormat struct {
	Type       ResponseFormatType
	Name       string
	JSONSchema json.RawMessage
	Strict     bool
}

type ResponseFormatCapabilities struct {
	JSONObject CapabilitySupport `json:"json_object"`
	JSONSchema CapabilitySupport `json:"json_schema"`
}

type ResponseFormatType string

type SamplingParams map[string]any

type SamplingParamsByThinkingLevel map[ModelThinkingLevel]SamplingParams

type SessionResourceCleanup func(sessionID string)

type SessionResourceCleanupOptional func()

type StopReason string

type StreamObserver interface {
	OnStreamEvent(ctx context.Context, model Model, event AssistantMessageEvent)
	OnStreamFinish(ctx context.Context, model Model, final AssistantMessage, eventCount int, droppedCount int, duration time.Duration)
}

type StreamOptions struct {
	// Common remains as a legacy compatibility snapshot. Flat fields are the
	// authoritative state and Common is rebuilt from them at conversion boundaries.
	Common CommonProviderOptions

	// Legacy flat common fields remain the direct access path for callers.
	APIKey            string
	Auth              map[Provider]AuthConfig
	HTTPClient        *http.Client
	Headers           map[string]string
	MaxTokens         int
	Temperature       *float64
	TopP              *float64
	SamplingParams    SamplingParams
	ParallelToolCalls *bool
	Transport         Transport
	CacheRetention    CacheRetention
	SessionID         string
	OnPayload         func(payload any, model Model) any
	OnResponse        func(response ProviderResponse, model Model)
	// OnProviderStreamEvent observes valid provider JSON events before normalization.
	// The data is an isolated copy; returning an error stops the request without retry.
	OnProviderStreamEvent func(data json.RawMessage, model Model) error
	ServiceTier           string
	TimeoutMs             int
	MaxRetries            int
	MaxRetryDelay         int
	Metadata              map[string]any
	RequestContext        context.Context
	Reasoning             ThinkingLevel
	ReasoningSummary      string
	TextVerbosity         string
	ThinkingBudgetTokens  int
	ToolChoice            string
	PreviousResponseID    string
	Truncation            string
	ThinkingBudgets       ThinkingBudgets
	Observer              Observer
	ResponseFormat        *ResponseFormat
}

type SystemMessage struct {
	Content      string
	Sections     map[string]*string
	ToolsAdded   []Tool
	ToolsRemoved []ToolReference
	Timestamp    time.Time
}

type TextContent struct {
	Text          string
	TextSignature string
}

type TextSignatureV1 struct {
	V     int    `json:"v"`
	ID    string `json:"id"`
	Phase string `json:"phase,omitempty"`
}

type ThinkingBudgets struct {
	Minimal int
	Low     int
	Medium  int
	High    int
}

type ThinkingContent struct {
	Thinking          string
	ThinkingSignature string
	Redacted          bool
}

type ThinkingLevel string

type ThinkingLevelMap map[ModelThinkingLevel]string

type Tool struct {
	Name                string                   `json:"name"`
	Description         string                   `json:"description,omitempty"`
	Parameters          any                      `json:"parameters,omitempty"`
	OutputSchema        any                      `json:"outputSchema,omitempty"`
	Validator           ToolArgumentsValidator   `json:"-"`
	ConstrainedSampling *ToolConstrainedSampling `json:"constrainedSampling,omitempty"`
}

type ToolArgumentsValidator interface {
	Validate(map[string]any) (map[string]any, error)
}

type ToolArgumentsValidatorFunc func(map[string]any) (map[string]any, error)

type ToolCall struct {
	ID   string
	Name string
	// Namespace is provider replay metadata, not a local tool routing key.
	Namespace string
	Arguments map[string]any
	// RawArguments is the original JSON object text when the provider exposes
	// it. It is available on completed calls from Responses, OpenAI chat
	// completions, DeepSeek chat, Anthropic Messages and Command Code. Unlike Arguments, it
	// preserves exact number literals and duplicate keys. It is ephemeral
	// provider evidence and is not part of serialized conversation history.
	RawArguments     string `json:"-"`
	ThoughtSignature string
}

type ToolConstrainedSampling struct {
	Type       string `json:"type"`
	Mode       string `json:"mode,omitempty"`
	Syntax     string `json:"syntax,omitempty"`
	Definition string `json:"definition,omitempty"`
}

type ToolReference struct {
	Name string `json:"name"`
}

type ToolResultMessage struct {
	ToolCallID string
	ToolName   string
	Content    []ContentBlock
	Details    any
	IsError    bool
	Timestamp  time.Time
}

type ToolSamplingDecision struct {
	Representation string
	InputProperty  string
}

type ToolStateChanges struct {
	ToolsAdded   []Tool
	ToolsRemoved []ToolReference
}

type TranscriptContext struct {
	Messages    []Message
	HostedTools []HostedTool
}

type Transport string

type Usage struct {
	Input       int
	Output      int
	CacheRead   int
	CacheWrite  int
	TotalTokens int
	Cost        UsageCost
}

type UsageCost struct {
	Input      float64
	Output     float64
	CacheRead  float64
	CacheWrite float64
	Total      float64
}

type UserMessage struct {
	Content   any
	Timestamp time.Time
}

type VercelGatewayRouting struct {
	Only  []string
	Order []string
}