typ

type AdvisorConfig struct {
	// ProviderUUID references a configured provider by UUID.
	ProviderUUID string `json:"provider_uuid,omitempty" yaml:"provider_uuid,omitempty"`
	Model        string `json:"model,omitempty" yaml:"model,omitempty"`

	// ProviderResolver is a function that resolves a provider by UUID at call time.
	// It is not persisted to JSON/YAML and must be set by the server before use.
	ProviderResolver func(string) (*Provider, error) `json:"-" yaml:"-"`

	MaxUsesPerRequest int `json:"max_uses_per_request,omitempty" yaml:"max_uses_per_request,omitempty"`
	// The max token output by adviser. Too much explodes worker's context. 4k is enough for pure suggestions.
	MaxTokens int `json:"max_tokens,omitempty" yaml:"max_tokens,omitempty"`
	// TimeoutSeconds overrides the default 60s per-call timeout. Set higher for slow/large models.
	TimeoutSeconds int `json:"timeout_seconds,omitempty" yaml:"timeout_seconds,omitempty"`
}

type AuthType = ai.AuthType

type CapacityBasedParams struct{}

type CapacityBasedTactic struct{}

type ClaudeCodeProfileConfig struct {
	Env         map[string]string `json:"env,omitempty" yaml:"env,omitempty"`
	UnsetEnv    []string          `json:"unset_env,omitempty" yaml:"unset_env,omitempty"`
	DefaultMode string            `json:"default_mode,omitempty" yaml:"default_mode,omitempty"`
}

type ClientKey struct {
	ProviderUUID string    `json:"provider_uuid"`
	Model        string    `json:"model"`
	SessionID    SessionID `json:"session_id,omitempty"`
}

type CredentialBundle = ai.CredentialBundle

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

type FlagCategory string

type FlagOption struct {
	Value string `json:"value"`
	Label string `json:"label"`
}

type FlagSpec struct {
	Key         string        `json:"key"`
	Label       string        `json:"label"`
	Description string        `json:"description"`
	Type        FlagValueType `json:"type"`
	Category    FlagCategory  `json:"category"`
	// Placeholder is the hint text shown in string-type input fields.
	Placeholder string `json:"placeholder,omitempty"`
	// Options enumerates the selectable values for FlagTypeEnum flags.
	// The first option is treated as the default when the stored value is empty.
	Options []FlagOption `json:"options,omitempty"`
	// Suggestions offers a non-exhaustive list of recommended values for a
	// FlagTypeString flag. Unlike Options (enum) these are not the only legal
	// values — the UI surfaces them as a quick-pick / autocomplete while still
	// allowing free-form input. Used by custom_user_agent to expose the common
	// CLI/agent User-Agent strings (see DefaultUserAgents).
	Suggestions []FlagOption `json:"suggestions,omitempty"`
	// Shared indicates this flag also exists at the scenario level
	// (ScenarioFlags) and participates in scenario→rule inheritance.
	Shared bool `json:"shared,omitempty"`
	// InheritanceMode describes how the scenario-level and rule-level values
	// combine when both are set:
	//   - "or":       bool OR — either level enabling it activates the flag
	//   - "override": rule non-zero/non-empty wins, else scenario default
	// Empty means the flag is rule-only (not shared).
	InheritanceMode string `json:"inheritance_mode,omitempty"`
}

type FlagValueType string

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 LoadBalancingTactic interface {
	SelectService(rule *Rule) *loadbalance.Service
	GetName() string
	GetType() loadbalance.TacticType
}

type MCPAuthType string

type MCPClient struct {
	ID     string          `json:"id"`
	Config MCPSourceConfig `json:"config"`
	Tools  []MCPTool       `json:"tools"`
	State  MCPClientState  `json:"state"`
}

type MCPClientState string

type MCPConnectionType string

type MCPMode string

type MCPOAuthConfig struct {
	ClientID     string   `json:"client_id"`
	ClientSecret string   `json:"client_secret,omitempty"`
	AuthorizeURL string   `json:"authorize_url"`
	TokenURL     string   `json:"token_url"`
	Scopes       []string `json:"scopes,omitempty"`
}

