llm

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

type AnthropicOption func(*AnthropicLLM)

type ContentBlock struct {
	Type string `json:"type"`

	// Text carries text and thinking content.
	Text string `json:"text,omitempty"`
	// Signature authenticates a thinking block so it can be replayed to
	// the API on the next request of the same turn.
	Signature string `json:"signature,omitempty"`

	// Tool use fields.
	ID        string         `json:"id,omitempty"`
	Name      string         `json:"name,omitempty"`
	Arguments map[string]any `json:"arguments,omitempty"`

	// Tool result fields.
	ToolUseID string `json:"tool_use_id,omitempty"`
	Content   string `json:"content,omitempty"`
	IsError   bool   `json:"is_error,omitempty"`

	// Image fields (BlockImage): base64-encoded image Data plus its MediaType
	// (e.g. "image/png"). Vision-capable models read these on user turns.
	MediaType string `json:"media_type,omitempty"`
	Data      string `json:"data,omitempty"`

	// Raw is the verbatim API block for BlockOpaque — block types govega
	// does not model, preserved so turn replay is lossless.
	Raw json.RawMessage `json:"raw,omitempty"`
}

type LLM interface {
	// Generate sends a request and returns the complete response.
	Generate(ctx context.Context, messages []Message, tools []ToolSchema) (*LLMResponse, error)

	// GenerateStream sends a request and returns a channel of streaming events.
	GenerateStream(ctx context.Context, messages []Message, tools []ToolSchema) (<-chan StreamEvent, error)
}

type LLMResponse struct {
	// Content is the text response
	Content string

	// Blocks is the ordered, typed content of the response (thinking,
	// text, tool_use). Callers replaying the assistant turn should attach
	// these to the next Message so thinking blocks and tool invocations
	// survive the round trip. Empty on backends without block support.
	Blocks []ContentBlock

	// ToolCalls are any tool calls the model wants to make
	ToolCalls []ToolCall

	// Token counts
	InputTokens  int
	OutputTokens int

	// Cache token counts (Anthropic prompt caching)
	CacheCreationInputTokens int
	CacheReadInputTokens     int

	// Cost in USD
	CostUSD float64

	// Latency in milliseconds
	LatencyMs int64

	// StopReason indicates why generation stopped
	StopReason StopReason
}

type Message struct {
	Role    Role
	Content string
	Blocks  []ContentBlock `json:"Blocks,omitempty"`

	// Volatile is per-conversation system content — who the agent is talking
	// to, what it remembers about them — that belongs in the system prompt but
	// is byte-unique per conversation. Meaningful only on a RoleSystem
	// message. Providers that support prompt caching render it as a second,
	// uncached system block after Content, so every conversation shares one
	// cached prefix instead of writing its own. Empty ⇒ one block, as before.
	Volatile string `json:"Volatile,omitempty"`
}

type ModelCapabilities struct {
	// AdaptiveThinking — model supports {type: "adaptive"} thinking.
	// Older models use the legacy budget_tokens form, which we don't emit.
	AdaptiveThinking bool

	// SupportsEffort — model accepts output_config.effort.
	// Sonnet 4.5 and Haiku 4.5 return 400 if it's sent.
	SupportsEffort bool

	// SupportsTemperature — model accepts the temperature sampling
	// parameter. Opus 4.7 removed sampling params and returns 400 if
	// temperature/top_p/top_k are sent.
	SupportsTemperature bool

	// SupportsStructuredOutputs — model accepts output_config.format
	// for JSON schema enforcement. Supported on Claude 4.5+ Opus,
	// Sonnet 4.6, Haiku 4.5.
	SupportsStructuredOutputs bool

	// MaxOutputTokens is the streaming output ceiling for this model.
	MaxOutputTokens int
}

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

type OpenAIOption func(*OpenAILLM)

type Options struct {
	// Model overrides the client's default model for this call.
	Model string

	// Temperature is a float pointer because zero is a valid value;
	// nil means "do not send" (use model default). Backends that
	// don't support sampling parameters drop this silently.
	Temperature *float64

	// MaxTokens caps response output. 0 means use the capability default.
	MaxTokens int

	// Effort sets output_config.effort on supported models.
	// Empty defaults to "high" if the model supports effort.
	Effort string

	// OutputSchema is a JSON Schema enforced on the response via
	// output_config.format. When set on a model that supports
	// structured outputs, the API returns valid JSON conforming to
	// the schema (no markdown fences, no invented fields). Silently
	// dropped on unsupported models — caller falls back to ad-hoc
	// JSON parsing in that case.
	OutputSchema map[string]any
}

type Role string

type StopReason string

type StreamEvent struct {
	// Type of event
	Type StreamEventType

	// Delta is new content for ContentDelta events
	Delta string

	// ToolCall for ToolCallStart events
	ToolCall *ToolCall

	// Error if something went wrong
	Error error

	// InputTokens after message start
	InputTokens int

	// OutputTokens after message end
	OutputTokens int

	// CostUSD is the request cost, set on MessageEnd by backends that
	// know their pricing. Callers should prefer this over recomputing
	// from the model name.
	CostUSD float64

	// StopReason, set on MessageEnd, indicates why generation stopped.
	// Callers must handle refusal and pause_turn instead of treating
	// every stream end as a completed answer.
	StopReason StopReason

	// Cache token counts (Anthropic prompt caching)
	CacheCreationInputTokens int
	CacheReadInputTokens     int
}

type StreamEventType string

type ToolCall struct {
	// ID is the unique identifier for this tool call
	ID string

	// Name is the tool being called
	Name string

	// Arguments are the parameters passed to the tool
	Arguments map[string]any
}

type ToolSchema struct {
	// Name of the tool
	Name string `json:"name"`

	// Description of what the tool does
	Description string `json:"description"`

	// InputSchema is the JSON Schema for parameters
	InputSchema map[string]any `json:"input_schema"`
}