providers

type AnthropicProvider struct {
	*BaseProvider
}

type Attachment struct {
	Kind      AttachmentKind
	MediaType string
	Data      []byte
}

type AttachmentKind string

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

type BedrockProvider struct {
	*BaseProvider
	// contains filtered or unexported fields
}

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

type CatalogCost struct {
	Input      float64 `json:"input,omitempty"`
	Output     float64 `json:"output,omitempty"`
	CacheRead  float64 `json:"cache_read,omitempty"`
	CacheWrite float64 `json:"cache_write,omitempty"`
}

type CatalogLimit struct {
	Context int `json:"context,omitempty"`
	Output  int `json:"output,omitempty"`
}

type CatalogModalities struct {
	Input  []string `json:"input,omitempty"`
	Output []string `json:"output,omitempty"`
}

type CatalogModel struct {
	ID          string            `json:"id"`
	Name        string            `json:"name"`
	Family      string            `json:"family,omitempty"`
	Attachment  bool              `json:"attachment,omitempty"`
	Reasoning   bool              `json:"reasoning,omitempty"`
	ToolCall    bool              `json:"tool_call,omitempty"`
	Temperature bool              `json:"temperature,omitempty"`
	OpenWeights bool              `json:"open_weights,omitempty"`
	Knowledge   string            `json:"knowledge,omitempty"`
	ReleaseDate string            `json:"release_date,omitempty"`
	LastUpdated string            `json:"last_updated,omitempty"`
	Modalities  CatalogModalities `json:"modalities,omitempty"`
	Cost        CatalogCost       `json:"cost,omitempty"`
	Limit       CatalogLimit      `json:"limit,omitempty"`
}

type CatalogProvider struct {
	ID     string                  `json:"id"`
	Name   string                  `json:"name"`
	NPM    string                  `json:"npm,omitempty"`
	API    string                  `json:"api,omitempty"`
	Doc    string                  `json:"doc,omitempty"`
	Env    []string                `json:"env,omitempty"`
	Models map[string]CatalogModel `json:"models"`
}

type CatalogSource string

type Chunk struct {
	Content   string
	ToolCalls []ToolCall
	Done      bool
	// Usage is a provider-reported cumulative snapshot for this request, not
	// a delta. Nil means omitted/unknown, including interrupted streams.
	Usage *Usage
	// Err carries a fatal streaming error (transport drop, scanner failure,
	// parse error on the upstream protocol). Consumers MUST treat a non-nil
	// Err as "this stream did not complete cleanly" — committing the
	// accumulated content as if Done would be a silent wrong answer. The
	// producer emits at most one Err chunk and then closes the channel.
	Err error
}

type ClassifiedError struct {
	Original  error
	Reason    FailoverReason
	Retryable bool
	Cooldown  time.Duration
}

type ErrorClassifier struct {
}

type FactoryConfig struct {
	Name     string
	Type     string
	APIKey   string
	BaseURL  string
	Models   []Model
	Headers  map[string]string
	AuthType string // "oauth" to use stored OAuth tokens via ResolveOAuthAPIKey
}

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

type FailoverReason string

type FlatModel struct {
	ProviderID   string
	ProviderName string
	Model        CatalogModel
}

type GeminiProvider struct {
	*BaseProvider
}

type HTTPError struct {
	StatusCode int
	Body       string
}

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

type Message struct {
	Role       string
	Content    string
	ToolCalls  []ToolCall
	ToolCallID string
	// Attachments carry non-text inputs (images today, potentially
	// audio/PDF later). Empty for the common case so a string Content
	// still serializes as a plain string-content message to every
	// provider. When non-empty, the provider's request builder emits
	// the format-specific multi-part body (anthropic content blocks,
	// OpenAI content parts, gemini inlineData). Order is preserved.
	Attachments []Attachment
}

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

type Model struct {
	ID                string
	Name              string
	Family            string
	MaxTokens         int
	ContextWindow     int
	MaxOutputTokens   int // explicit completion ceiling, independent of context capacity
	DefaultMaxTokens  int
	CostIn            float64
	CostOut           float64
	CostCacheIn       float64
	CostCacheOut      float64
	SupportsTools     bool
	SupportsStreaming bool
	SupportsVision    bool
	Reasoning         bool
	StructuredOutput  bool
	Temperature       bool
	Attachment        bool
	OpenWeights       bool
	ReleaseDate       string
	LastUpdated       string
	Knowledge         string
	Status            string
	InputModalities   []string
	OutputModalities  []string
}

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