type MCPRuntimeConfig struct {
	Mode                  MCPMode           `json:"mode,omitempty"` // deprecated: kept only for backward compatibility
	Sources               []MCPSourceConfig `json:"sources,omitempty"`
	RequestTimeout        int               `json:"request_timeout,omitempty"`          // seconds, default: 30
	StripDisabledMCPTools bool              `json:"strip_disabled_mcp_tools,omitempty"` // dangerous: strip disabled MCP declarations/tool_calls
}

type MCPSourceConfig struct {
	ID         string            `json:"id,omitempty"`         // unique source id for normalized tool names
	Name       string            `json:"name,omitempty"`       // client name (unique, no spaces/hyphens)
	Enabled    *bool             `json:"enabled,omitempty"`    // nil means enabled (backward-compatible default)
	Transport  string            `json:"transport,omitempty"`  // "http", "stdio", or "sse"
	Endpoint   string            `json:"endpoint,omitempty"`   // endpoint URL for HTTP/SSE transport
	Headers    map[string]string `json:"headers,omitempty"`    // static headers for MCP calls
	Tools      []string          `json:"tools,omitempty"`      // allow list, empty means all
	Command    string            `json:"command,omitempty"`    // command for stdio transport
	Args       []string          `json:"args,omitempty"`       // args for stdio command
	Cwd        string            `json:"cwd,omitempty"`        // working directory for stdio command
	Env        map[string]string `json:"env,omitempty"`        // extra env vars for stdio command
	ProxyURL   string            `json:"proxy_url,omitempty"`  // HTTP proxy URL for outgoing requests
	Visibility ToolVisibility    `json:"visibility,omitempty"` // "client" or "server"

	// Local mode specific fields
	ConnectionType      MCPConnectionType `json:"connection_type,omitempty"`       // stdio/http/sse
	AuthType            MCPAuthType       `json:"auth_type,omitempty"`             // headers/oauth
	AllowedExtraHeaders []string          `json:"allowed_extra_headers,omitempty"` // allowed request headers to forward
	StdioConfig         *MCPStdioConfig   `json:"stdio_config,omitempty"`
	OAuthConfig         *MCPOAuthConfig   `json:"oauth_config,omitempty"`
	ToolsToExecute      []string          `json:"tools_to_execute,omitempty"`      // available tools
	ToolsAutoExec       []string          `json:"tools_to_auto_execute,omitempty"` // auto-execute tools (agent mode)
	IsPingAvailable     *bool             `json:"is_ping_available,omitempty"`     // health check method
	AutoRegistered      bool              `json:"auto_registered,omitempty"`       // true if auto-registered on first connect
	Advisor             *AdvisorConfig    `json:"advisor,omitempty" yaml:"advisor,omitempty"`
}

type MCPStdioConfig struct {
	Command string   `json:"command"`        // execution command
	Args    []string `json:"args,omitempty"` // command arguments
	Env     []string `json:"env,omitempty"`  // inherited environment variables
	Cwd     string   `json:"cwd,omitempty"`  // working directory
}

type MCPTool struct {
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
}

type OAuthDetail = ai.OAuthDetail

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)
	Unified    bool                     `json:"unified" yaml:"unified"`                             // true=unified mode (single model), false=separate mode (individual models, default)
	ClaudeCode *ClaudeCodeProfileConfig `json:"claude_code,omitempty" yaml:"claude_code,omitempty"` // Persistent overrides for generated Claude Code settings.
}

type Provider = ai.Provider

