typ

type AdaptiveParams struct {
	LatencyWeight float64 `json:"latency_weight"`  // Weight for latency (0-1)
	TokenWeight   float64 `json:"token_weight"`    // Weight for token usage (0-1)
	SpeedWeight   float64 `json:"speed_weight"`    // Weight for token speed (0-1)
	HealthWeight  float64 `json:"health_weight"`   // Weight for health status (0-1)
	MaxLatencyMs  int64   `json:"max_latency_ms"`  // Maximum acceptable latency
	MaxTokenUsage int64   `json:"max_token_usage"` // Maximum acceptable token usage
	MinSpeedTps   float64 `json:"min_speed_tps"`   // Minimum acceptable tokens per second
	ScoringMode   string  `json:"scoring_mode"`    // "weighted_sum", "multiplicative", "rank_based"
}

type AdaptiveTactic struct {
	LatencyWeight float64 // Weight for latency (0-1)
	TokenWeight   float64 // Weight for token usage (0-1)
	SpeedWeight   float64 // Weight for token speed (0-1)
	HealthWeight  float64 // Weight for health status (0-1)
	MaxLatencyMs  int64   // Maximum acceptable latency for normalization
	MaxTokenUsage int64   // Maximum acceptable token usage for normalization
	MinSpeedTps   float64 // Minimum acceptable tokens per second for normalization
	ScoringMode   string  // "weighted_sum", "multiplicative", "rank_based"
}

type AuthType string

type DiscoveryResult struct {
	TotalIdesScanned int             `json:"total_ides_scanned"`
	IdesFound        []IDESource     `json:"ides_found"`
	SkillsFound      int             `json:"skills_found"`
	Locations        []SkillLocation `json:"locations"`
}

type FlexibleBool bool

type GroupingStrategy struct {
	// Mode: "flat" (no grouping), "auto" (automatic based on file count), "pattern" (by pattern)
	Mode string `json:"mode"`
	// GroupPattern: pattern for grouping when mode="pattern", e.g., "skills" groups by skills directory
	// The pattern is searched in the file path, and everything up to (and including) the match becomes the group key
	GroupPattern string `json:"group_pattern,omitempty"`
	// MinFilesForSplit: minimum files before splitting a group (only for auto mode)
	MinFilesForSplit int `json:"min_files_for_split,omitempty"`
}

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

type IDEAdapter struct {
	Key               IDESource `json:"key"`
	DisplayName       string    `json:"display_name"`
	RelativeDetectDir string    `json:"relative_detect_dir"`
	Icon              string    `json:"icon"`
	SupportsSymlink   bool      `json:"supports_symlink"`
	// ScanPatterns defines glob patterns for finding skill files (e.g., ["*.md", "skill/*.md"])
	// Patterns are relative to the detected IDE base directory (relative_detect_dir).
	// If empty, defaults to ["**/*.md"]
	ScanPatterns []string `json:"scan_patterns,omitempty"`
	// GroupingStrategy defines how skills should be grouped in the UI
	GroupingStrategy *GroupingStrategy `json:"grouping_strategy,omitempty"`
}

type IDESource string

type LatencyBasedParams struct {
	LatencyThresholdMs int64   `json:"latency_threshold_ms"` // Switch if latency exceeds this (ms)
	SampleWindowSize   int     `json:"sample_window_size"`   // Number of samples to keep
	Percentile         float64 `json:"percentile"`           // Which percentile to use (0.5 = p50, 0.95 = p95, 0.99 = p99)
	ComparisonMode     string  `json:"comparison_mode"`      // "avg", "p50", "p95", "p99"
}

type LatencyBasedTactic struct {
	LatencyThresholdMs int64   // Switch if latency exceeds this (ms)
	SampleWindowSize   int     // Number of samples to keep
	Percentile         float64 // Which percentile to use
	ComparisonMode     string  // "avg", "p50", "p95", "p99"
}

type LoadBalancingTactic interface {
	SelectService(rule *Rule) *loadbalance.Service
	GetName() string
	GetType() loadbalance.TacticType
}

type OAuthDetail struct {
	AccessToken  string                 `json:"access_token"`  // OAuth access token
	ProviderType string                 `json:"provider_type"` // anthropic, google, etc. for token manager lookup
	UserID       string                 `json:"user_id"`       // OAuth user identifier
	RefreshToken string                 `json:"refresh_token"` // Token for refreshing access token
	ExpiresAt    string                 `json:"expires_at"`    // Token expiration time (RFC3339)
	ExtraFields  map[string]interface{} `json:"extra_fields"`  // Any extra field for some special clients
}

type ProfileMeta struct {
	ID   string `json:"id" yaml:"id"`     // Profile ID (e.g. "p1")
	Name string `json:"name" yaml:"name"` // Human-readable name (unique within base scenario)
}

