client

type AdaptiveRateLimitConfig struct {
	// RPMLimit is the maximum requests per minute (0 = no limit).
	RPMLimit int
	// TPMLimit is the maximum tokens per minute (0 = no limit).
	TPMLimit int
	// ThresholdPercent is the percentage of remaining quota below which
	// the provider starts throttling. Default is 10 (i.e., <10% remaining).
	ThresholdPercent int
	// MaxDelay is the maximum time to delay when throttling.
	// Default is 10 seconds. Set to 0 to return an error instead of delaying.
	MaxDelay time.Duration
	// HeaderExtractor is an optional function to extract rate limit info from
	// HTTP response headers. If nil, only internal tracking is used.
	HeaderExtractor HeaderExtractor
}

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

type Alert struct {
	Level     string
	Message   string
	Timestamp time.Time
	Threshold float64
}

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

type AnthropicClientConfig struct {
	APIKey         string            `json:"-"`
	DefaultHeaders map[string]string `json:"default_headers,omitempty"`
	Timeout        int               `json:"timeout,omitempty"`
	MaxRetries     int               `json:"max_retries,omitempty"`
	Provider       string            `json:"provider,omitempty"`
	BaseURL        string            `json:"base_url,omitempty"`
}

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

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

type BatchRequest struct {
	CustomID string         `json:"custom_id"`
	Messages []EyrieMessage `json:"messages"`
	Options  ChatOptions    `json:"options"`
}

type BatchResponse struct {
	CustomID string         `json:"custom_id"`
	Response *EyrieResponse `json:"response,omitempty"`
	Error    string         `json:"error,omitempty"`
}

type BatchResult struct {
	ID        string          `json:"id"`
	Status    string          `json:"status"` // "in_progress", "ended", "failed"
	Responses []BatchResponse `json:"responses,omitempty"`
	CreatedAt time.Time       `json:"created_at"`
}

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

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

type BudgetStore interface {
	// CheckBudget returns ErrBudgetExceeded if charging estCostUSD to the key
	// would exceed its budget, ErrUnknownVirtualKey if the key is unknown, or
	// nil if the request may proceed.
	CheckBudget(ctx context.Context, virtualKey string, estCostUSD float64) error
	// RecordUsage records actual spend against a virtual key after a call.
	RecordUsage(ctx context.Context, virtualKey string, costUSD float64, tokensIn, tokensOut int) error
}

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

type CacheConfig struct {
	// MaxAge is how long cache entries remain valid. Default: 5 minutes.
	MaxAge time.Duration
	// MaxSize is the maximum number of cached responses. Default: 100.
	// When exceeded, the least-recently-used entry is evicted.
	MaxSize int
	// Enabled toggles caching. Default: true.
	// When false, the CachedProvider passes all requests through unchanged.
	Enabled bool
	// TemperatureThreshold is the temperature above which responses are not cached.
	// Default: 0.5. Responses with temperature > threshold are expected to vary,
	// so caching them would defeat the purpose.
	TemperatureThreshold float64
}

type CacheControlType string

type CacheReport struct {
	TotalCalls   int           `json:"total_calls"`
	CacheHits    int           `json:"cache_hits"`
	CacheMisses  int           `json:"cache_misses"`
	HitRate      float64       `json:"hit_rate"`
	TokensSaved  int           `json:"tokens_saved"`
	CostSaved    float64       `json:"cost_saved_usd"`
	LatencySaved time.Duration `json:"latency_saved"`
}

type CacheStatsResult struct {
	Size    int  `json:"size"`
	MaxSize int  `json:"max_size"`
	Enabled bool `json:"enabled"`
}

type CachedContent struct {
	Type         string      `json:"type"`
	Text         string      `json:"text"`
	CacheControl interface{} `json:"cache_control,omitempty"`
}

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

type CallMetrics struct {
	Model               string    `json:"model"`
	Provider            string    `json:"provider"`
	InputTokens         int       `json:"input_tokens"`
	OutputTokens        int       `json:"output_tokens"`
	CacheReadTokens     int       `json:"cache_read_tokens"`
	CacheCreationTokens int       `json:"cache_creation_tokens"`
	LatencyMs           int64     `json:"latency_ms"`
	Timestamp           time.Time `json:"timestamp"`
}

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

