core

type AudioInput struct {
	// Data is the raw audio bytes.
	Data []byte `json:"data"`
	// Format is the audio format (e.g., "wav", "mp3", "ogg", "flac").
	Format string `json:"format"`
	// SampleRate is the sample rate in Hz (e.g., 16000, 44100).
	SampleRate int `json:"sample_rate,omitempty"`
	// Language is an optional language hint (BCP-47 tag, e.g., "en-US").
	Language string `json:"language,omitempty"`
}

type AudioProvider interface {
	Provider
	// ChatWithAudio sends a chat request that includes audio data alongside
	// text messages. The audio format is specified in audioConfig.
	ChatWithAudio(ctx context.Context, request *ChatCompletionRequest, audio *AudioInput) (*ChatCompletionResponse, error)
}

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

type ChatCompletionChoice struct {
	// Index is the index of the choice
	Index int `json:"index"`
	// Message is the message
	Message Message `json:"message"`
	// FinishReason is the reason the completion finished
	FinishReason string `json:"finish_reason"`
}

type ChatCompletionRequest struct {
	// Messages is the list of messages in the conversation
	Messages []Message `json:"messages"`
	// MaxTokens is the maximum number of tokens to generate
	MaxTokens int `json:"max_tokens,omitempty"`
	// Temperature controls randomness (0.0 to 2.0)
	Temperature float64 `json:"temperature,omitempty"`
	// TopP controls diversity via nucleus sampling (0.0 to 1.0)
	TopP float64 `json:"top_p,omitempty"`
	// N is the number of completions to generate
	N int `json:"n,omitempty"`
	// Stop is a list of tokens at which to stop generation
	Stop []string `json:"stop,omitempty"`
	// Stream indicates whether to stream the response
	Stream bool `json:"stream,omitempty"`
	// PresencePenalty penalizes new tokens based on presence in text so far (0.0 to 2.0)
	PresencePenalty float64 `json:"presence_penalty,omitempty"`
	// FrequencyPenalty penalizes new tokens based on frequency in text so far (0.0 to 2.0)
	FrequencyPenalty float64 `json:"frequency_penalty,omitempty"`
	// LogitBias is a map from token IDs to bias values (-100 to 100)
	LogitBias map[string]float64 `json:"logit_bias,omitempty"`
	// User is an optional user identifier
	User string `json:"user,omitempty"`
	// Functions is a list of function definitions
	Functions []Function `json:"functions,omitempty"`
	// FunctionCall controls function calling behavior
	FunctionCall interface{} `json:"function_call,omitempty"`
	// Tools is a list of tool definitions
	Tools []Tool `json:"tools,omitempty"`
	// ToolChoice controls tool choice behavior
	ToolChoice interface{} `json:"tool_choice,omitempty"`
	// ResponseFormat specifies the format of the response
	ResponseFormat map[string]string `json:"response_format,omitempty"`
	// Model is the model to use
	Model string `json:"model,omitempty"`
	// Metadata is optional metadata for the request
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type ChatCompletionResponse struct {
	// ID is the ID of the completion
	ID string `json:"id"`
	// Object is the object type
	Object string `json:"object"`
	// Created is the Unix timestamp of when the completion was created
	Created int64 `json:"created"`
	// Model is the model used
	Model string `json:"model"`
	// Choices is the list of completion choices
	Choices []ChatCompletionChoice `json:"choices"`
	// Usage is the token usage information
	Usage *TokenUsage `json:"usage,omitempty"`
}

type ConnectionPoolConfig struct {
	// Pool sizing
	MaxIdleConns        int `json:"max_idle_conns"`
	MaxIdleConnsPerHost int `json:"max_idle_conns_per_host"`
	MaxConnsPerHost     int `json:"max_conns_per_host"`

	// Timeouts
	IdleConnTimeout       time.Duration `json:"idle_conn_timeout"`
	TLSHandshakeTimeout   time.Duration `json:"tls_handshake_timeout"`
	ExpectContinueTimeout time.Duration `json:"expect_continue_timeout"`
	ResponseHeaderTimeout time.Duration `json:"response_header_timeout"`

	// Keep-alive settings
	KeepAlive          time.Duration `json:"keep_alive"`
	DisableKeepAlives  bool          `json:"disable_keep_alives"`
	DisableCompression bool          `json:"disable_compression"`

	// TLS settings
	InsecureSkipVerify bool `json:"insecure_skip_verify"`

	// Health check settings
	HealthCheckInterval time.Duration `json:"health_check_interval"`
	HealthCheckTimeout  time.Duration `json:"health_check_timeout"`

	// Provider-specific settings
	ProviderType ProviderType `json:"provider_type"`
	BaseURL      string       `json:"base_url"`
}

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

type ConnectionPoolMetrics struct {
	TotalPools         int64 `json:"total_pools"`
	ActiveConnections  int64 `json:"active_connections"`
	IdleConnections    int64 `json:"idle_connections"`
	ConnectionsCreated int64 `json:"connections_created"`
	ConnectionsReused  int64 `json:"connections_reused"`
	ConnectionErrors   int64 `json:"connection_errors"`
	HealthChecksPassed int64 `json:"health_checks_passed"`
	HealthChecksFailed int64 `json:"health_checks_failed"`

	// Per-provider metrics
	ProviderMetrics map[ProviderType]*ProviderPoolMetrics `json:"provider_metrics"`
}

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

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

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

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

type Embedding struct {
	// Object is the object type
	Object string `json:"object"`
	// Embedding is the embedding vector
	Embedding []float64 `json:"embedding"`
	// Index is the index of the embedding
	Index int `json:"index"`
}

type EmbeddingRequest struct {
	// Input is the input to embed
	Input interface{} `json:"input"`
	// Model is the model to use
	Model string `json:"model"`
	// EncodingFormat is the encoding format
	EncodingFormat string `json:"encoding_format,omitempty"`
	// User is an optional user identifier
	User string `json:"user,omitempty"`
	// Dimensions is the number of dimensions for the embeddings
	Dimensions int `json:"dimensions,omitempty"`
}

type EmbeddingResponse struct {
	// Object is the object type
	Object string `json:"object"`
	// Data is the list of embeddings
	Data []Embedding `json:"data"`
	// Model is the model used
	Model string `json:"model"`
	// Usage is the token usage information
	Usage *TokenUsage `json:"usage,omitempty"`
}

type Function struct {
	// Name is the name of the function
	Name string `json:"name"`
	// Description is a description of the function
	Description string `json:"description"`
	// Parameters is a JSON schema of parameters
	Parameters map[string]interface{} `json:"parameters"`
}

type FunctionCall struct {
	// Name is the name of the function
	Name string `json:"name"`
	// Arguments is a JSON string of arguments
	Arguments string `json:"arguments"`
}

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

type ImageInput struct {
	// Bytes holds the inline image bytes. Mutually exclusive with URL.
	Bytes []byte `json:"bytes,omitempty"`
	// URL references an image hosted out-of-band. Mutually exclusive with Bytes.
	URL string `json:"url,omitempty"`
	// MimeType is the image MIME type (e.g., "image/jpeg", "image/png").
	MimeType string `json:"mime_type"`
	// Detail is an advisory hint to the provider ("low", "high", "auto").
	// Providers that don't accept this hint silently ignore it.
	Detail string `json:"detail,omitempty"`
}

type ImageProvider interface {
	Provider
	// ChatWithImages sends a chat request with one or more attached images.
	// Each ImageInput carries either inline Bytes or a URL reference, plus
	// the MIME type and an advisory Detail hint that providers may honor or
	// ignore at their discretion.
	ChatWithImages(ctx context.Context, request *ChatCompletionRequest, images []ImageInput) (*ChatCompletionResponse, error)
}

type LogProbs struct {
	// Tokens is the list of tokens
	Tokens []string `json:"tokens"`
	// TokenLogProbs is the list of log probabilities for tokens
	TokenLogProbs []float64 `json:"token_logprobs"`
	// TopLogProbs is a list of maps from tokens to log probabilities
	TopLogProbs []map[string]float64 `json:"top_logprobs"`
	// TextOffset is a list of offsets in the text
	TextOffset []int `json:"text_offset"`
}

type Logger interface {
	Info(msg string, args ...interface{})
	Warn(msg string, args ...interface{})
	Error(msg string, args ...interface{})
	Debug(msg string, args ...interface{})
}

type LongContextProvider interface {
	Provider
	// MaxContextTokens returns the maximum number of input tokens supported.
	MaxContextTokens() int
}

type MCPProvider interface {
	Provider
	// ListMCPTools returns the available MCP tools.
	ListMCPTools(ctx context.Context) ([]MCPToolInfo, error)
	// InvokeMCPTool invokes an MCP tool by name with the given arguments.
	InvokeMCPTool(ctx context.Context, toolName string, arguments map[string]interface{}) (*MCPToolResult, error)
}

type MCPToolInfo struct {
	// Name is the tool's unique name.
	Name string `json:"name"`
	// Description describes what the tool does.
	Description string `json:"description"`
	// InputSchema is the JSON Schema for the tool's input parameters.
	InputSchema map[string]interface{} `json:"input_schema"`
}

type MCPToolResult struct {
	// Content is the tool's output.
	Content string `json:"content"`
	// IsError indicates whether the tool returned an error.
	IsError bool `json:"is_error"`
}

type Message struct {
	// Role is the role of the message sender (e.g., "system", "user", "assistant")
	Role string `json:"role"`
	// Content is the content of the message
	Content string `json:"content"`
	// Name is an optional name for the message sender
	Name string `json:"name,omitempty"`
	// FunctionCall is an optional function call
	FunctionCall *FunctionCall `json:"function_call,omitempty"`
	// ToolCalls is an optional list of tool calls
	ToolCalls []*ToolCall `json:"tool_calls,omitempty"`
	// Timestamp is the timestamp of the message
	Timestamp time.Time `json:"timestamp,omitempty"`
}

type ModelCapability string

type ModelInfo struct {
	// ID is the ID of the model
	ID string `json:"id"`
	// Provider is the provider of the model
	Provider ProviderType `json:"provider"`
	// Type is the type of model
	Type ModelType `json:"type"`
	// Capabilities is a list of capabilities of the model
	Capabilities []ModelCapability `json:"capabilities"`
	// MaxTokens is the maximum number of tokens the model can process
	MaxTokens int `json:"max_tokens"`
	// TrainingCutoff is the training cutoff date of the model
	TrainingCutoff time.Time `json:"training_cutoff,omitempty"`
	// Version is the version of the model
	Version string `json:"version,omitempty"`
	// Description is a description of the model
	Description string `json:"description,omitempty"`
	// PricingInfo is information about pricing for the model
	PricingInfo *ModelPricingInfo `json:"pricing_info,omitempty"`
}

type ModelPricingInfo struct {
	// InputPricePerToken is the price per input token
	InputPricePerToken float64 `json:"input_price_per_token"`
	// OutputPricePerToken is the price per output token
	OutputPricePerToken float64 `json:"output_price_per_token"`
	// Currency is the currency of the prices
	Currency string `json:"currency"`
}

type ModelRegistry interface {
	// RegisterModel registers a model
	RegisterModel(model *ModelInfo) error

	// GetModel returns a model by ID
	GetModel(modelID string) (*ModelInfo, error)

	// GetModelsByProvider returns models by provider
	GetModelsByProvider(providerType ProviderType) ([]*ModelInfo, error)

	// GetModelsByType returns models by type
	GetModelsByType(modelType ModelType) ([]*ModelInfo, error)

	// GetModelsByCapability returns models by capability
	GetModelsByCapability(capability ModelCapability) ([]*ModelInfo, error)

	// GetAllModels returns all registered models
	GetAllModels() ([]*ModelInfo, error)
}

type ModelType string

type Provider interface {
	// GetType returns the type of provider
	GetType() ProviderType
	// GetConfig returns the configuration for the provider
	GetConfig() *ProviderConfig
	// GetModels returns a list of available models
	GetModels(ctx context.Context) ([]ModelInfo, error)
	// GetModelInfo returns information about a specific model
	GetModelInfo(ctx context.Context, modelID string) (*ModelInfo, error)
	// TextCompletion generates a text completion
	TextCompletion(ctx context.Context, request *TextCompletionRequest) (*TextCompletionResponse, error)
	// ChatCompletion generates a chat completion
	ChatCompletion(ctx context.Context, request *ChatCompletionRequest) (*ChatCompletionResponse, error)
	// StreamingChatCompletion generates a streaming chat completion
	StreamingChatCompletion(ctx context.Context, request *ChatCompletionRequest, callback func(response *ChatCompletionResponse) error) error
	// CreateEmbedding creates an embedding
	CreateEmbedding(ctx context.Context, request *EmbeddingRequest) (*EmbeddingResponse, error)
	// CountTokens counts the number of tokens in a text
	CountTokens(ctx context.Context, text string, modelID string) (int, error)
	// SupportsModel returns whether the provider supports a specific model
	SupportsModel(ctx context.Context, modelID string) bool
	// SupportsCapability returns whether the provider supports a specific capability
	SupportsCapability(ctx context.Context, capability ModelCapability) bool
	// Close closes the provider and releases any resources
	Close() error

	// GetRateLimitConfig returns the rate limit configuration
	GetRateLimitConfig() *RateLimitConfig
	// UpdateRateLimitConfig updates the rate limit configuration
	UpdateRateLimitConfig(config *RateLimitConfig) error
	// GetRetryConfig returns the retry configuration
	GetRetryConfig() *RetryConfig
	// UpdateRetryConfig updates the retry configuration
	UpdateRetryConfig(config *RetryConfig) error
	// GetUsageMetrics returns the usage metrics for a specific model
	GetUsageMetrics(modelID string) (*UsageMetrics, error)
	// GetAllUsageMetrics returns the usage metrics for all models
	GetAllUsageMetrics() (map[string]*UsageMetrics, error)
	// ResetUsageMetrics resets the usage metrics
	ResetUsageMetrics() error
}

type ProviderConfig struct {
	// Type is the type of provider
	Type ProviderType `json:"type"`
	// APIKey is the API key for the provider
	APIKey string `json:"api_key,omitempty"`
	// OrgID is the organization ID for the provider
	OrgID string `json:"org_id,omitempty"`
	// BaseURL is the base URL for the provider API
	BaseURL string `json:"base_url,omitempty"`
	// Timeout is the timeout for requests to the provider
	Timeout time.Duration `json:"timeout,omitempty"`
	// RetryConfig is the configuration for retries
	RetryConfig *RetryConfig `json:"retry_config,omitempty"`
	// RateLimitConfig is the configuration for rate limiting
	RateLimitConfig *RateLimitConfig `json:"rate_limit_config,omitempty"`
	// DefaultModel is the default model to use
	DefaultModel string `json:"default_model,omitempty"`
	// AdditionalHeaders is a map of additional headers to include in requests
	AdditionalHeaders map[string]string `json:"additional_headers,omitempty"`
	// AdditionalParams is a map of additional parameters to include in requests
	AdditionalParams map[string]interface{} `json:"additional_params,omitempty"`
}

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

type ProviderCreator func(config *ProviderConfig) (Provider, error)

type ProviderError struct {
	// StatusCode is the HTTP status code
	StatusCode int `json:"status_code,omitempty"`
	// Type is the type of error
	Type string `json:"type,omitempty"`
	// Message is the error message
	Message string `json:"message"`
	// Param is the parameter that caused the error
	Param string `json:"param,omitempty"`
	// Code is the error code
	Code string `json:"code,omitempty"`
	// RawResponse is the raw response from the provider
	RawResponse string `json:"-"`
}

type ProviderFactory interface {
	// CreateProvider creates a provider with the given configuration
	CreateProvider(config *ProviderConfig) (Provider, error)
	// GetSupportedProviderTypes returns the provider types supported by this factory
	GetSupportedProviderTypes() []ProviderType
}

type ProviderPoolMetrics struct {
	ProviderType       ProviderType  `json:"provider_type"`
	ActiveConnections  int64         `json:"active_connections"`
	IdleConnections    int64         `json:"idle_connections"`
	ConnectionsCreated int64         `json:"connections_created"`
	ConnectionsReused  int64         `json:"connections_reused"`
	ConnectionErrors   int64         `json:"connection_errors"`
	AverageLatency     time.Duration `json:"average_latency"`
	LastHealthCheck    time.Time     `json:"last_health_check"`
	HealthStatus       string        `json:"health_status"`
}

type ProviderRegistry interface {
	// RegisterProvider registers a provider
	RegisterProvider(provider Provider) error

	// RegisterProviderFactory registers a provider factory
	RegisterProviderFactory(factory ProviderFactory) error

	// GetProvider returns a provider by type
	GetProvider(providerType ProviderType) (Provider, error)

	// GetProviderByModel returns a provider that supports a specific model
	GetProviderByModel(modelID string) (Provider, error)

	// GetProviderByCapability returns a provider that supports a specific capability
	GetProviderByCapability(capability ModelCapability) (Provider, error)

	// GetAllProviders returns all registered providers
	GetAllProviders() []Provider

	// GetAllProviderTypes returns all registered provider types
	GetAllProviderTypes() []ProviderType
}

type ProviderType string

type RateLimitConfig struct {
	// RequestsPerMinute is the maximum number of requests per minute
	RequestsPerMinute int `json:"requests_per_minute"`
	// TokensPerMinute is the maximum number of tokens per minute
	TokensPerMinute int `json:"tokens_per_minute"`
	// MaxConcurrentRequests is the maximum number of concurrent requests
	MaxConcurrentRequests int `json:"max_concurrent_requests"`
	// BurstSize is the maximum burst size
	BurstSize int `json:"burst_size"`
}

type ReasoningProvider interface {
	Provider
	// ChatWithReasoning generates a chat completion that includes the model's
	// reasoning trace alongside the final response.
	ChatWithReasoning(ctx context.Context, request *ChatCompletionRequest) (*ChatCompletionResponse, *ThinkingTrace, error)
}

type RetryConfig struct {
	// MaxRetries is the maximum number of retries
	MaxRetries int `json:"max_retries"`
	// InitialBackoff is the initial backoff duration
	InitialBackoff time.Duration `json:"initial_backoff"`
	// MaxBackoff is the maximum backoff duration
	MaxBackoff time.Duration `json:"max_backoff"`
	// BackoffMultiplier is the multiplier for backoff duration
	BackoffMultiplier float64 `json:"backoff_multiplier"`
	// RetryableStatusCodes is a list of HTTP status codes that should be retried
	RetryableStatusCodes []int `json:"retryable_status_codes"`
}

type TextCompletionChoice struct {
	// Text is the completed text
	Text string `json:"text"`
	// Index is the index of the choice
	Index int `json:"index"`
	// LogProbs is the log probabilities
	LogProbs *LogProbs `json:"logprobs,omitempty"`
	// FinishReason is the reason the completion finished
	FinishReason string `json:"finish_reason"`
}

type TextCompletionRequest struct {
	// Prompt is the prompt for text completion
	Prompt string `json:"prompt"`
	// MaxTokens is the maximum number of tokens to generate
	MaxTokens int `json:"max_tokens,omitempty"`
	// Temperature controls randomness (0.0 to 2.0)
	Temperature float64 `json:"temperature,omitempty"`
	// TopP controls diversity via nucleus sampling (0.0 to 1.0)
	TopP float64 `json:"top_p,omitempty"`
	// N is the number of completions to generate
	N int `json:"n,omitempty"`
	// Stop is a list of tokens at which to stop generation
	Stop []string `json:"stop,omitempty"`
	// Stream indicates whether to stream the response
	Stream bool `json:"stream,omitempty"`
	// LogProbs is the number of log probabilities to return
	LogProbs int `json:"logprobs,omitempty"`
	// Echo indicates whether to echo the prompt
	Echo bool `json:"echo,omitempty"`
	// PresencePenalty penalizes new tokens based on presence in text so far (0.0 to 2.0)
	PresencePenalty float64 `json:"presence_penalty,omitempty"`
	// FrequencyPenalty penalizes new tokens based on frequency in text so far (0.0 to 2.0)
	FrequencyPenalty float64 `json:"frequency_penalty,omitempty"`
	// User is an optional user identifier
	User string `json:"user,omitempty"`
	// Model is the model to use
	Model string `json:"model,omitempty"`
}

type TextCompletionResponse struct {
	// ID is the ID of the completion
	ID string `json:"id"`
	// Object is the object type
	Object string `json:"object"`
	// Created is the Unix timestamp of when the completion was created
	Created int64 `json:"created"`
	// Model is the model used
	Model string `json:"model"`
	// Choices is the list of completion choices
	Choices []TextCompletionChoice `json:"choices"`
	// Usage is the token usage information
	Usage *TokenUsage `json:"usage,omitempty"`
}

type ThinkingStep struct {
	// Content is the text of this reasoning step.
	Content string `json:"content"`
	// Type categorizes the step (e.g., "analysis", "hypothesis", "conclusion").
	Type string `json:"type,omitempty"`
}

type ThinkingTrace struct {
	// Steps contains the individual reasoning steps.
	Steps []ThinkingStep `json:"steps"`
	// TotalThinkingTokens is the number of tokens used for reasoning.
	TotalThinkingTokens int `json:"total_thinking_tokens"`
	// ThinkingDuration is the time spent on reasoning.
	ThinkingDuration string `json:"thinking_duration,omitempty"`
}

type TokenUsage struct {
	// PromptTokens is the number of tokens in the prompt
	PromptTokens int `json:"prompt_tokens"`
	// CompletionTokens is the number of tokens in the completion
	CompletionTokens int `json:"completion_tokens"`
	// TotalTokens is the total number of tokens
	TotalTokens int `json:"total_tokens"`
}

type Tool struct {
	// Type is the type of tool (e.g., "function")
	Type string `json:"type"`
	// Function is the function definition
	Function *Function `json:"function"`
}

type ToolCall struct {
	// ID is the ID of the tool call
	ID string `json:"id"`
	// Type is the type of tool call (e.g., "function")
	Type string `json:"type"`
	// Function is the function call
	Function *FunctionCall `json:"function"`
}

type UsageMetrics struct {
	// Requests is the number of requests made
	Requests int64 `json:"requests"`
	// Tokens is the number of tokens used
	Tokens int64 `json:"tokens"`
	// Errors is the number of errors encountered
	Errors int64 `json:"errors"`
	// LastRequestTime is the time of the last request
	LastRequestTime time.Time `json:"last_request_time"`
	// TotalRequestDuration is the total duration of all requests
	TotalRequestDuration time.Duration `json:"total_request_duration"`
	// AverageResponseTime is the average response time
	AverageResponseTime time.Duration `json:"average_response_time"`
	// TokensPerMinute is the average tokens per minute
	TokensPerMinute float64 `json:"tokens_per_minute"`
	// RequestsPerMinute is the average requests per minute
	RequestsPerMinute float64 `json:"requests_per_minute"`
	// ModelID is the ID of the model
	ModelID string `json:"model_id"`
}