type Provider struct {
	UUID          string            `json:"uuid"`
	Name          string            `json:"name"`
	APIBase       string            `json:"api_base"`
	APIStyle      protocol.APIStyle `json:"api_style"` // "openai" or "anthropic", defaults to "openai"
	Token         string            `json:"token"`     // API key for api_key auth type
	NoKeyRequired bool              `json:"no_key_required"`
	Enabled       bool              `json:"enabled"`
	ProxyURL      string            `json:"proxy_url"`              // HTTP or SOCKS proxy URL (e.g., "http://127.0.0.1:7890" or "socks5://127.0.0.1:1080")
	Timeout       int64             `json:"timeout,omitempty"`      // Request timeout in seconds (default: 1800 = 30 minutes)
	Tags          []string          `json:"tags,omitempty"`         // Provider tags for categorization
	Models        []string          `json:"models,omitempty"`       // Available models for this provider (cached)
	LastUpdated   string            `json:"last_updated,omitempty"` // Last update timestamp

	// Auth configuration
	AuthType    AuthType     `json:"auth_type"`              // api_key or oauth
	OAuthDetail *OAuthDetail `json:"oauth_detail,omitempty"` // OAuth credentials (only for oauth auth type)
}

type RandomParams struct{}

type RandomTactic struct{}

type RecordingMode string

type Rule struct {
	UUID          string                 `json:"uuid"`
	Scenario      RuleScenario           `json:"scenario,required" yaml:"scenario"` // openai, anthropic, claude_code; defaults to openai
	RequestModel  string                 `json:"request_model" yaml:"request_model"`
	ResponseModel string                 `json:"response_model" yaml:"response_model"`
	Description   string                 `json:"description"`
	Services      []*loadbalance.Service `json:"services" yaml:"services"`
	// Per-rule feature flags (e.g. cursor_compat / cursor_compat_auto).
	Flags RuleFlags `json:"flags,omitempty" yaml:"flags,omitempty"`
	// CurrentServiceID is persisted to SQLite, not JSON (provider:model format)
	// This identifies the current service for round-robin load balancing
	CurrentServiceID string `json:"-" yaml:"-"`
	// Unified Tactic Configuration
	LBTactic Tactic `json:"lb_tactic" yaml:"lb_tactic"`
	Active   bool   `json:"active" yaml:"active"`
	// Smart Routing Configuration
	SmartEnabled  bool                        `json:"smart_enabled" yaml:"smart_enabled"`
	SmartAffinity bool                        `json:"smart_affinity,omitempty" yaml:"smart_affinity,omitempty"`
	SmartRouting  []smartrouting.SmartRouting `json:"smart_routing,omitempty" yaml:"smart_routing,omitempty"`
}

type RuleFlags struct {
	// CursorCompat enables Cursor compatibility handling (rich content normalization, stream usage stripping, tool gating).
	CursorCompat bool `json:"cursor_compat,omitempty" yaml:"cursor_compat,omitempty"`

	// CursorCompatAuto enables Cursor auto-detection based on request headers.
	CursorCompatAuto bool `json:"cursor_compat_auto,omitempty" yaml:"cursor_compat_auto,omitempty"`
}

type RuleScenario string

type ScanResult struct {
	LocationID string  `json:"location_id"`
	Skills     []Skill `json:"skills"`
	Error      string  `json:"error,omitempty"`
}

type ScenarioConfig struct {
	Scenario   RuleScenario           `json:"scenario" yaml:"scenario"`
	Flags      ScenarioFlags          `json:"flags" yaml:"flags"`                               // Scenario configuration flags
	Extensions map[string]interface{} `json:"extensions,omitempty" yaml:"extensions,omitempty"` // Reserved for future extensions
}

type ScenarioDescriptor struct {
	// ID is the stable scenario identifier stored on rules and scenario configs.
	ID RuleScenario `json:"id" yaml:"id"`
	// SupportedTransport declares which protocol surfaces may resolve rules bound to this scenario.
	SupportedTransport []ScenarioTransport `json:"supported_transport" yaml:"supported_transport"`
	// AllowRuleBinding controls whether API/CLI callers may create or update rules under this scenario.
	AllowRuleBinding bool `json:"allow_rule_binding" yaml:"allow_rule_binding"`
	// AllowDirectPathUse controls whether scenario-scoped HTTP paths like /openai/{scenario}/... are valid.
	AllowDirectPathUse bool `json:"allow_direct_path_use" yaml:"allow_direct_path_use"`
}

