types

type Client interface {
	// NewRequest creates a new request builder for constructing LLM requests.
	NewRequest() *RequestBuilder
}

type Connection struct {
	types.HTTP
	Backend LLMBackend
	Model   string
}

type Cost struct {
	Model string `json:"model,omitempty"`
	// Multiple models can be used during to full a single request (e.g., cache + reasoning + LLM)
	ModelType    ModelType `json:"model_type,omitempty"`
	InputTokens  int       `json:"input_tokens,omitempty"`
	OutputTokens int       `json:"output_tokens,omitempty"`
	TotalTokens  int       `json:"total_tokens,omitempty"`
	InputCost    float64   `json:"input_cost,omitempty"`
	OutputCost   float64   `json:"output_cost,omitempty"`
}

type CostInfo struct {
	InputTokens      int     `json:"inputTokens"`
	OutputTokens     int     `json:"outputTokens"`
	ReasoningTokens  *int    `json:"reasoningTokens,omitempty"`
	CacheReadTokens  *int    `json:"cacheReadTokens,omitempty"`
	CacheWriteTokens *int    `json:"cacheWriteTokens,omitempty"`
	Cost             float64 `json:"cost"`
	Model            string  `json:"model"`
	CostError        *string `json:"costCalculationError,omitempty"`
}

type Costs []Cost

type LLMBackend string

type ModelInfo struct {
	Provider            LLMBackend
	ModelID             string
	MaxTokens           int
	ContextWindow       int
	SupportsImages      bool
	SupportsPromptCache bool
	InputPrice          float64 // Per million tokens
	OutputPrice         float64 // Per million tokens
	InputPriceTiers     []PriceTier
	OutputPriceTiers    []PriceTier
	CacheWritesPrice    float64 // Per million tokens
	CacheReadsPrice     float64 // Per million tokens
}

type ModelType string

type OpenRouterModel struct {
	ID            string            `json:"id"`
	Name          string            `json:"name"`
	Pricing       OpenRouterPricing `json:"pricing"`
	ContextLength int               `json:"context_length"`
	TopProvider   *TopProvider      `json:"top_provider,omitempty"`
}

type OpenRouterPricing struct {
	Prompt            string `json:"prompt"`                       // Per-token input price
	Completion        string `json:"completion"`                   // Per-token output price
	Request           string `json:"request,omitempty"`            // Per-request fee
	Image             string `json:"image,omitempty"`              // Image processing cost
	InternalReasoning string `json:"internal_reasoning,omitempty"` // Reasoning token cost
	InputCacheRead    string `json:"input_cache_read,omitempty"`   // Cache read cost
	InputCacheWrite   string `json:"input_cache_write,omitempty"`  // Cache write cost
}

type OpenRouterResponse struct {
	Data []OpenRouterModel `json:"data"`
}

type PriceTier struct {
	TokenLimit int     // Upper limit (inclusive)
	Price      float64 // Per million tokens
}

type PricingCache struct {
	Timestamp time.Time             `json:"timestamp"`
	Models    map[string]*ModelInfo `json:"models"`
}

type Provider interface {
	// Execute sends a request to the LLM provider and returns the response.
	Execute(ctx *Session, req ProviderRequest) (ProviderResponse, error)

	// GetModel returns the model name configured for this provider.
	GetModel() string

	// GetBackend returns the backend type for this provider.
	GetBackend() LLMBackend

	// GetOpenRouterModelID returns the OpenRouter model identifier for pricing lookups.
	// Returns empty string if the model is not available on OpenRouter.
	GetOpenRouterModelID() string
}

type ProviderRequest struct {
	SystemPrompt     string
	Prompt           string
	MaxTokens        *int
	StructuredOutput interface{} // Schema for structured JSON output
	Model            string
	APIKey           string
	APIURL           string
}

type ProviderResponse struct {
	Cached           bool
	Text             string
	StructuredData   interface{} // Populated if structured output was requested
	Model            string
	InputTokens      int
	OutputTokens     int
	ReasoningTokens  *int
	CacheReadTokens  *int
	CacheWriteTokens *int
	Raw              interface{} // Raw provider-specific response
}

type RequestBuilder struct {
	Provider         Provider
	SystemPrompt     string
	Prompt           string
	MaxTokens        *int
	Timeout          time.Duration
	StructuredOutput interface{}
}

type Response struct {
	// Text is the text response from the LLM (empty if structured output was requested).
	Text string

	// StructuredData contains the parsed structured output if WithStructuredOutput was used.
	StructuredData interface{}

	// CostInfo provides token usage and cost information for this request.
	CostInfo CostInfo

	// Model is the specific model that generated the response.
	Model string

	// Provider is the LLM provider (openai, anthropic, gemini).
	Provider string
}

type Session struct {
	context.Context
	Model       string
	ID          string
	ProjectName string
	Costs       Costs
	// contains filtered or unexported fields
}

type TopProvider struct {
	MaxCompletionTokens *int `json:"max_completion_tokens,omitempty"`
}