type ModelFetcher interface {
	Fetch(ctx context.Context, providerType, apiKey, baseURL string) ([]Model, error)
}

type OllamaProvider struct {
	*OpenAIProvider
}

type OpenAICompatProvider struct {
	*OpenAIProvider
}

type OpenAIProvider struct {
	*BaseProvider
}

type Provider interface {
	Name() string
	Complete(ctx context.Context, req Request) (Response, error)
	Stream(ctx context.Context, req Request) (<-chan Chunk, error)
	Models() []Model
}

type ProviderDefaults struct {
	Type      string
	Name      string
	APIKeyEnv string
	BaseURL   string
	Method    ProviderMethod // "native" for non-OpenAI-compat, "openai-compat" otherwise
}

type ProviderMethod string

type Request struct {
	Model         string
	Messages      []Message
	Tools         []Tool
	MaxTokens     int
	Temperature   float64
	SystemPrompt  string
	ThinkingLevel string // off|minimal|low|medium|high|x-high — passed through from config
	Metadata      map[string]any
}

type Response struct {
	ID        string
	Model     string
	Content   string
	ToolCalls []ToolCall
	Usage     Usage
	// UsageReported distinguishes a reported all-zero usage object from
	// omitted/null usage. OpenAI Chat Completions populates this explicitly;
	// older adapters may leave it false even when numeric usage is present.
	UsageReported bool
}

type TOMLCost struct {
	Input      float64 `toml:"input"`
	Output     float64 `toml:"output"`
	CacheRead  float64 `toml:"cache_read"`
	CacheWrite float64 `toml:"cache_write"`
}

type TOMLExperimental struct {
	Modes map[string]TOMLExperimentalMode `toml:"modes"`
}

type TOMLExperimentalMode struct {
	Cost     TOMLCost              `toml:"cost"`
	Provider *TOMLProviderOverride `toml:"provider,omitempty"`
}

type TOMLExtends struct {
	From string `toml:"from"`
}

type TOMLLimit struct {
	Context int `toml:"context"`
	Output  int `toml:"output"`
	Input   int `toml:"input"`
}

type TOMLModalities struct {
	Input  []string `toml:"input"`
	Output []string `toml:"output"`
}

type TOMLModel struct {
	Name             string                `toml:"name"`
	Family           string                `toml:"family"`
	MaxTokens        int                   `toml:"max_tokens"`
	Reasoning        *bool                 `toml:"reasoning"`
	ToolCall         *bool                 `toml:"tool_call"`
	StructuredOutput *bool                 `toml:"structured_output"`
	Temperature      *bool                 `toml:"temperature"`
	Attachment       *bool                 `toml:"attachment"`
	OpenWeights      *bool                 `toml:"open_weights"`
	Modalities       TOMLModalities        `toml:"modalities"`
	Cost             TOMLCost              `toml:"cost"`
	Extends          *TOMLExtends          `toml:"extends"`
	ReleaseDate      string                `toml:"release_date"`
	LastUpdated      string                `toml:"last_updated"`
	Knowledge        string                `toml:"knowledge"`
	Status           string                `toml:"status"`
	Interleaved      any                   `toml:"interleaved"`
	Limit            TOMLLimit             `toml:"limit"`
	Experimental     *TOMLExperimental     `toml:"experimental,omitempty"`
	ProviderOverride *TOMLProviderOverride `toml:"provider,omitempty"`
}

type TOMLProviderOverride struct {
	NPM     string            `toml:"npm"`
	API     string            `toml:"api"`
	Body    map[string]any    `toml:"body"`
	Headers map[string]string `toml:"headers"`
	Shape   string            `toml:"shape"`
}

type TokenLimitResolver func(model string) (contextWindow, outputTokens int, err error)

type Tool struct {
	Name        string
	Description string
	Parameters  json.RawMessage
}

type ToolCall struct {
	ID        string
	Name      string
	Arguments string
}

type Usage struct {
	InputTokens       int
	OutputTokens      int
	CachedInputTokens int
}