type Cassette struct {
	Name         string        `json:"name"`
	RecordedAt   time.Time     `json:"recorded_at"`
	Provider     string        `json:"provider"`
	Interactions []Interaction `json:"interactions"`
}

type ChatOptions struct {
	Provider       string          `json:"provider,omitempty"`
	Model          string          `json:"model,omitempty"`
	Temperature    *float64        `json:"temperature,omitempty"`
	MaxTokens      int             `json:"max_tokens,omitempty"`
	Stream         bool            `json:"stream,omitempty"`
	Tools          []EyrieTool     `json:"tools,omitempty"`
	System         string          `json:"system,omitempty"`
	EnableCaching  bool            `json:"enable_caching,omitempty"`
	ResponseFormat *ResponseFormat `json:"response_format,omitempty"`
	// ReasoningEffort hints how much reasoning the model should perform.
	// Valid values are "low", "medium", or "high" (see ReasoningLow/Medium/High).
	// Only applied for OpenAI-compatible providers whose compat config sets
	// SupportsReasoningEffort.
	ReasoningEffort string `json:"reasoning_effort,omitempty"`
	// ThinkingBudgetTokens enables Anthropic extended thinking with the given
	// token budget when greater than zero. Ignored by other providers.
	ThinkingBudgetTokens int `json:"thinking_budget_tokens,omitempty"`
	// ThinkingMode controls Anthropic thinking behavior: "enabled", "adaptive", or "disabled".
	// When set, takes precedence over ThinkingBudgetTokens (except "enabled" which uses the budget).
	ThinkingMode string `json:"thinking_mode,omitempty"`
	// ThinkingDisplay controls how thinking is shown: "summarized" (default) or "omitted".
	ThinkingDisplay string `json:"thinking_display,omitempty"`
	// GLMThinkingEnabled toggles GLM/Z.ai extended reasoning via the provider's
	// non-OpenAI thinking={"type":"enabled"|"disabled"} request parameter. Only
	// applied for OpenAI-compatible providers whose compat config sets
	// ThinkingFormat to "zai". When nil the parameter is omitted and the model
	// uses its default (GLM defaults to enabled). Ignored by other providers.
	GLMThinkingEnabled *bool `json:"glm_thinking_enabled,omitempty"`
	// VirtualKeyID optionally attributes the request to a logical virtual key
	// for budget enforcement and cost accounting (see BudgetProvider). When
	// empty, the BudgetProvider also checks the request context.
	VirtualKeyID string `json:"virtual_key_id,omitempty"`
	// KimiContextCacheID, when set, prepends a cache-role message to the
	// request for Kimi/Moonshot context caching. Only effective when the
	// provider compat is KimiCompat (SupportsCacheRole true).
	KimiContextCacheID string `json:"kimi_context_cache_id,omitempty"`
	// KimiCacheResetTTL resets the TTL of the cache on use when true.
	// Only effective when KimiContextCacheID is also set.
	KimiCacheResetTTL bool `json:"kimi_cache_reset_ttl,omitempty"`

	// Shared parameters (Anthropic + OpenAI)
	TopP           *float64          `json:"top_p,omitempty"`            // nucleus sampling (0.0-1.0)
	TopK           *int              `json:"top_k,omitempty"`            // top-K sampling (Anthropic only)
	StopSequences  []string          `json:"stop_sequences,omitempty"`   // custom stop sequences
	ToolChoice     *ToolChoiceOption `json:"tool_choice,omitempty"`      // tool use control
	MetadataUserID string            `json:"metadata_user_id,omitempty"` // user ID for abuse detection / monitoring
	ServiceTier    string            `json:"service_tier,omitempty"`     // "auto", "default", "flex", "priority"
	OutputEffort   string            `json:"output_effort,omitempty"`    // "low","medium","high","xhigh","max" (Anthropic)
	OutputSchema   string            `json:"output_schema,omitempty"`    // JSON schema string for structured output (Anthropic)

	// OpenAI-specific parameters
	PresencePenalty  *float64          `json:"presence_penalty,omitempty"`   // -2.0 to 2.0
	FrequencyPenalty *float64          `json:"frequency_penalty,omitempty"`  // -2.0 to 2.0
	N                *int              `json:"n,omitempty"`                  // number of completions (1-128)
	LogProbs         *bool             `json:"logprobs,omitempty"`           // return log probabilities
	TopLogProbs      *int              `json:"top_logprobs,omitempty"`       // 0-20, requires logprobs=true
	Seed             *int              `json:"seed,omitempty"`               // deterministic sampling
	Store            *bool             `json:"store,omitempty"`              // store output for Responses API
	Metadata         map[string]string `json:"metadata,omitempty"`           // developer tags
	Modalities       []string          `json:"modalities,omitempty"`         // "text", "audio"
	AudioConfig      string            `json:"audio_config,omitempty"`       // JSON: {voice, format}
	Prediction       string            `json:"prediction,omitempty"`         // JSON: {type:"content", content:"..."}
	WebSearchOptions string            `json:"web_search_options,omitempty"` // JSON: {search_context_size, user_location}
}