type ProviderSource = ai.ProviderSource

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"`
	// 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"`
	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"`

	// SkipUsage strips the `usage` field from both streaming and non-streaming responses.
	SkipUsage bool `json:"skip_usage,omitempty" yaml:"skip_usage,omitempty"`

	// CustomUserAgent overrides the User-Agent header sent to upstream providers.
	// Empty value means do not override.
	CustomUserAgent string `json:"custom_user_agent,omitempty" yaml:"custom_user_agent,omitempty"`

	// UseMaxCompletionTokens rewrites the `max_tokens` request field to `max_completion_tokens`
	// (OpenAI's newer field name for o1/o3/gpt-5 family models).
	UseMaxCompletionTokens bool `json:"use_max_completion_tokens,omitempty" yaml:"use_max_completion_tokens,omitempty"`

	// UseMaxTokens rewrites the `max_completion_tokens` request field back to the legacy
	// `max_tokens` field. Use this for providers or models that reject `max_completion_tokens`.
	UseMaxTokens bool `json:"use_max_tokens,omitempty" yaml:"use_max_tokens,omitempty"`

	// OpenAIEndpointOverride forces the OpenAI endpoint selection (chat or
	// responses), overriding the capability-aware adaptive router. Empty or
	// "auto" preserves adaptive behavior. OpenAI providers only; Anthropic
	// and Google providers ignore this. On Codex OAuth providers, "chat"
	// is silently ignored (Codex has no Chat endpoint) and a warning is logged.
	OpenAIEndpointOverride string `json:"openai_endpoint_override,omitempty" yaml:"openai_endpoint_override,omitempty"`

	// BlockTools is a comma-separated list of tool names to strip from the
	// inbound request's tool list before it is forwarded upstream. Matching is
	// exact on the tool name as the client sent it. Empty means no blocking.
	BlockTools string `json:"block_tools,omitempty" yaml:"block_tools,omitempty"`

	// ThinkingEffort is the unified extended-thinking control. Recognized
	// values: "" (by client, default), "off" (force disabled), or one of
	// "low"/"medium"/"high"/"max" (force enabled with the matching budget).
	// Maps to budget_tokens for Anthropic and reasoning_effort for OpenAI
	// ("max" collapses to "high" for OpenAI which has no "max").
	ThinkingEffort ThinkingEffortLevel `json:"thinking_effort,omitempty" yaml:"thinking_effort,omitempty"`

	// CleanHeader strips x-anthropic-billing-header blocks from system messages.
	// Auto-enabled for billing scenarios (claude_code, claude_desktop) during protocol
	// transformation. Can be manually set to force enable/disable.
	CleanHeader bool `json:"clean_header,omitempty" yaml:"clean_header,omitempty"`

	// ClaudeCodeCompat rewrites any "system" role in the messages array to "user"
	// before forwarding. Claude Code sends system-role entries inside the messages
	// list (a non-standard extension); this flag normalizes them for third-party
	// providers that reject that role. Auto-applied when the scenario's
	// ClaudeCodeCompat flag is set.
	ClaudeCodeCompat bool `json:"claude_code_compat,omitempty" yaml:"claude_code_compat,omitempty"`

	// SessionAffinity pins a client session to the service it first landed on.
	// The value is the TTL in seconds (0 = disabled). Subsequent requests in
	// the same session keep hitting that service until the affinity entry
	// expires. This is a load-balancing concern and works independently of
	// smart routing.
	//
	// Rule-only: there is no scenario-level inheritance. The built-in Claude
	// Code / Claude Desktop / Codex rules default this to 1800s (30 min) via
	// init seeds + migration; any other rule is off unless explicitly set.
	SessionAffinity int `json:"session_affinity,omitempty" yaml:"session_affinity,omitempty"`

	// VisionProxyService enables the rule-scoped vision proxy when set. When a
	// request matched by this rule carries an image, the configured service
	// describes it and the image block is replaced with text before the
	// request reaches the downstream model. Same effect as the scenario-level
	// vision proxy (ScenarioConfig.Extensions["vision_proxy_service"]), only
	// narrower in scope; when both are set the rule-level service wins.
	VisionProxyService *VisionProxyService `json:"vision_proxy_service,omitempty" yaml:"vision_proxy_service,omitempty"`

	// Context1M enables Anthropic's 1M token context window for supported models
	// (Sonnet 4.6+, Opus 4.6+). When enabled, the gateway injects the
	// context-1m-2025-08-07 beta flag into the upstream request's
	// anthropic-beta header. The model name sent to Anthropic is unchanged —
	// only the beta header changes behavior.
	Context1M bool `json:"context_1m,omitempty" yaml:"context_1m,omitempty"`

	// ClaudeOrgID controls the anthropic-organization-id header sent upstream
	// for Claude OAuth providers. Organization attribution is opt-in: empty
	// (default) sends no organization header at all. "auto"
	// (typ.ClaudeOrgIDAuto) sends the organization captured at OAuth login
	// (OAuthDetail.ExtraFields["organization_id"]), which org-bound
	// entitlements (e.g. Cyber Verification) rely on. Any other value sends
	// that organization id verbatim.
	ClaudeOrgID string `json:"claude_org_id,omitempty" yaml:"claude_org_id,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"`
	// SupportsProfiles indicates whether this scenario supports named profiles.
	SupportsProfiles bool `json:"supports_profiles" yaml:"supports_profiles"`
}

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

	// Experimental feature flags (scenario-based opt-in)
	SmartCompact bool          `json:"smart_compact,omitempty" yaml:"smart_compact,omitempty"` // Enable smart compact (remove thinking blocks)
	RecordingV2  RecordingMode `json:"recording_v2,omitempty" yaml:"recording_v2,omitempty"`   // Enable scenario recording V2 (request/request_response/staged_request_response)
	// SkipUsage strips usage fields from streaming chunks and responses.
	// Use for clients that cannot handle usage data (e.g. Xcode). Equivalent
	// to the rule-level skip_usage flag but applied as a scenario-wide default.
	SkipUsage bool `json:"skip_usage,omitempty" yaml:"skip_usage,omitempty"`

	// ThinkingEffort is the unified extended-thinking control. Recognized
	// values: "" (by client, default), "off" (force disabled), or one of
	// "low"/"medium"/"high"/"max" (force enabled with the matching budget).
	ThinkingEffort ThinkingEffortLevel `json:"thinking_effort,omitempty" yaml:"thinking_effort,omitempty"`

	// CustomUserAgent overrides the outbound User-Agent header for every rule
	// under this scenario. Acts as a scenario-wide default; individual rules can
	// override it via RuleFlags.CustomUserAgent (rule value wins when non-empty).
	// Empty value means do not override. Same effect and injection path as the
	// rule-level flag — see internal/client/custom_ua_transport.go.
	CustomUserAgent string `json:"custom_user_agent,omitempty" yaml:"custom_user_agent,omitempty"`

	// ClaudeCodeCompat rewrites any "system" role in the messages array to "user"
	// before forwarding. Claude Code sends system-role entries inside the messages
	// list (a non-standard extension); this flag normalizes them so third-party
	// providers that reject that role do not error out.
	ClaudeCodeCompat bool `json:"claude_code_compat,omitempty" yaml:"claude_code_compat,omitempty"`
}

type ScenarioTransport string

type SessionID struct {
	Source   SessionSource `json:"source"`
	Value    string        `json:"value"`
	IPBackup string        `json:"ip_backup,omitempty"` // Always store client IP when available
}

type SessionSource 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 TierParams struct {
	WithinTierTactic loadbalance.TacticType `json:"within_tier_tactic"`
}

type TierTactic struct {
	WithinTierTactic loadbalance.TacticType
}

type ToolDescriptor struct {
	Name           string             `json:"name"`
	SourceID       string             `json:"source_id"`
	Visibility     ToolVisibility     `json:"visibility"`
	Implementation ToolImplementation `json:"implementation"`
	Provider       ToolProvider       `json:"provider"`
	Description    string             `json:"description,omitempty"`
}

type ToolImplementation string

type ToolProvider string

type ToolVisibility = coretool.ToolVisibility

type TransportKey struct {
	ProviderUUID string    `json:"provider_uuid"`
	SessionID    SessionID `json:"session_id,omitempty"` // Included for per-session OAuth providers
}

type VModelDetail = ai.VModelDetail

type VisionProxyService struct {
	Provider string `json:"provider" yaml:"provider"`
	Model    string `json:"model" yaml:"model"`
}