types

type AuthConfig struct {
	Method       AuthMethod `json:"method"`
	APIKey       string     `json:"api_key,omitempty"`
	BaseURL      string     `json:"base_url,omitempty"`
	DefaultModel string     `json:"default_model,omitempty"`
}

type AuthMethod string

type AuthenticatedProvider interface {
	// Authentication
	Authenticate(ctx context.Context, authConfig AuthConfig) error
	IsAuthenticated() bool
	Logout(ctx context.Context) error
}

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

type ChatChoice struct {
	Index        int         `json:"index"`
	Message      ChatMessage `json:"message"`
	FinishReason string      `json:"finish_reason"`
	Delta        ChatMessage `json:"delta"`
}

type ChatCompletionChunk struct {
	ID               string                 `json:"id"`
	Object           string                 `json:"object"`
	Created          int64                  `json:"created"`
	Model            string                 `json:"model"`
	Choices          []ChatChoice           `json:"choices"`
	Usage            Usage                  `json:"usage"`
	Done             bool                   `json:"done"`
	Content          string                 `json:"content"`
	Reasoning        string                 `json:"reasoning,omitempty"`         // Reasoning content for clients that want it
	ReasoningContent string                 `json:"reasoning_content,omitempty"` // Alternative reasoning field
	Error            string                 `json:"error"`
	Metadata         map[string]interface{} `json:"metadata,omitempty"`
}

type ChatCompletionStream interface {
	Next() (ChatCompletionChunk, error)
	Close() error
}

type ChatMessage struct {
	Role             string                 `json:"role"`
	Content          string                 `json:"content"`
	Reasoning        string                 `json:"reasoning,omitempty"`         // Reasoning content (e.g., from GLM-4.6, OpenCode/Zen)
	ReasoningContent string                 `json:"reasoning_content,omitempty"` // Alternative reasoning field (e.g., from vLLM/Synthetic)
	ToolCalls        []ToolCall             `json:"tool_calls,omitempty"`
	ToolCallID       string                 `json:"tool_call_id,omitempty"`
	Metadata         map[string]interface{} `json:"metadata,omitempty"`
}

type ChatProvider interface {
	// Core chat capability
	GenerateChatCompletion(ctx context.Context, options GenerateOptions) (ChatCompletionStream, error)
}

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

type CodeGenerationResult struct {
	Code  string `json:"code"`
	Usage *Usage `json:"usage,omitempty"`
}

type ConfigurableProvider interface {
	// Configuration
	Configure(config ProviderConfig) error
	GetConfig() ProviderConfig
}

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

type CoreChatProvider interface {
	// Core chat completion using standard request/response format
	GenerateStandardCompletion(ctx context.Context, request StandardRequest) (*StandardResponse, error)

	// Streaming chat completion using standard format
	GenerateStandardStream(ctx context.Context, request StandardRequest) (StandardStream, error)

	// Get the provider's core extension for format conversion
	GetCoreExtension() CoreProviderExtension

	// Provider capabilities using the standardized format
	GetStandardCapabilities() []string

	// Validate a standard request for this provider
	ValidateStandardRequest(request StandardRequest) error
}

type CoreProvider interface {
	// Basic provider information
	Name() string
	Type() ProviderType
	Description() string
}

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

type CoreProviderExtension interface {
	// Extension information
	Name() string
	Version() string
	Description() string

	// Convert between standard and provider-specific formats
	StandardToProvider(request StandardRequest) (interface{}, error)
	ProviderToStandard(response interface{}) (*StandardResponse, error)
	ProviderToStandardChunk(chunk interface{}) (*StandardStreamChunk, error)

	// Validate provider-specific options
	ValidateOptions(options map[string]interface{}) error

	// Get provider-specific capabilities
	GetCapabilities() []string
}

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

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

type DefaultProviderFactoryExtensions struct {
	ProviderFactory
	// contains filtered or unexported fields
}

type EnhancedRouterMetrics struct {
	TotalRequests      int64 `json:"TotalRequests"`
	SuccessfulRequests int64 `json:"SuccessfulRequests"`
	FailedRequests     int64 `json:"FailedRequests"`
	FallbackAttempts   int64 `json:"FallbackAttempts"`
}