type ChatProtocol int

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

type CoalesceKey struct {
	Provider    string         `json:"provider"`
	Model       string         `json:"model"`
	Messages    []EyrieMessage `json:"messages"`
	Temperature *float64       `json:"temperature,omitempty"`
	MaxTokens   int            `json:"max_tokens,omitempty"`
}

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

type CondenseOptions struct {
	// MaxSize is the message-count threshold above which condensation runs.
	// When len(messages) <= MaxSize, the history is returned unchanged.
	MaxSize int
	// KeepFirst is the number of leading messages preserved verbatim (e.g. a
	// system prompt and the opening turns). The middle span between the kept
	// head and tail is what gets summarized.
	KeepFirst int
}

type CondenserOption func(*LLMSummarizingCondenser)

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

type ContentPart struct {
	Type       string          `json:"type"`                  // "text", "image_url", "input_audio"
	Text       string          `json:"text,omitempty"`        // for type="text"
	ImageURL   *ImageURLPart   `json:"image_url,omitempty"`   // for type="image_url"
	InputAudio *InputAudioPart `json:"input_audio,omitempty"` // for type="input_audio"
}

type ContinuationConfig struct {
	// MaxContinuations is the maximum number of continuation calls (default 3).
	MaxContinuations int
	// MaxTotalTokens caps the total output tokens across all continuations (0 = unlimited).
	MaxTotalTokens int
}

type ConversationCondenser interface {
	// Condense returns a reduced copy of messages according to opts. It must
	// not mutate the input slice. When no reduction is needed it may return the
	// input slice unchanged.
	Condense(ctx context.Context, messages []EyrieMessage, opts CondenseOptions) ([]EyrieMessage, error)
}

type CostEstimate struct {
	InputTokens   int     `json:"input_tokens"`
	OutputTokens  int     `json:"estimated_output_tokens"`
	InputCostUSD  float64 `json:"input_cost_usd"`
	OutputCostUSD float64 `json:"estimated_output_cost_usd"`
	TotalCostUSD  float64 `json:"estimated_total_cost_usd"`
	Model         string  `json:"model"`
	CacheDiscount float64 `json:"cache_discount_usd"` // potential savings if cached
}

type CostEstimator struct{}

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

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

type DeprecationInfo struct {
	Model       string    `json:"model"`
	Deprecated  bool      `json:"deprecated"`
	RetireDate  time.Time `json:"retire_date"`
	Replacement string    `json:"replacement"`
	Message     string    `json:"message"`
}

type Embedder interface {
	CreateEmbedding(ctx context.Context, req EmbeddingRequest) (*EmbeddingResponse, error)
}

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

type EmbeddingParams struct {
	Indexing map[string]string `json:"indexing,omitempty"`
	Query    map[string]string `json:"query,omitempty"`
}

type EmbeddingRequest struct {
	Model  string            `json:"model"`
	Input  []string          `json:"input"`
	Params map[string]string `json:"params,omitempty"` // indexing or query params
}

type EmbeddingResponse struct {
	Embeddings [][]float32 `json:"embeddings"`
	Model      string      `json:"model"`
	Usage      *EyrieUsage `json:"usage,omitempty"`
}

type ExtractOptions struct {
	// Chat carries provider/model/temperature for the extraction call. If Model
	// is empty the provider default is used.
	Chat ChatOptions
	// Instruction overrides the default extraction instruction. Use it to scope
	// what relations to extract (e.g. "extract only code dependency relations").
	// When empty, a general noun-constrained instruction is used.
	Instruction string
	// AllowedPredicates, when non-empty, constrains the predicate vocabulary —
	// the model is told to use only these relation types, and triples with other
	// predicates are dropped after extraction. This is the lightweight analogue
	// of CocoIndex's EntityTypeConfig schema constraint.
	AllowedPredicates []string
	// MaxRetries is the schema-validation retry budget. Defaults to 2.
	MaxRetries int
}

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

