provider

type APIError struct {
	Provider   string
	StatusCode int
	RetryAfter time.Duration // parsed from the Retry-After header; 0 if absent
	Body       string
}

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

type BaseURLReporter interface {
	BaseURL() string
}

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

type CacheVerdict string

type CatalogModel struct {
	ID              string
	Name            string
	ActiveByDefault bool
	InputPricePerM  float64 // USD per 1M input tokens (0 = unknown)
	OutputPricePerM float64 // USD per 1M output tokens (0 = unknown)
	SupportsImages  bool    // whether the model accepts image input
	ContextWindow   int     // total context length in tokens (0 = unknown → byte-size fallback)
	// MaxOutputTokens is the most output the model produces in one response.
	// 0 means unknown: no explicit limit is sent and the provider's own default
	// applies. NEVER guess this upward — a value above the model's real ceiling
	// makes every request fail, so understate it when a published figure is not
	// at hand. Only Anthropic entries carry a value today: the OpenAI-compatible
	// path (also used for OpenRouter and Ollama) would send it as `max_tokens`,
	// which the o-series and GPT-5 reasoning models reject in favour of
	// `max_completion_tokens`, so those deliberately stay at 0.
	MaxOutputTokens int
	// Thinking names the reasoning mode to request for this model, for providers
	// that must ask for it explicitly. "adaptive" is what Claude 4.6 and later
	// accept: the model decides when and how deeply to think, and reasons
	// between tool calls on its own with no beta header.
	//
	// Empty means no thinking configuration is sent. Claude 4.5 and earlier
	// accept only a fixed `budget_tokens` that has to fit inside `max_tokens` —
	// a tradeoff the agent loop does not currently make, since it leaves
	// `max_tokens` at the provider default — and Haiku 4.5 cannot reason
	// between tool calls at all, which is where an agent loop would spend it.
	Thinking string
}

type ContentPart struct {
	Type string `json:"type"`
	Text string `json:"text,omitempty"`
}

type FreeProviderDef struct {
	Collection   string   `json:"collection"`   // grouping label ("Cerebras", "SambaNova", …)
	BaseURL      string   `json:"baseURL"`      // OpenAI-compatible API base URL
	Keys         []string `json:"keys"`         // pool of API keys (round-robin / random)
	DefaultModel string   `json:"defaultModel"` // suggested default model ID
}

type MessageImage struct {
	MediaType string `json:"mediaType"`
	Data      string `json:"data"`
}

type ModelInfo struct {
	ID              string  `json:"id"`
	Name            string  `json:"name"`
	ProviderID      string  `json:"providerId"`
	Default         bool    `json:"default"`
	ActiveByDefault bool    `json:"activeByDefault"`
	InputPricePerM  float64 `json:"inputPricePerM"`
	OutputPricePerM float64 `json:"outputPricePerM"`
	SupportsImages  bool    `json:"supportsImages"`
	// ContextWindow is the model's total context length in tokens (0 = unknown).
	// Used to size the compaction trigger; when 0 the loop falls back to a fixed
	// byte-size heuristic.
	ContextWindow int `json:"contextWindow,omitempty"`
	// MaxOutputTokens is the most output the model will produce in one response
	// (0 = unknown, leave the request's limit to the provider's own default).
	MaxOutputTokens int `json:"maxOutputTokens,omitempty"`
	// Collection is an optional grouping label for dynamically-fetched models
	// from OpenAI-compatible providers (e.g. "DeepSeek", "Gemini") so the UI can
	// group them instead of collapsing everything under the OpenAI provider id.
	Collection string `json:"collection,omitempty"`
}

type ModelMessage struct {
	Role       string          `json:"role"`
	Content    json.RawMessage `json:"content,omitempty"`
	ToolCalls  json.RawMessage `json:"tool_calls,omitempty"`
	ToolCallID string          `json:"tool_call_id,omitempty"`
	Name       string          `json:"name,omitempty"`
	// Images carries image attachments for a tool-result message. Providers
	// render these per their API: Anthropic embeds them in the tool_result
	// content block; OpenAI-family inject a follow-up user message.
	Images []MessageImage `json:"images,omitempty"`
	// ReasoningParts carries thinking/reasoning blocks from a previous assistant
	// turn. Anthropic requires these to be forwarded back as "thinking" content
	// blocks with their signatures intact; OpenAI-family providers handle
	// reasoning tokens server-side and should ignore this field.
	ReasoningParts []ReasoningPart `json:"reasoningParts,omitempty"`
}

type ModelRefresher interface {
	RefreshModels()
}

type OllamaStatus struct {
	// Installed reports whether the `ollama` binary is found on $PATH (via
	// exec.LookPath — cross-platform, unlike hardcoded install paths).
	Installed bool `json:"installed"`
	// Running reports whether the Ollama server responded to a health probe
	// (GET http://localhost:11434 with a short timeout). This is the reliable
	// signal that the endpoint is actually usable right now.
	Running bool `json:"running"`
	// BaseURL is the detected/expected Ollama base URL. It honours
	// OLLAMA_BASE_URL when set, otherwise defaults to the localhost endpoint.
	BaseURL string `json:"baseUrl"`
}

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

type Provider interface {
	ID() string
	Models() []ModelInfo
	StreamChat(ctx context.Context, req StreamRequest) (<-chan StreamEvent, error)
}

type ReasoningPart struct {
	Text      string `json:"text"`
	Signature string `json:"signature,omitempty"`
	// RedactedData is the opaque payload of a redacted_thinking block. When
	// set, the block carries no readable text and must be re-sent as a
	// redacted_thinking block rather than a thinking block.
	RedactedData string `json:"redactedData,omitempty"`
}

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

type StreamEvent struct {
	Type         StreamEventType `json:"type"`
	Text         string          `json:"text,omitempty"`
	Signature    string          `json:"signature,omitempty"`
	RedactedData string          `json:"redactedData,omitempty"`
	ToolCallID   string          `json:"toolCallId,omitempty"`
	ToolName     string          `json:"toolName,omitempty"`
	ToolInput    json.RawMessage `json:"toolInput,omitempty"`
	FinishReason *string         `json:"finishReason,omitempty"`
	Usage        *TokenUsage     `json:"usage,omitempty"`
	Error        string          `json:"error,omitempty"`
}

type StreamEventType string

type StreamRequest struct {
	Model       string           `json:"model"`
	System      []string         `json:"system"`
	Messages    []ModelMessage   `json:"messages"`
	Tools       []ToolDefinition `json:"tools"`
	Temperature float64          `json:"temperature,omitempty"`
	MaxTokens   int              `json:"maxTokens,omitempty"`
	// Thinking asks for the model's reasoning mode, where the provider and the
	// model support one. Only the agent loop sets it. The short utility calls —
	// titles, the auto-mode risk gate, compaction — run on tight max_tokens
	// budgets that thinking would spend before reaching an answer, and none of
	// them is the kind of work reasoning improves.
	Thinking bool `json:"thinking,omitempty"`
}

type TokenUsage struct {
	InputTokens      int `json:"inputTokens,omitempty"`
	OutputTokens     int `json:"outputTokens,omitempty"`
	ReasoningTokens  int `json:"reasoningTokens,omitempty"`
	CacheReadTokens  int `json:"cacheReadTokens,omitempty"`
	CacheWriteTokens int `json:"cacheWriteTokens,omitempty"`
}

type ToolDefinition struct {
	Name        string          `json:"name"`
	Description string          `json:"description"`
	Parameters  json.RawMessage `json:"parameters"`
}