type ErrorMetrics struct {
	TotalErrors      int64            `json:"total_errors"`
	ErrorTypes       map[string]int64 `json:"error_types"`
	LastError        string           `json:"last_error"`
	LastErrorTime    time.Time        `json:"last_error_time"`
	ConsecutiveFails int64            `json:"consecutive_fails"`
}

type ExtensionRegistry interface {
	// Register an extension for a provider type
	Register(providerType ProviderType, extension CoreProviderExtension) error

	// Get extension for a provider type
	Get(providerType ProviderType) (CoreProviderExtension, error)

	// List all registered extensions
	List() map[ProviderType]CoreProviderExtension

	// Check if a provider type has a registered extension
	Has(providerType ProviderType) bool
}

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

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

type FlexibleProviderFactory struct{}

type GenerateOptions struct {
	Prompt         string                 `json:"prompt"`
	Model          string                 `json:"model,omitempty"` // Per-request model override
	Context        string                 `json:"context"`
	ContextObj     context.Context        `json:"-"` // Internal context for operations
	OutputFile     string                 `json:"output_file"`
	Language       *string                `json:"language"`
	ContextFiles   []string               `json:"context_files"`
	Messages       []ChatMessage          `json:"messages"`
	MaxTokens      int                    `json:"max_tokens,omitempty"`
	Temperature    float64                `json:"temperature,omitempty"`
	Stop           []string               `json:"stop,omitempty"`
	Stream         bool                   `json:"stream"`
	Tools          []Tool                 `json:"tools,omitempty"`
	ToolChoice     *ToolChoice            `json:"tool_choice,omitempty"` // Fine-grained tool selection control
	ResponseFormat string                 `json:"response_format,omitempty"`
	Timeout        time.Duration          `json:"timeout,omitempty"`
	Metadata       map[string]interface{} `json:"metadata,omitempty"`
}

type HTTPClient interface {
	Do(req *http.Request) (*http.Response, error)
	Get(url string) (*http.Response, error)
	Post(url string, bodyType string, body io.Reader) (*http.Response, error)
}

type HealthCheckProvider interface {
	// Health and metrics
	HealthCheck(ctx context.Context) error
	GetMetrics() ProviderMetrics
}

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

type HealthStatus struct {
	Healthy      bool      `json:"healthy"`
	LastChecked  time.Time `json:"last_checked"`
	Message      string    `json:"message"`
	ResponseTime float64   `json:"response_time"`
	StatusCode   int       `json:"status_code"`
}

type LatencyTracker interface {
	Add(latency time.Duration)
	GetPercentiles() (min, p50, p95, p99, max time.Duration)
}

type Logger interface {
	Debug(msg string, fields ...interface{})
	Info(msg string, fields ...interface{})
	Warn(msg string, fields ...interface{})
	Error(msg string, fields ...interface{})
	Fatal(msg string, fields ...interface{})
	WithField(key string, value interface{}) Logger
	WithFields(fields map[string]interface{}) Logger
}

type MetricsTracker interface {
	GetMetrics() ProviderMetricsInfo
	RecordRequest(success bool, latency time.Duration, usage *Usage)
}

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

type Model struct {
	ID                   string       `json:"id"`
	Name                 string       `json:"name"`
	Provider             ProviderType `json:"provider"`
	Description          string       `json:"description"`
	MaxTokens            int          `json:"max_tokens"`
	InputTokens          int          `json:"input_tokens"`
	OutputTokens         int          `json:"output_tokens"`
	SupportsStreaming    bool         `json:"supports_streaming"`
	SupportsToolCalling  bool         `json:"supports_tool_calling"`
	SupportsResponsesAPI bool         `json:"supports_responses_api"`
	Capabilities         []string     `json:"capabilities"`
	Pricing              Pricing      `json:"pricing"`
}

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