type EyrieConfig struct {
	Provider   string `json:"provider,omitempty"`
	APIKey     string `json:"-"`
	BaseURL    string `json:"base_url,omitempty"`
	Model      string `json:"model,omitempty"`
	MaxRetries int    `json:"max_retries,omitempty"`
}

type EyrieError struct {
	Provider   string
	Op         string // operation that failed (e.g. "chat", "stream", "ping")
	StatusCode int
	RequestID  string
	Message    string
	Err        error
}

type EyrieMessage struct {
	Role         string        `json:"role"`
	Content      string        `json:"content,omitempty"`
	Thinking     string        `json:"thinking,omitempty"`      // chain-of-thought captured from a prior response (never forwarded to providers that reject it)
	ContentParts []ContentPart `json:"content_parts,omitempty"` // multi-modal content (takes precedence over Content/Images)
	Images       []string      `json:"images,omitempty"`
	ToolUse      []ToolCall    `json:"tool_use,omitempty"`     // assistant message with tool calls
	ToolResults  []ToolResult  `json:"tool_results,omitempty"` // user message with one or more tool results
}

type EyrieResponse struct {
	Content        string      `json:"content"`
	Thinking       string      `json:"thinking,omitempty"`
	Usage          *EyrieUsage `json:"usage,omitempty"`
	ToolCalls      []ToolCall  `json:"tool_calls,omitempty"`
	FinishReason   string      `json:"finish_reason"`
	RequestID      string      `json:"request_id,omitempty"`
	OrganizationID string      `json:"organization_id,omitempty"`
}

type EyrieStreamEvent struct {
	Type       string      `json:"type"` // content, tool_call, tool_input_delta, thinking, done, error, ttft
	Content    string      `json:"content,omitempty"`
	ToolCall   *ToolCall   `json:"tool_call,omitempty"`
	Thinking   string      `json:"thinking,omitempty"`
	Error      string      `json:"error,omitempty"`
	RequestID  string      `json:"request_id,omitempty"`
	Usage      *EyrieUsage `json:"usage,omitempty"`
	StopReason string      `json:"stop_reason,omitempty"`
	TTFTms     int         `json:"ttft_ms,omitempty"` // time-to-first-token milliseconds, set on "done" event
	// TTFT carries time-to-first-token milliseconds on Type=="ttft" events.
	// It is emitted as a dedicated event immediately before the first content
	// or tool-call delta so consumers can measure latency without waiting for
	// the stream to finish.
	TTFT int `json:"ttft,omitempty"`
}

type EyrieTool struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	Parameters  map[string]interface{} `json:"parameters"`
}

type EyrieUsage struct {
	PromptTokens        int `json:"prompt_tokens"`
	CompletionTokens    int `json:"completion_tokens"`
	TotalTokens         int `json:"total_tokens"`
	CacheCreationTokens int `json:"cache_creation_tokens,omitempty"`
	CacheReadTokens     int `json:"cache_read_tokens,omitempty"`
	ThinkingTokens      int `json:"thinking_tokens,omitempty"`
}

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

type FeatureSet struct {
	Thinking         bool `json:"thinking"`
	AdaptiveThinking bool `json:"adaptive_thinking"`
	ToolUse          bool `json:"tool_use"`
	Images           bool `json:"images"`
	Streaming        bool `json:"streaming"`
	Caching          bool `json:"caching"`
	JSON             bool `json:"json_mode"`
	Embeddings       bool `json:"embeddings"`
	MaxContext       int  `json:"max_context"`
	MaxOutput        int  `json:"max_output"`
	Effort           bool `json:"effort"`
	StructuredOutput bool `json:"structured_output"`
	CodeExecution    bool `json:"code_execution"`
	Citations        bool `json:"citations"`
	PDFInput         bool `json:"pdf_input"`
}

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

type GuardrailAction string

type GuardrailError struct {
	Violations []GuardrailViolation `json:"violations"`
	Message    string               `json:"message"`
}

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

