autoroute

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

type AutoRoutingResult struct {
	// ResolvedModel is the model chosen by the auto-router (e.g., "geminicli:gemini-3.1-pro")
	ResolvedModel string

	// Providers is the ordered list of providers to try (winner first, then fallbacks)
	Providers []string

	// Intent is the classified or hinted intent (e.g., "coding")
	Intent string

	// Complexity is the estimated prompt complexity (0.0-1.0)
	Complexity float64

	// Decision is the full routing rationale, retained for Lab telemetry
	Decision *RoutingDecision

	// WasAutoRouted indicates this request was handled by auto-routing
	WasAutoRouted bool
}

type CandidateInput struct {
	Model       string        // Full model ID (e.g., "geminicli:gemini-3.1-pro")
	Provider    string        // Provider name (e.g., "geminicli")
	Available   bool          // Is the provider reachable and has active credentials?
	QuotaHealth float64       // 0.0 (exhausted) to 1.0 (full), based on active/cooled credentials
	Latency     time.Duration // Average observed latency (0 = unknown)
	SuccessRate float64       // 0.0 to 1.0 historical success rate (-1 = unknown/cold start)
}

type Config struct {
	Enabled       bool                          `yaml:"enabled" json:"enabled"`
	MaxResolution time.Duration                 `yaml:"max-resolution-ms" json:"max_resolution_ms"`
	Providers     map[string]ProviderTierConfig `yaml:"providers" json:"providers"`
	Preferences   []ModelPreference             `yaml:"preferences" json:"preferences"`
	Conservation  ConservationConfig            `yaml:"conservation" json:"conservation"`
	Discovery     DiscoveryConfig               `yaml:"discovery" json:"discovery"`
	Weights       ScoringWeights                `yaml:"weights" json:"weights"`
	IntentMatrix  map[string][]string           `yaml:"intent-matrix" json:"intent_matrix"`
	Lab           LabConfig                     `yaml:"lab" json:"lab"`
	// DisabledProviders lists provider names that should never be selected, even if
	// they score highest. Use when credits are exhausted or a provider is known-bad.
	// Example: [anthropic] skips all Anthropic models until the list is cleared.
	DisabledProviders []string `yaml:"disabled-providers" json:"disabled_providers"`
}

type ConservationConfig struct {
	Enabled               bool    `yaml:"enabled" json:"enabled"`
	SimpleThreshold       int     `yaml:"simple-threshold-tokens" json:"simple_threshold_tokens"`
	PremiumConservationAt float64 `yaml:"premium-conservation-at" json:"premium_conservation_at"` // percentage (0.0 to 1.0)
}

type DiscoveredModel struct {
	ID      string
	Context int
}

type DiscoveryConfig struct {
	Enabled           bool          `yaml:"enabled" json:"enabled"`
	ProbeOnStartup    bool          `yaml:"probe-on-startup" json:"probe_on_startup"`
	ProbeInterval     time.Duration `yaml:"probe-interval" json:"probe_interval"`
	ProbeTimeout      time.Duration `yaml:"probe-timeout" json:"probe_timeout"`
	PassiveMonitoring bool          `yaml:"passive-monitoring" json:"passive_monitoring"`
	CacheTTL          time.Duration `yaml:"cache-ttl" json:"cache_ttl"`
}

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

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

type FallbackEntry struct {
	Provider string `json:"provider"`
	Model    string `json:"model"`
	Tier     string `json:"tier"`
}

type IntentClassification struct {
	Intent     string  // The detected intent category
	Confidence float64 // 0.0 - 1.0
	Method     string  // "hint", "heuristic", or "cortex"
}

type JournalEntry struct {
	Timestamp  time.Time
	RequestID  string
	Intent     string
	Complexity float64
	// Production Decision
	ProdModel   string
	ProdTier    string
	ProdLatency time.Duration
	ProdSuccess bool
	ProdRQS     float64
	// Shadow Decision (if diff from Prod)
	ShadowModel       string
	ShadowTier        string
	ShadowExpectedRQS float64 // Predicted RQS based on heuristic/history
	// Active Weights
	WeightAvail   float64
	WeightQuota   float64
	WeightLatency float64
	WeightSuccess float64
}

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

type LabConfig struct {
	Enabled              bool          `yaml:"enabled" json:"enabled"`
	AdaptationInterval   time.Duration `yaml:"adaptation-interval" json:"adaptation_interval"`
	MaxWeightDrift       float64       `yaml:"max-weight-drift" json:"max_weight_drift"`
	MinObservationWindow int           `yaml:"min-observation-window" json:"min_observation_window"` // min requests before evaluating (default 10)
}

type LabStatus struct {
	Enabled             bool           `json:"enabled"`
	ActiveWeights       ScoringWeights `json:"active_weights"`
	ShadowWeights       ScoringWeights `json:"shadow_weights"`
	ActiveHypothesis    bool           `json:"active_hypothesis"`
	WindowReqCount      int            `json:"window_req_count"`
	WindowExploredCount int            `json:"window_explored_count"`
	AvgProdRQS          float64        `json:"avg_prod_rqs"`
	AvgShadowRQS        float64        `json:"avg_shadow_rqs"`
}

type ModelPreference struct {
	Model      string  `yaml:"model" json:"model"`
	Preference float64 `yaml:"preference" json:"preference"` // 0.0 to 1.0 multiplier boost
	Reason     string  `yaml:"reason,omitempty" json:"reason,omitempty"`
}