type ModelMetrics struct {
	ModelID         string        `json:"model_id"`
	Provider        ProviderType  `json:"provider"`
	RequestCount    int64         `json:"request_count"`
	SuccessCount    int64         `json:"success_count"`
	ErrorCount      int64         `json:"error_count"`
	TokensUsed      int64         `json:"tokens_used"`
	AverageLatency  time.Duration `json:"average_latency"`
	LastRequestTime time.Time     `json:"last_request_time"`
	P95ResponseTime time.Duration `json:"p95_response_time"`
	P99ResponseTime time.Duration `json:"p99_response_time"`
}

type ModelProvider interface {
	// Model management
	GetModels(ctx context.Context) ([]Model, error)
	GetDefaultModel() string
}

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

type OAuthConfig struct {
	ClientID     string    `json:"client_id"`
	ClientSecret string    `json:"client_secret"`
	RedirectURL  string    `json:"redirect_url,omitempty"`
	Scopes       []string  `json:"scopes"`
	AuthURL      string    `json:"auth_url,omitempty"`
	TokenURL     string    `json:"token_url,omitempty"`
	RefreshToken string    `json:"refresh_token,omitempty"`
	AccessToken  string    `json:"access_token,omitempty"`
	ExpiresAt    time.Time `json:"expires_at,omitempty"`

	// OnTokenRefresh is called when OAuth tokens are refreshed
	// Parameters: accessToken, refreshToken, expiresAt
	// The callback should return an error if token persistence fails
	OnTokenRefresh func(accessToken, refreshToken string, expiresAt time.Time) error `json:"-"`
}

type OAuthCredentialSet struct {
	// Unique identifier for this credential set (e.g., "account-1", "team-account")
	ID string `json:"id"`

	// OAuth client credentials
	ClientID     string `json:"client_id"`
	ClientSecret string `json:"client_secret"`

	// OAuth tokens
	AccessToken  string    `json:"access_token"`
	RefreshToken string    `json:"refresh_token"`
	ExpiresAt    time.Time `json:"expires_at"`

	// OAuth scopes for this credential
	Scopes []string `json:"scopes,omitempty"`

	// Metadata for tracking
	LastRefresh  time.Time `json:"last_refresh,omitempty"`
	RefreshCount int       `json:"refresh_count"`

	// Callback for when tokens are refreshed
	// Parameters: id, accessToken, refreshToken, expiresAt
	// The callback should persist the new tokens and return an error if persistence fails
	OnTokenRefresh func(id, accessToken, refreshToken string, expiresAt time.Time) error `json:"-"`
}

type Options interface {
	Get(key string) (interface{}, bool)
	Set(key string, value interface{})
	GetString(key string) string
	GetInt(key string) int
	GetBool(key string) bool
	GetDuration(key string) time.Duration
	GetStringSlice(key string) []string
}

type OverallLatencyMetrics struct {
	MinLatency time.Duration `json:"MinLatency"`
	P50Latency time.Duration `json:"P50Latency"`
	P95Latency time.Duration `json:"P95Latency"`
	P99Latency time.Duration `json:"P99Latency"`
	MaxLatency time.Duration `json:"MaxLatency"`
}

type Pricing struct {
	InputTokenPrice  float64 `json:"input_token_price"`
	OutputTokenPrice float64 `json:"output_token_price"`
	Unit             string  `json:"unit"`
}

type Provider interface {
	CoreProvider
	ModelProvider
	AuthenticatedProvider
	ConfigurableProvider
	ChatProvider
	ToolCallingProvider
	StreamingProvider
	ResponsesAPIProvider
	HealthCheckProvider
}

type ProviderConfig struct {
	Type           ProviderType           `json:"type"`
	Name           string                 `json:"name"`
	BaseURL        string                 `json:"base_url,omitempty"`
	APIKey         string                 `json:"api_key,omitempty"`
	APIKeyEnv      string                 `json:"api_key_env,omitempty"`
	DefaultModel   string                 `json:"default_model,omitempty"`
	Description    string                 `json:"description,omitempty"`
	ProviderConfig map[string]interface{} `json:"provider_config,omitempty"`

	// Multiple OAuth credentials for failover (multi-OAuth)
	OAuthCredentials []*OAuthCredentialSet `json:"oauth_credentials,omitempty"`

	// Feature flags
	SupportsStreaming    bool `json:"supports_streaming"`
	SupportsToolCalling  bool `json:"supports_tool_calling"`
	SupportsResponsesAPI bool `json:"supports_responses_api"`

	// Limits and timeouts
	MaxTokens int           `json:"max_tokens,omitempty"`
	Timeout   time.Duration `json:"timeout,omitempty"`

	// Tool format
	ToolFormat ToolFormat `json:"tool_format,omitempty"`
}