type GuardrailRule struct {
	Type     GuardrailType     `json:"type"`
	Name     string            `json:"name"`
	Pattern  string            `json:"pattern"`
	Action   GuardrailAction   `json:"action"`
	Severity GuardrailSeverity `json:"severity"`
	// contains filtered or unexported fields
}

type GuardrailSeverity string

type GuardrailType string

type GuardrailViolation struct {
	Rule           GuardrailRule `json:"rule"`
	MatchedText    string        `json:"matched_text"`
	RedactedResult string        `json:"redacted_result,omitempty"`
	// contains filtered or unexported fields
}

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

type HeaderExtractor func(h http.Header) *RateLimitHeaders

type ImageURLPart struct {
	URL    string `json:"url"`
	Detail string `json:"detail,omitempty"` // "auto", "low", "high" (OpenAI-specific)
}

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

type InflightStats struct {
	// InflightRequests is the number of unique requests being executed
	InflightRequests int
	// TotalWaiters is the total number of goroutines waiting across all requests
	TotalWaiters int
}

type InputAudioPart struct {
	Data   string `json:"data"`   // base64 encoded audio
	Format string `json:"format"` // "wav", "mp3" (OpenAI) or used to derive media_type (Anthropic)
}

type Interaction struct {
	Request  RecordedRequest  `json:"request"`
	Response RecordedResponse `json:"response"`
}

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

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

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

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

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

type MockCall struct {
	Messages []EyrieMessage
	Options  ChatOptions
}

type MockMode string

type MockProvider struct {
	Mode     MockMode
	Response string // used in MockModeFixed
	ToolName string // used in MockModeToolUse
	ToolArgs map[string]interface{}
	Delay    time.Duration // simulate latency
	Calls    []MockCall    // recorded calls for assertions
	// contains filtered or unexported fields
}

type ModelRoles struct {
	Primary string `json:"primary,omitempty"`
	Weak    string `json:"weak,omitempty"`
	Editor  string `json:"editor,omitempty"`
}

type ModerationOption func(*ModerationProvider)

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

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

type OpenAICompatConfig struct {
	SupportsStore                    bool   `json:"supports_store,omitempty"`
	SupportsDeveloperRole            bool   `json:"supports_developer_role,omitempty"`
	SupportsReasoningEffort          bool   `json:"supports_reasoning_effort,omitempty"`
	SupportsUsageInStreaming         bool   `json:"supports_usage_in_streaming,omitempty"`
	SupportsStrictMode               bool   `json:"supports_strict_mode,omitempty"`
	MaxTokensField                   string `json:"max_tokens_field,omitempty"` // "max_tokens" or "max_completion_tokens"
	RequiresToolResultName           bool   `json:"requires_tool_result_name,omitempty"`
	RequiresAssistantAfterToolResult bool   `json:"requires_assistant_after_tool_result,omitempty"`
	RequiresThinkingAsText           bool   `json:"requires_thinking_as_text,omitempty"`
	ThinkingFormat                   string `json:"thinking_format,omitempty"` // "openai", "zai", "qwen", "openrouter"
	// StripReasoningFromInput instructs buildRequestBase to omit the reasoning_content
	// field from assistant messages. DeepSeek (and compatible providers) return HTTP 400
	// if reasoning_content appears in the input context of a multi-turn conversation.
	StripReasoningFromInput bool `json:"strip_reasoning_from_input,omitempty"`
	// SupportsCacheRole enables Kimi/Moonshot context-cache injection: when
	// ChatOptions.KimiContextCacheID is non-empty, buildRequestBase prepends a
	// {"role":"cache","content":<id>} message per the MoonshotAI-Cookbook spec.
	SupportsCacheRole bool `json:"supports_cache_role,omitempty"`
}

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

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

type ProtocolChatFallback func(primaryErr error, primaryResp *EyrieResponse) bool

type ProtocolRouter struct {
	OpenAI    *OpenAIClient
	Anthropic *AnthropicClient
}

type ProtocolStreamConfig struct {
	Primary               ChatProtocol
	FallbackOnError       func(error) bool
	ReasoningOnlyFallback bool // retry alternate protocol when primary stream is reasoning-only
}

type Provider interface {
	// Chat sends a non-streaming chat request.
	Chat(ctx context.Context, messages []EyrieMessage, opts ChatOptions) (*EyrieResponse, error)
	// StreamChat sends a streaming chat request.
	// The caller must call Close() on the returned StreamResult when done.
	StreamChat(ctx context.Context, messages []EyrieMessage, opts ChatOptions) (*StreamResult, error)
	// Ping checks connectivity and authentication.
	Ping(ctx context.Context) error
	// Name returns the provider name (e.g. "anthropic", "openai").
	Name() string
}