type ProbeResult struct {
	Provider         string
	Available        bool
	AuthType         string
	SubscriptionInfo *SubscriptionInfo
	Models           []DiscoveredModel
	RateLimits       *RateLimits
	Latency          time.Duration
	ProbeError       error
	ProbedAt         time.Time
}

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

type ProviderHealthState struct {
	LastProbe       time.Time
	Status          string        // "healthy", "degraded", "unavailable"
	Latency         time.Duration // Exponential moving average
	SuccessRate     float64       // Sliding window approximation
	QuotaRemaining  float64       // 0.0 - 1.0
	ConsecutiveFail int
	CoolingDown     bool
	CooldownUntil   time.Time
	// CooldownAttempts counts how many times this provider has tripped the
	// circuit. Used to compute exponential backoff for the next cooldown.
	// Resets to 0 after a successful request that follows a cooldown.
	CooldownAttempts int
}

type ProviderProber interface {
	// Name returns the provider name (e.g., "geminicli")
	Name() string
	// Probe executes the health/discovery check
	Probe(ctx context.Context) ProbeResult
}

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

type ProviderTierConfig struct {
	Tier          string            `yaml:"tier" json:"tier"`
	MonthlyBudget float64           `yaml:"monthly-budget,omitempty" json:"monthly_budget,omitempty"`
	ModelTiers    map[string]string `yaml:"model-tiers,omitempty" json:"model_tiers,omitempty"`
}

type RQSWeightConfig struct {
	Success      float64
	Latency      float64
	Efficiency   float64
	Conservation float64
}

type RateLimitHeaderConfig struct {
	RequestLimit     string
	RequestRemaining string
	RequestReset     string
	TokenLimit       string
	TokenRemaining   string
	TokenReset       string
	RetryAfter       string
}

type RateLimitSnapshot struct {
	Provider string

	// Request-level limits
	RequestLimit     int
	RequestRemaining int
	RequestReset     time.Time

	// Token-level limits
	TokenLimit     int
	TokenRemaining int
	TokenReset     time.Time

	// Retry-After (seconds or absolute time)
	RetryAfterSec int

	// Derived health metric (0.0 = exhausted, 1.0 = full)
	QuotaHealth float64

	// Whether any rate-limit headers were detected at all
	Detected bool
}

type RateLimits struct {
	RequestsPerMinute int
	TokensPerMinute   int
}

type RequestOutcome struct {
	Timestamp           time.Time
	Model               string
	Provider            string
	Tier                string
	Latency             time.Duration
	Success             bool
	StatusCode          int
	EstimatedComplexity float64
	TokensUsed          int // If available
}

type RoutingDecision struct {
	// SelectedModel is the primary model chosen for the request
	SelectedModel string `json:"selected_model"`

	// FallbackChain is an ordered list of models to try if the primary fails
	FallbackChain []FallbackEntry `json:"fallback_chain"`

	// Intent hints or classifications (e.g., "coding", "creative")
	Intent string `json:"intent"`

	// EstimatedComplexity of the prompt (0.0 to 1.0)
	EstimatedComplexity float64 `json:"estimated_complexity"`

	// Candidates evaluated (useful for debugging/dashboard)
	Candidates []ScoredCandidate `json:"candidates,omitempty"`

	// OriginalInputs preserves the raw CandidateInput values at decision time,
	// enabling the Lab to replay exact conditions for shadow scoring (H1 fix).
	OriginalInputs []CandidateInput `json:"-"`

	// ResolutionLatency tracks how long the scoring process took
	ResolutionLatency time.Duration `json:"resolution_latency_ms"`
}

type RoutingRequest struct {
	// Content is the user's message text (used for complexity estimation)
	Content string

	// IntentHint is an explicit intent from the model name (e.g., "auto:coding" → "coding")
	IntentHint string

	// AvailableModels is the list of candidate model IDs currently registered
	AvailableModels []CandidateInput
}

type ScoredCandidate struct {
	// Model is the canonical internal model identifier (e.g., "geminicli:gemini-3.1-pro")
	Model string `json:"model"`

	// Provider is the extracted provider name (e.g., "geminicli")
	Provider string `json:"provider"`

	// Score Breakdown
	FinalScore       float64 `json:"final_score"`
	BaseScore        float64 `json:"base_score"`
	TierBoost        float64 `json:"tier_boost"`
	PreferenceBoost  float64 `json:"preference_boost"`
	ConservationMult float64 `json:"conservation_multiplier"`

	// EffectiveTier is the final assigned tier (e.g., "premium", "free") after resolving overrides
	EffectiveTier string `json:"effective_tier"`

	// Available tracks if the health monitor considers this candidate routable
	Available bool `json:"available"`

	// EstimatedLatency via health monitor EMAs
	EstimatedLatency time.Duration `json:"estimated_latency_ms"`
}

type ScoringWeights struct {
	Availability float64 `yaml:"availability" json:"availability"`
	Quota        float64 `yaml:"quota" json:"quota"`
	Latency      float64 `yaml:"latency" json:"latency"`
	SuccessRate  float64 `yaml:"success-rate" json:"success_rate"`
}

type SubscriptionInfo struct {
	Tier           string // "free", "standard", "premium", "unknown"
	QuotaTotal     int64  // -1 = unlimited
	QuotaRemaining int64
	ResetTime      time.Time
	Source         string // "api-header", "cli-command", "inferred", "config-override"
}