type ProviderFactory interface {
	RegisterProvider(providerType ProviderType, factoryFunc func(ProviderConfig) Provider)
	CreateProvider(providerType ProviderType, config ProviderConfig) (Provider, error)
	GetSupportedProviders() []ProviderType
}

type ProviderFactoryExtensions interface {
	ProviderFactory

	// Create a core provider adapter
	CreateCoreProvider(providerType ProviderType, config ProviderConfig) (CoreChatProvider, error)

	// Get supported provider types for core API
	GetSupportedCoreProviders() []ProviderType

	// Check if a provider type supports the core API
	SupportsCoreAPI(providerType ProviderType) bool
}

type ProviderInfo struct {
	Name           string       `json:"name"`
	Type           ProviderType `json:"type"`
	Description    string       `json:"description"`
	HealthStatus   HealthStatus `json:"health_status"`
	Models         []Model      `json:"models"`
	SupportedTools []string     `json:"supported_tools"`
	DefaultModel   string       `json:"default_model"`
}

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

type ProviderMetrics struct {
	RequestCount    int64         `json:"request_count"`
	SuccessCount    int64         `json:"success_count"`
	ErrorCount      int64         `json:"error_count"`
	TotalLatency    time.Duration `json:"total_latency"`
	AverageLatency  time.Duration `json:"average_latency"`
	LastRequestTime time.Time     `json:"last_request_time"`
	LastSuccessTime time.Time     `json:"last_success_time"`
	LastErrorTime   time.Time     `json:"last_error_time"`
	LastError       string        `json:"last_error"`
	TokensUsed      int64         `json:"tokens_used"`
	HealthStatus    HealthStatus  `json:"health_status"`
}

type ProviderMetricsInfo struct {
	Name            string        `json:"name"`
	IsModel         bool          `json:"is_model"`
	RequestCount    int64         `json:"request_count"`
	SuccessCount    int64         `json:"success_count"`
	ErrorCount      int64         `json:"error_count"`
	AverageLatency  time.Duration `json:"average_latency"`
	LastRequestTime time.Time     `json:"last_request_time"`
	TokensUsed      int64         `json:"tokens_used"`
}

type ProviderRegistry interface {
	Register(provider Provider) error
	Unregister(name string) error
	Get(name string) (Provider, error)
	List() []Provider
	ListByType(providerType ProviderType) []Provider
	GetAvailable() []Provider
	GetHealthy() []Provider
}

type ProviderType string

type ResponsesAPIProvider interface {
	// Responses API support
	SupportsResponsesAPI() bool
}

type Router interface {
	SelectProvider(prompt string, options interface{}) (Provider, error)
	GetAvailableProviders() []ProviderInfo
	GetProvider(name string) (Provider, error)
	SetPreference(providerName string) error
}

type RouterHealthStatus struct {
	IsHealthy    bool          `json:"IsHealthy"`
	LastChecked  time.Time     `json:"LastChecked"`
	ErrorMessage string        `json:"ErrorMessage,omitempty"`
	ResponseTime time.Duration `json:"ResponseTime"`
}

type RouterMetrics struct {
	TotalRequests       int64                       `json:"total_requests"`
	SuccessfulRequests  int64                       `json:"successful_requests"`
	FailedRequests      int64                       `json:"failed_requests"`
	ProviderUsage       map[string]int64            `json:"provider_usage"`
	AverageResponseTime time.Duration               `json:"average_response_time"`
	ProviderMetrics     map[string]*ProviderMetrics `json:"provider_metrics"`
	LastReset           time.Time                   `json:"last_reset"`
}