type ProviderCallback interface {
	// OnRequest is called before each Chat or StreamChat request.
	// The messages and opts parameters must not be modified.
	OnRequest(ctx context.Context, provider string, model string, messages []EyrieMessage, opts ChatOptions)

	// OnResponse is called after a successful Chat request.
	OnResponse(ctx context.Context, provider string, model string, response *EyrieResponse, duration time.Duration)

	// OnError is called after a Chat or StreamChat request fails.
	OnError(ctx context.Context, provider string, model string, err error, duration time.Duration)

	// OnStreamEvent is called for each event emitted during streaming.
	OnStreamEvent(ctx context.Context, provider string, model string, event EyrieStreamEvent)
}

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

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

type ProviderRegistryConfig struct {
	Name              string              `json:"name"`
	Type              ProviderType        `json:"type"`
	BaseURL           string              `json:"base_url,omitempty"`
	EnvKey            string              `json:"env_key"`
	SupportsStreaming bool                `json:"supports_streaming"`
	SupportsTools     bool                `json:"supports_tools"`
	SupportsReasoning bool                `json:"supports_reasoning"`
	Compat            *OpenAICompatConfig `json:"compat,omitempty"`
}

type ProviderScore struct {
	Name         string  `json:"name"`
	Score        float64 `json:"score"` // 0-1 (1 = perfect health)
	AvgLatencyMs int64   `json:"avg_latency_ms"`
	ErrorRate    float64 `json:"error_rate"`
	IsHealthy    bool    `json:"is_healthy"`
}

type ProviderType string

type RateLimitConfig struct {
	// RequestsPerMinute is the maximum requests per minute (0 = unlimited).
	RequestsPerMinute int
	// BurstSize is the maximum burst above the steady rate (default = RequestsPerMinute/10, min 1).
	BurstSize int
	// MinInterval is the minimum time between requests (e.g., 5ms for cloud, 0 for local).
	MinInterval time.Duration
}

type RateLimitHeaders struct {
	RequestsRemaining int
	RequestsLimit     int
	TokensRemaining   int
	TokensLimit       int
	ResetTime         time.Time
}

type RateLimitState struct {
	// RPM tracking
	RPMUsed    int       // requests used in the current window
	RPMLimit   int       // maximum requests per minute (0 = unknown)
	RPMResetAt time.Time // when the RPM window resets

	// TPM tracking
	TPMUsed    int       // tokens used in the current window
	TPMLimit   int       // maximum tokens per minute (0 = unknown)
	TPMResetAt time.Time // when the TPM window resets

	// Header-derived remaining counts (from x-ratelimit-remaining)
	RPMRemaining int // -1 if unknown
	TPMRemaining int // -1 if unknown

	// Last updated timestamp
	LastUpdated time.Time

	// Total requests and tokens tracked (lifetime)
	TotalRequests int64
	TotalTokens   int64

	// Number of times the provider was delayed due to near-limit
	ThrottleCount int64
}

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

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

type RecordedRequest struct {
	Messages []EyrieMessage `json:"messages"`
	Model    string         `json:"model"`
	System   string         `json:"system,omitempty"`
	Hash     string         `json:"hash"`
}

type RecordedResponse struct {
	Content      string      `json:"content,omitempty"`
	ToolCalls    []ToolCall  `json:"tool_calls,omitempty"`
	Usage        *EyrieUsage `json:"usage,omitempty"`
	FinishReason string      `json:"finish_reason,omitempty"`
	Error        string      `json:"error,omitempty"`
}

type RecorderMode string

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

type Relationship struct {
	// Subject is the entity the relation originates from. A noun/noun phrase.
	Subject string `json:"subject"`
	// Predicate is the typed relation (e.g. "depends_on", "authored_by").
	Predicate string `json:"predicate"`
	// Object is the entity the relation points to. A noun/noun phrase.
	Object string `json:"object"`
}

type RepeatDetector struct {

	// MinLength is the minimum accumulated rune count before detection fires.
	// Default 100.
	MinLength int
	// Threshold is the repeatness score below which the stream is aborted.
	// Default 0.5.
	Threshold float64
	// contains filtered or unexported fields
}