type ScenarioFlags struct {
	Unified  bool `json:"unified" yaml:"unified"`   // Single configuration for all models
	Separate bool `json:"separate" yaml:"separate"` // Separate configuration for each model
	Smart    bool `json:"smart" yaml:"smart"`       // Smart mode with automatic optimization

	// Experimental feature flags (scenario-based opt-in)
	SmartCompact bool          `json:"smart_compact,omitempty" yaml:"smart_compact,omitempty"`   // Enable smart compact (remove thinking blocks)
	Recording    bool          `json:"recording,omitempty" yaml:"recording,omitempty"`           // Enable scenario recording (legacy boolean flag)
	RecordV2     RecordingMode `json:"record_v2,omitempty" yaml:"record_v2,omitempty"`           // Enable scenario recording V2 (request/response/request_response)
	Beta         bool          `json:"anthropic_beta,omitempty" yaml:"anthropic_beta,omitempty"` // Enable Anthropic beta features (e.g. extended thinking)

	// Stream configuration flags
	DisableStreamUsage bool `json:"disable_stream_usage,omitempty" yaml:"disable_stream_usage,omitempty"` // Don't include usage in streaming chunks (for incompatible clients like xcode)

	// Thinking effort level (empty string = use model default)
	ThinkingEffort ThinkingEffortLevel `json:"thinking_effort,omitempty" yaml:"thinking_effort,omitempty"`

	// Thinking mode for claude_code scenario (default/adaptive/force)
	// Using string directly instead of ThinkingMode type to avoid naming conflicts
	ThinkingMode string `json:"thinking_mode,omitempty" yaml:"thinking_mode,omitempty"`

	CleanHeader bool `json:"clean_header,omitempty" yaml:"clean_header,omitempty"` // Remove billing header from system messages (Claude Code only)
}

type ScenarioTransport string

type Skill struct {
	ID          string    `json:"id"`
	Name        string    `json:"name"`
	Filename    string    `json:"filename"`
	Path        string    `json:"path"`
	LocationID  string    `json:"location_id"`
	FileType    string    `json:"file_type"`
	Description string    `json:"description,omitempty"`
	ContentHash string    `json:"content_hash,omitempty"`
	Size        int64     `json:"size,omitempty"`
	ModifiedAt  time.Time `json:"modified_at,omitempty"`
	Content     string    `json:"content,omitempty"`
}

type SkillLocation struct {
	ID               string    `json:"id"`
	Name             string    `json:"name"`
	Path             string    `json:"path"`
	IDESource        IDESource `json:"ide_source"`
	SkillCount       int       `json:"skill_count"`
	Icon             string    `json:"icon,omitempty"`
	IsAutoDiscovered bool      `json:"is_auto_discovered,omitempty"`
	IsInstalled      bool      `json:"is_installed,omitempty"`
	LastScannedAt    time.Time `json:"last_scanned_at,omitempty"`
	// GroupingStrategy: optional override for this specific location
	GroupingStrategy *GroupingStrategy `json:"grouping_strategy,omitempty"`
}

type SpeedBasedParams struct {
	MinSamplesRequired int     `json:"min_samples_required"` // Minimum samples before making decisions
	SpeedThresholdTps  float64 `json:"speed_threshold_tps"`  // Minimum acceptable tokens per second
	SampleWindowSize   int     `json:"sample_window_size"`   // Number of speed samples to keep
}

type SpeedBasedTactic struct {
	MinSamplesRequired int     // Minimum samples before making decisions
	SpeedThresholdTps  float64 // Minimum acceptable tokens per second
	SampleWindowSize   int     // Number of speed samples to keep
}

type Tactic struct {
	Type   loadbalance.TacticType `json:"type" yaml:"type"`
	Params TacticParams           `json:"params" yaml:"params"`
}

type TacticParams interface {
	// contains filtered or unexported methods
}

type ThinkingEffortLevel = string

type ThinkingMode string

type TokenBasedParams struct {
	TokenThreshold int64 `json:"token_threshold"` // Threshold for token consumption before switching
}

type TokenBasedTactic struct {
	TokenThreshold int64 // Threshold for token consumption before switching
}

type ToolInterceptorConfig struct {
	PreferLocalSearch FlexibleBool `json:"prefer_local_search,omitempty"` // Prefer local tool interception even if provider has built-in search
	SearchAPI         string       `json:"search_api,omitempty"`          // "brave" or "google"
	SearchKey         string       `json:"search_key,omitempty"`          // API key for search service
	MaxResults        int          `json:"max_results,omitempty"`         // Max search results to return (default: 10)

	// Proxy configuration
	ProxyURL string `json:"proxy_url,omitempty"` // HTTP proxy URL (e.g., "http://127.0.0.1:7897")

	// Fetch configuration
	MaxFetchSize int64 `json:"max_fetch_size,omitempty"` // Max content size for fetch in bytes (default: 1MB)
	FetchTimeout int64 `json:"fetch_timeout,omitempty"`  // Fetch timeout in seconds (default: 30)
	MaxURLLength int   `json:"max_url_length,omitempty"` // Max URL length (default: 2000)
}

type ToolInterceptorOverride struct {
	// Disabled allows provider to explicitly disable when globally enabled
	Disabled bool `json:"disabled,omitempty"`

	// MaxResults override for this specific provider
	MaxResults *int `json:"max_results,omitempty"`
}