type StandardChoice struct {
	Index        int         `json:"index"`
	Message      ChatMessage `json:"message"`
	FinishReason string      `json:"finish_reason"`
}

type StandardRequest struct {
	// Core content
	Messages []ChatMessage `json:"messages"`

	// Model selection
	Model string `json:"model,omitempty"`

	// Generation parameters
	MaxTokens   int      `json:"max_tokens,omitempty"`
	Temperature float64  `json:"temperature,omitempty"`
	Stop        []string `json:"stop,omitempty"`

	// Streaming control
	Stream bool `json:"stream"`

	// Tool support (if provider supports it)
	Tools      []Tool      `json:"tools,omitempty"`
	ToolChoice *ToolChoice `json:"tool_choice,omitempty"`

	// Response format (for providers that support structured output)
	ResponseFormat string `json:"response_format,omitempty"`

	// Context and metadata
	Context  context.Context        `json:"-"`
	Timeout  time.Duration          `json:"-"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type StandardResponse struct {
	// Core response
	ID      string `json:"id"`
	Model   string `json:"model"`
	Object  string `json:"object"`
	Created int64  `json:"created"`

	// Content
	Choices []StandardChoice `json:"choices"`

	// Usage information
	Usage Usage `json:"usage"`

	// Provider-specific metadata
	ProviderMetadata map[string]interface{} `json:"provider_metadata,omitempty"`
}

type StandardStream interface {
	// Next returns the next chunk from the stream
	Next() (*StandardStreamChunk, error)

	// Close closes the stream
	Close() error

	// Done returns true if the stream is finished
	Done() bool
}

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

type StandardStreamChoice struct {
	Index        int         `json:"index"`
	Delta        ChatMessage `json:"delta"`
	FinishReason string      `json:"finish_reason,omitempty"`
}

type StandardStreamChunk struct {
	ID      string `json:"id"`
	Model   string `json:"model"`
	Object  string `json:"object"`
	Created int64  `json:"created"`

	// Content
	Choices []StandardStreamChoice `json:"choices"`

	// Usage information (may be nil for intermediate chunks)
	Usage *Usage `json:"usage,omitempty"`

	// Stream state
	Done bool `json:"done"`

	// Provider-specific metadata
	ProviderMetadata map[string]interface{} `json:"provider_metadata,omitempty"`
}

type StreamingProvider interface {
	// Streaming support
	SupportsStreaming() bool
}

type TokenMetrics struct {
	InputTokens   int64     `json:"input_tokens"`
	OutputTokens  int64     `json:"output_tokens"`
	TotalTokens   int64     `json:"total_tokens"`
	EstimatedCost float64   `json:"estimated_cost"`
	Currency      string    `json:"currency"`
	LastUpdated   time.Time `json:"last_updated"`
}

type TokenStorage interface {
	StoreToken(key string, token *OAuthConfig) error
	RetrieveToken(key string) (*OAuthConfig, error)
	DeleteToken(key string) error
	ListTokens() ([]string, error)
}

type Tool struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	InputSchema map[string]interface{} `json:"input_schema"`
}

type ToolCall struct {
	ID       string                 `json:"id"`
	Type     string                 `json:"type"`
	Function ToolCallFunction       `json:"function"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type ToolCallFunction struct {
	Name      string `json:"name"`
	Arguments string `json:"arguments"`
}

type ToolCallingProvider interface {
	// Tool invocation
	InvokeServerTool(ctx context.Context, toolName string, params interface{}) (interface{}, error)

	// Tool format support
	SupportsToolCalling() bool
	GetToolFormat() ToolFormat
}

type ToolChoice struct {
	Mode         ToolChoiceMode `json:"mode"`
	FunctionName string         `json:"function_name,omitempty"` // For "specific" mode
}

type ToolChoiceMode string

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

type ToolFormat string

type Usage struct {
	PromptTokens     int `json:"prompt_tokens"`
	CompletionTokens int `json:"completion_tokens"`
	TotalTokens      int `json:"total_tokens"`
}

type ValidationError struct {
	Message string
}