type RequestLogEntry struct {
	Timestamp    time.Time `json:"timestamp"`
	Provider     string    `json:"provider"`
	Model        string    `json:"model"`
	InputTokens  int       `json:"input_tokens"`
	OutputTokens int       `json:"output_tokens"`
	LatencyMs    int64     `json:"latency_ms"`
	Status       string    `json:"status"` // "success" or "error"
	Error        string    `json:"error,omitempty"`
	CacheHit     bool      `json:"cache_hit"`
}

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

type ResponseFormat struct {
	Type   string `json:"type"`             // "json_object" or "json_schema"
	Schema string `json:"schema,omitempty"` // optional JSON schema for structured output
}

type ResponseHealth string

type ResponseSignals struct {
	SawReasoning bool // any thinking/reasoning tokens were produced
	ContentLen   int  // length of usable assistant content
	ToolCalls    int  // number of tool calls produced
	FinishReason string
	StreamErr    bool // a stream-level error event was seen
	StreamEnded  bool // a terminal done/finish event was observed
}

type RetryConfig struct {
	types.RetryConfig
	RetryOn []int // HTTP status codes to retry on
}

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

type SSEEvent struct {
	Event string
	Data  string
}

type SchemaValidation struct {
	// Schema is the JSON schema to validate against.
	Schema map[string]interface{}
	// MaxRetries is the maximum number of retry attempts if validation fails.
	MaxRetries int
	// StrictMode enables strict schema validation requiring all fields.
	StrictMode bool
}

type SemanticCacheConfig struct {
	// MaxAge is how long cache entries remain valid. Default: 5 minutes.
	MaxAge time.Duration
	// MaxSize is the maximum number of cached responses. Default: 100.
	// When exceeded, the least-recently-used entry is evicted.
	MaxSize int
	// Enabled toggles caching. Default: true.
	Enabled bool
	// TemperatureThreshold is the temperature above which responses are not
	// cached. Default: 0.5.
	TemperatureThreshold float64
	// SimilarityThreshold is the minimum cosine similarity (0..1) for a cached
	// entry to be considered a hit. Default: 0.95.
	SimilarityThreshold float64
	// EmbeddingModel is the model passed to the Embedder. Required.
	EmbeddingModel string
}

type SemanticCacheStats struct {
	Size    int  `json:"size"`
	MaxSize int  `json:"max_size"`
	Hits    int  `json:"hits"`
	Misses  int  `json:"misses"`
	Enabled bool `json:"enabled"`
}

type StreamGuardrailConfig struct {
	// Enabled turns streaming guardrails on or off.
	Enabled bool `json:"enabled"`
	// MaxChunkSize is the maximum allowed size of a single chunk (in bytes).
	// Chunks exceeding this limit are split. A value of 0 disables splitting.
	MaxChunkSize int `json:"max_chunk_size,omitempty"`
	// AccumulateForPII buffers chunks before running PII detection, since
	// patterns like SSNs or credit-card numbers may span chunk boundaries.
	AccumulateForPII bool `json:"accumulate_for_pii"`
	// BlockOnInjection causes an immediate block when a prompt-injection
	// pattern is detected in any chunk, without waiting for accumulation.
	BlockOnInjection bool `json:"block_on_injection"`
}

type StreamGuardrailResult struct {
	// Chunk is the original chunk text.
	Chunk string `json:"chunk"`
	// Blocked indicates that the chunk (or accumulated content) was blocked
	// by a guardrail with Action=Block.
	Blocked bool `json:"blocked"`
	// Violations lists any rules matched during this chunk's processing.
	Violations []GuardrailViolation `json:"violations,omitempty"`
	// ModifiedChunk is the chunk after redactions have been applied.
	// When no redactions are needed, it equals Chunk.
	ModifiedChunk string `json:"modified_chunk"`
}

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

type StreamMerger struct {
	StreamFields []string
	IndexFields  []string
	// contains filtered or unexported fields
}

type StreamResult struct {
	Events    <-chan EyrieStreamEvent
	RequestID string
	// contains filtered or unexported fields
}

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

type StructuredOutputError struct {
	// Response is the raw response that failed validation.
	Response string
	// ValidationErr is the underlying validation error.
	ValidationErr error
	// Attempt is the attempt number that failed.
	Attempt int
}