providers

type ChatRequest struct {
	System      string          `json:"system"`
	Messages    []types.Message `json:"messages"`
	Temperature float32         `json:"temperature"`
	TopP        float32         `json:"top_p"`
	MaxTokens   int             `json:"max_tokens"`
	Seed        *int            `json:"seed,omitempty"`
}

type ChatResponse struct {
	Content    string                  `json:"content"`
	CostInfo   *types.CostInfo         `json:"cost_info,omitempty"` // Cost breakdown for this response (includes token counts)
	Latency    time.Duration           `json:"latency"`
	Raw        []byte                  `json:"raw,omitempty"`
	RawRequest interface{}             `json:"raw_request,omitempty"` // Raw API request (for debugging)
	ToolCalls  []types.MessageToolCall `json:"tool_calls,omitempty"`  // Tools called in this response
}

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

type ClaudeToolProvider struct {
	*ClaudeProvider
}

type ExecutionResult interface{}

type GeminiProvider struct {
	Model    string
	BaseURL  string
	ApiKey   string
	Defaults ProviderDefaults

	Client *http.Client
	// contains filtered or unexported fields
}

type GeminiToolProvider struct {
	*GeminiProvider
	// contains filtered or unexported fields
}

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

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

type OpenAIToolProvider struct {
	*OpenAIProvider
}

type Pricing struct {
	InputCostPer1K  float64
	OutputCostPer1K float64
}

type Provider interface {
	ID() string
	Chat(ctx context.Context, req ChatRequest) (ChatResponse, error)

	// Streaming support
	ChatStream(ctx context.Context, req ChatRequest) (<-chan StreamChunk, error)
	SupportsStreaming() bool

	ShouldIncludeRawOutput() bool
	Close() error // Close cleans up provider resources (e.g., HTTP connections)

	// CalculateCost calculates cost breakdown for given token counts
	CalculateCost(inputTokens, outputTokens, cachedTokens int) types.CostInfo
}

type ProviderDefaults struct {
	Temperature float32
	TopP        float32
	MaxTokens   int
	Pricing     Pricing
}

type ProviderSpec struct {
	ID               string
	Type             string
	Model            string
	BaseURL          string
	Defaults         ProviderDefaults
	IncludeRawOutput bool
}

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

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

type StreamChunk struct {
	// Content is the accumulated content so far
	Content string `json:"content"`

	// Delta is the new content in this chunk
	Delta string `json:"delta"`

	// TokenCount is the total number of tokens so far
	TokenCount int `json:"token_count"`

	// DeltaTokens is the number of tokens in this delta
	DeltaTokens int `json:"delta_tokens"`

	// ToolCalls contains accumulated tool calls (for assistant messages that invoke tools)
	ToolCalls []types.MessageToolCall `json:"tool_calls,omitempty"`

	// FinishReason is nil until stream is complete
	// Values: "stop", "length", "content_filter", "tool_calls", "error", "validation_failed", "cancelled"
	FinishReason *string `json:"finish_reason,omitempty"`

	// Error is set if an error occurred during streaming
	Error error `json:"error,omitempty"`

	// Metadata contains provider-specific metadata
	Metadata map[string]interface{} `json:"metadata,omitempty"`

	// FinalResult contains the complete execution result (only set in the final chunk)
	FinalResult ExecutionResult `json:"final_result,omitempty"`

	// CostInfo contains cost breakdown (only present in final chunk when FinishReason != nil)
	CostInfo *types.CostInfo `json:"cost_info,omitempty"`
}

type StreamEvent struct {
	// Type is the event type: "chunk", "complete", "error"
	Type string `json:"type"`

	// Chunk contains the stream chunk data
	Chunk *StreamChunk `json:"chunk,omitempty"`

	// Error is set for error events
	Error error `json:"error,omitempty"`

	// Timestamp is when the event occurred
	Timestamp time.Time `json:"timestamp"`
}

type StreamObserver interface {
	OnChunk(chunk StreamChunk)
	OnComplete(totalTokens int, duration time.Duration)
	OnError(err error)
}

type ToolDescriptor struct {
	Name         string          `json:"name"`
	Description  string          `json:"description"`
	InputSchema  json.RawMessage `json:"input_schema"`
	OutputSchema json.RawMessage `json:"output_schema"`
}

type ToolResult = types.MessageToolResult

type ToolSupport interface {
	Provider // Extends the base Provider interface

	// BuildTooling converts tool descriptors to provider-native format
	BuildTooling(descriptors []*ToolDescriptor) (interface{}, error)

	// ChatWithTools performs a chat request with tool support
	ChatWithTools(ctx context.Context, req ChatRequest, tools interface{}, toolChoice string) (ChatResponse, []types.MessageToolCall, error)

	// ContinueWithToolResults continues conversation with tool results
	// req contains the original messages, prior is the response with tool calls, results are tool outputs
	ContinueWithToolResults(ctx context.Context, req ChatRequest, prior ChatResponse, tools interface{}, toolChoice string, results []types.MessageToolResult) (ChatResponse, []types.MessageToolCall, error)
}

type UnsupportedProviderError struct {
	ProviderType string
}

type ValidationAbortError struct {
	Reason string
	Chunk  StreamChunk
}