provider

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

type CacheEntry struct {
	Response  *CompletionResponse
	Timestamp time.Time
}

type CompletionRequest struct {
	// Messages is the conversation history
	Messages []Message `json:"messages"`

	// Model is the model to use (e.g., "gpt-4", "claude-3-opus")
	Model string `json:"model,omitempty"`

	// Temperature controls randomness (0.0-2.0)
	Temperature float64 `json:"temperature,omitempty"`

	// MaxTokens is the maximum number of tokens to generate
	MaxTokens int `json:"max_tokens,omitempty"`

	// Tools available for the model to call
	Tools []Tool `json:"tools,omitempty"`

	// MaxIterations is the maximum number of ReAct iterations (for ReAct providers)
	MaxIterations int `json:"max_iterations,omitempty"`

	// TokenBudget is the total token budget for the entire conversation/loop
	TokenBudget int `json:"token_budget,omitempty"`

	// Additional provider-specific options
	Extra map[string]any `json:"extra,omitempty"`
}

type CompletionResponse struct {
	// Content is the generated text
	Content string `json:"content"`

	// FinishReason explains why generation stopped
	FinishReason string `json:"finish_reason"`

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

	// ToolCalls if the model called any tools
	ToolCalls []ToolCall `json:"tool_calls,omitempty"`

	// Raw is the raw provider response for debugging
	Raw any `json:"raw,omitempty"`
}

type FunctionCall struct {
	Name      string          `json:"name"`
	Arguments json.RawMessage `json:"arguments"`
}

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

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

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

type HuggingFaceStreamResponse struct {
	Token struct {
		ID      int     `json:"id"`
		Text    string  `json:"text"`
		Logprob float64 `json:"logprob"`
		Special bool    `json:"special"`
	} `json:"token"`
	GeneratedText string `json:"generated_text,omitempty"`
	Details       *struct {
		FinishReason string `json:"finish_reason"`
		Tokens       int    `json:"generated_tokens"`
	} `json:"details,omitempty"`
}

type InferenceStream interface {
	Recv() (*inference.GenerateResponse, error)
	Close() error
}

type InstrumentedConfig struct {
	// Calculator for cost tracking (defaults to cost.DefaultCalculator)
	Calculator *cost.Calculator

	// Enabled controls whether instrumentation is active
	Enabled bool
}

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

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

type Message struct {
	Role    string `json:"role"`    // "system", "user", "assistant"
	Content string `json:"content"` // The message content
}

type MockProvider struct {

	// Responses to return for each request
	CompletionResponses []*CompletionResponse
	StructuredResponses []*StructuredResponse
	StreamChunks        [][]*StreamChunk
	Errors              []error

	// Track calls
	CompletionCalls []CompletionRequest
	StructuredCalls []StructuredRequest
	StreamCalls     []CompletionRequest
	// contains filtered or unexported fields
}

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

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

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

type PerformanceMetrics struct {
	TotalRequests    int64
	SuccessfulCalls  int64
	FailedCalls      int64
	CacheHits        int64
	AverageLatency   time.Duration
	TokensProcessed  int64
	ToolCallAccuracy float64
	// contains filtered or unexported fields
}

type Provider interface {
	// CreateCompletion creates a completion (unstructured text response)
	CreateCompletion(ctx context.Context, request CompletionRequest) (*CompletionResponse, error)

	// CreateStructured creates a structured response with schema validation
	CreateStructured(ctx context.Context, request StructuredRequest) (*StructuredResponse, error)

	// CreateStreaming creates a streaming response
	CreateStreaming(ctx context.Context, request CompletionRequest) (Stream, error)

	// Name returns the provider name (e.g., "openai", "anthropic")
	Name() string
}

type ProviderError struct {
	Provider      string `json:"provider"`
	Code          string `json:"code"`
	Message       string `json:"message"`
	Type          string `json:"type,omitempty"`
	StatusCode    int    `json:"status_code,omitempty"`
	IsRetryable   bool   `json:"is_retryable"`
	OriginalError error  `json:"-"`
}

type ProviderFactory func(config map[string]any) (Provider, error)

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

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

type SSEEvent struct {
	Event string
	Data  string
	ID    string
}

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

type Schema struct {
	Type        string             `json:"type,omitempty"`
	Properties  map[string]*Schema `json:"properties,omitempty"`
	Required    []string           `json:"required,omitempty"`
	Items       *Schema            `json:"items,omitempty"`
	Enum        []any              `json:"enum,omitempty"`
	Minimum     *float64           `json:"minimum,omitempty"`
	Maximum     *float64           `json:"maximum,omitempty"`
	MinLength   *int               `json:"minLength,omitempty"`
	MaxLength   *int               `json:"maxLength,omitempty"`
	Pattern     string             `json:"pattern,omitempty"`
	Description string             `json:"description,omitempty"`
	Default     any                `json:"default,omitempty"`
	OneOf       []*Schema          `json:"oneOf,omitempty"`
	AnyOf       []*Schema          `json:"anyOf,omitempty"`
	AllOf       []*Schema          `json:"allOf,omitempty"`
}

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

type Stream interface {
	// Recv receives the next chunk
	Recv() (*StreamChunk, error)

	// Close closes the stream
	Close() error
}

type StreamChunk struct {
	// Delta is the incremental content
	Delta string `json:"delta"`

	// FinishReason if this is the last chunk
	FinishReason string `json:"finish_reason,omitempty"`

	// ToolCallDeltas if tools are being called
	ToolCallDeltas []ToolCallDelta `json:"tool_call_deltas,omitempty"`
}

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

type StreamingInferenceService interface {
	inference.InferenceService
	GenerateStream(ctx context.Context, req inference.GenerateRequest) (InferenceStream, error)
}

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

type StructuredRequest struct {
	CompletionRequest

	// ResponseSchema is the JSON Schema for the expected response
	ResponseSchema json.RawMessage `json:"response_schema"`

	// ResponseFormat specifies the format (e.g., "json_object", "json_schema")
	ResponseFormat string `json:"response_format,omitempty"`

	// StrictSchema enables strict schema adherence (provider-dependent)
	StrictSchema bool `json:"strict_schema,omitempty"`
}

type StructuredResponse struct {
	// Data is the parsed structured data
	Data json.RawMessage `json:"data"`

	// Raw completion response
	CompletionResponse
}

type Tool struct {
	Name        string          `json:"name"`
	Description string          `json:"description"`
	Parameters  json.RawMessage `json:"parameters"` // JSON Schema for parameters
}

type ToolCall struct {
	ID        string          `json:"id"`
	Type      string          `json:"type"` // "function"
	Function  FunctionCall    `json:"function"`
	Arguments json.RawMessage `json:"arguments,omitempty"`
}

type ToolCallDelta struct {
	Index         int    `json:"index"`
	ID            string `json:"id,omitempty"`
	Type          string `json:"type,omitempty"`
	FunctionName  string `json:"function_name,omitempty"`
	ArgumentDelta string `json:"argument_delta,omitempty"`
}

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

type ValidationResult struct {
	Valid  bool     `json:"valid"`
	Errors []string `json:"errors,omitempty"`
}

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

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