llm

type AnthropicAPIAccess string

type Config struct {
	IsSubAgent           bool               `mapstructure:"is_sub_agent" json:"is_sub_agent" yaml:"is_sub_agent"` // IsSubAgent is true if the LLM is a sub-agent
	Provider             string             `mapstructure:"provider" json:"provider" yaml:"provider"`             // Provider is the LLM provider (anthropic, openai)
	Model                string             `mapstructure:"model" json:"model" yaml:"model"`                      // Model is the main driver
	WeakModel            string             `mapstructure:"weak_model" json:"weak_model" yaml:"weak_model"`       // WeakModel is the less capable but faster model to use
	MaxTokens            int                `mapstructure:"max_tokens" json:"max_tokens" yaml:"max_tokens"`
	WeakModelMaxTokens   int                `mapstructure:"weak_model_max_tokens" json:"weak_model_max_tokens" yaml:"weak_model_max_tokens"`    // WeakModelMaxTokens is the maximum tokens for the weak model
	ThinkingBudgetTokens int                `mapstructure:"thinking_budget_tokens" json:"thinking_budget_tokens" yaml:"thinking_budget_tokens"` // ThinkingBudgetTokens is the budget for the thinking capability
	ReasoningEffort      string             `mapstructure:"reasoning_effort" json:"reasoning_effort" yaml:"reasoning_effort"`                   // ReasoningEffort is used for OpenAI models (none, minimal, low, medium, high, xhigh)
	AllowedCommands      []string           `mapstructure:"allowed_commands" json:"allowed_commands" yaml:"allowed_commands"`                   // AllowedCommands is a list of allowed command patterns for the bash tool
	AllowedDomainsFile   string             `mapstructure:"allowed_domains_file" json:"allowed_domains_file" yaml:"allowed_domains_file"`       // AllowedDomainsFile is the path to the file containing allowed domains for web_fetch tool
	AllowedTools         []string           `mapstructure:"allowed_tools" json:"allowed_tools" yaml:"allowed_tools"`                            // AllowedTools is a list of allowed tools for the main agent (empty means use defaults)
	WorkingDirectory     string             `mapstructure:"working_directory" json:"working_directory" yaml:"working_directory"`
	ToolMode             ToolMode           `mapstructure:"tool_mode" json:"tool_mode" yaml:"tool_mode"`                                    // ToolMode controls file-interaction behavior (e.g. full or patch)
	AnthropicAPIAccess   AnthropicAPIAccess `mapstructure:"anthropic_api_access" json:"anthropic_api_access" yaml:"anthropic_api_access"`   // AnthropicAPIAccess controls how to authenticate with Anthropic API
	AnthropicAccount     string             `mapstructure:"anthropic_account" json:"anthropic_account" yaml:"anthropic_account"`            // AnthropicAccount specifies which Anthropic subscription account to use
	UseCopilot           bool               `mapstructure:"use_copilot" json:"use_copilot" yaml:"use_copilot"`                              // UseCopilot enables GitHub Copilot subscription for OpenAI requests
	Aliases              map[string]string  `mapstructure:"aliases" json:"aliases,omitempty" yaml:"aliases,omitempty"`                      // Aliases maps short model names to full model names
	Retry                RetryConfig        `mapstructure:"retry" json:"retry" yaml:"retry"`                                                // Retry configuration for API calls
	MCPExecutionMode     string             `mapstructure:"mcp_execution_mode" json:"mcp_execution_mode" yaml:"mcp_execution_mode"`         // MCP execution mode (code, direct, or empty)
	MCPWorkspaceDir      string             `mapstructure:"mcp_workspace_dir" json:"mcp_workspace_dir" yaml:"mcp_workspace_dir"`            // MCP workspace directory for code execution mode
	Sysprompt            string             `mapstructure:"sysprompt" json:"sysprompt,omitempty" yaml:"sysprompt,omitempty"`                // Sysprompt is the path to a custom system prompt template file
	SyspromptArgs        map[string]string  `mapstructure:"sysprompt_args" json:"sysprompt_args,omitempty" yaml:"sysprompt_args,omitempty"` // SyspromptArgs are custom template arguments for system prompt rendering

	// Profile system configuration
	Profile  string                   `mapstructure:"profile" json:"profile,omitempty" yaml:"profile,omitempty"`    // Active profile name
	Profiles map[string]ProfileConfig `mapstructure:"profiles" json:"profiles,omitempty" yaml:"profiles,omitempty"` // Named configuration profiles

	// Provider-specific configurations
	OpenAI *OpenAIConfig `mapstructure:"openai" json:"openai,omitempty" yaml:"openai,omitempty"` // OpenAI-specific configuration including compatible providers
	Google *GoogleConfig `mapstructure:"google" json:"google,omitempty" yaml:"google,omitempty"` // Google GenAI-specific configuration

	// SubagentArgs is CLI arguments to pass when spawning subagents via shell-out
	// Example: "--profile cheap" or "--use-weak-model"
	SubagentArgs string `mapstructure:"subagent_args" json:"subagent_args,omitempty" yaml:"subagent_args,omitempty"`

	// Skills configuration
	Skills *SkillsConfig `mapstructure:"skills" json:"skills,omitempty" yaml:"skills,omitempty"` // Skills configuration for agentic skills system

	// Context configuration
	Context *ContextConfig `mapstructure:"context" json:"context,omitempty" yaml:"context,omitempty"` // Context configuration for context file discovery

	// Hooks and feature toggle configuration
	NoHooks              bool   `mapstructure:"no_hooks" json:"no_hooks" yaml:"no_hooks"`                                              // NoHooks disables agent lifecycle hooks
	DisableFSSearchTools bool   `mapstructure:"disable_fs_search_tools" json:"disable_fs_search_tools" yaml:"disable_fs_search_tools"` // DisableFSSearchTools disables glob_tool and grep_tool and updates prompt/tool guidance accordingly
	DisableSubagent      bool   `mapstructure:"disable_subagent" json:"disable_subagent" yaml:"disable_subagent"`                      // DisableSubagent disables the subagent tool and removes subagent-related system prompt context
	EnableTodos          bool   `mapstructure:"enable_todos" json:"enable_todos" yaml:"enable_todos"`                                  // EnableTodos enables todo_read and todo_write tools for the main agent
	RecipeName           string `mapstructure:"recipe_name" json:"recipe_name" yaml:"recipe_name"`                                     // RecipeName is the active recipe/fragment name for hooks
}

type ConsoleMessageHandler struct {
	Silent bool
}

type ContextConfig struct {
	// Patterns is a list of filenames to search for in each directory.
	// Default is ["AGENTS.md"]. Files are searched in order; first match wins per directory.
	Patterns []string `mapstructure:"patterns" json:"patterns" yaml:"patterns"`
}

type CustomModels struct {
	Reasoning    []string `mapstructure:"reasoning" json:"reasoning" yaml:"reasoning"`             // Models that support reasoning (o1, o3, etc.)
	NonReasoning []string `mapstructure:"non_reasoning" json:"non_reasoning" yaml:"non_reasoning"` // Models that don't support reasoning (gpt-4, etc.)
}

type CustomPricing map[string]ModelPricing

type DeltaEntry struct {
	Kind           string `json:"kind"`
	Delta          string `json:"delta,omitempty"`
	Content        string `json:"content,omitempty"`
	ConversationID string `json:"conversation_id"`
	Role           string `json:"role"`
}

type GoogleConfig struct {
	Backend        string `mapstructure:"backend" json:"backend" yaml:"backend"`                         // Backend to use: "gemini" or "vertexai" (auto-detected if not specified)
	APIKey         string `mapstructure:"api_key" json:"api_key" yaml:"api_key"`                         // API key for Gemini API
	Project        string `mapstructure:"project" json:"project" yaml:"project"`                         // Google Cloud project ID for Vertex AI
	Location       string `mapstructure:"location" json:"location" yaml:"location"`                      // Google Cloud region for Vertex AI (e.g., "us-central1")
	ThinkingBudget int32  `mapstructure:"thinking_budget" json:"thinking_budget" yaml:"thinking_budget"` // Token budget for thinking capability
}

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

type HookConfig struct {
	Handler string // Built-in handler name (e.g., "swap_context")
	Once    bool   // If true, only execute on the first turn
}

type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type MessageEvent struct {
	Type    string
	Content string
	Done    bool
}

type MessageHandler interface {
	HandleText(text string)
	HandleToolUse(toolCallID string, toolName string, input string)
	HandleToolResult(toolCallID string, toolName string, result tooltypes.ToolResult)
	HandleThinking(thinking string)
	HandleDone()
}

type MessageOpt struct {
	// PromptCache indicates if prompt caching should be used
	PromptCache bool
	// UseWeakModel allows temporarily overriding the model for this message
	UseWeakModel bool
	// NoToolUse indicates that no tool use should be performed
	NoToolUse bool
	// NoSaveConversation indicates that the following conversation should not be saved
	NoSaveConversation bool
	// Images contains image paths or URLs to include with the message
	Images []string
	// MaxTurns limits the number of turns within a single SendMessage call
	// A value of 0 means no limit, and negative values are treated as 0
	MaxTurns int
	// CompactRatio is the ratio of context window at which to trigger auto-compact (0.0-1.0)
	CompactRatio float64
	// DisableAutoCompact disables auto-compact functionality
	DisableAutoCompact bool
	// DisableUsageLog disables LLM usage logging for this message
	DisableUsageLog bool
}

type ModelPricing struct {
	Input         float64 `mapstructure:"input" json:"input" yaml:"input"`                            // Input token cost per token
	CachedInput   float64 `mapstructure:"cached_input" json:"cached_input" yaml:"cached_input"`       // Cached input token cost per token
	Output        float64 `mapstructure:"output" json:"output" yaml:"output"`                         // Output token cost per token
	ContextWindow int     `mapstructure:"context_window" json:"context_window" yaml:"context_window"` // Maximum context window size
}

type OpenAIAPIMode string

type OpenAIConfig struct {
	Platform     string                  `mapstructure:"platform" json:"platform" yaml:"platform"`                                    // Canonical platform name for OpenAI-compatible APIs (e.g., openai, xai, codex)
	BaseURL      string                  `mapstructure:"base_url" json:"base_url" yaml:"base_url"`                                    // Custom API base URL (overrides platform defaults)
	APIKeyEnvVar string                  `mapstructure:"api_key_env_var" json:"api_key_env_var" yaml:"api_key_env_var"`               // Environment variable name for API key (overrides platform default)
	APIMode      OpenAIAPIMode           `mapstructure:"api_mode" json:"api_mode" yaml:"api_mode"`                                    // Preferred API mode selection (chat_completions or responses)
	EnableSearch *bool                   `mapstructure:"enable_search" json:"enable_search,omitempty" yaml:"enable_search,omitempty"` // Enable native OpenAI Responses web_search tool when supported (defaults to true)
	ManualCache  bool                    `mapstructure:"manual_cache" json:"manual_cache" yaml:"manual_cache"`                        // Enables manual cache affinity headers for Chat Completions when prompt caching is requested
	Models       *CustomModels           `mapstructure:"models" json:"models,omitempty" yaml:"models,omitempty"`                      // Custom model configuration
	Pricing      map[string]ModelPricing `mapstructure:"pricing" json:"pricing,omitempty" yaml:"pricing,omitempty"`                   // Custom pricing configuration
}

type ProfileConfig map[string]any

type RetryConfig struct {
	Attempts     int    `mapstructure:"attempts" json:"attempts" yaml:"attempts"`                // Maximum number of retry attempts (default: 3)
	InitialDelay int    `mapstructure:"initial_delay" json:"initial_delay" yaml:"initial_delay"` // Initial delay in milliseconds (default: 1000) - OpenAI only
	MaxDelay     int    `mapstructure:"max_delay" json:"max_delay" yaml:"max_delay"`             // Maximum delay in milliseconds (default: 10000) - OpenAI only
	BackoffType  string `mapstructure:"backoff_type" json:"backoff_type" yaml:"backoff_type"`    // Backoff strategy: "fixed", "exponential" (default: "exponential") - OpenAI only
}

type SkillsConfig struct {
	// Enabled controls whether skills are active. When the SkillsConfig is nil
	// (not specified in config), skills default to enabled. Set to false to disable.
	Enabled bool `mapstructure:"enabled" json:"enabled" yaml:"enabled"`
	// Allowed is an allowlist of skill names. When empty, all discovered skills are available.
	// When specified, only the listed skills will be enabled.
	Allowed []string `mapstructure:"allowed" json:"allowed" yaml:"allowed"`
}

type StreamingMessageHandler interface {
	MessageHandler
	HandleTextDelta(delta string)     // Called for each text chunk as it streams
	HandleThinkingStart()             // Called when a thinking block starts
	HandleThinkingDelta(delta string) // Called for each thinking chunk as it streams
	HandleThinkingBlockEnd()          // Called when a thinking block ends (for visual separation)
	HandleContentBlockEnd()           // Called when any content block ends
}

type StringCollectorHandler struct {
	Silent bool
	// contains filtered or unexported fields
}

type Thread interface {
	// SetState sets the state for the thread
	SetState(s tooltypes.State)
	// GetState returns the current state of the thread
	GetState() tooltypes.State
	// AddUserMessage adds a user message with optional images to the thread
	AddUserMessage(ctx context.Context, message string, imagePaths ...string)
	// SendMessage sends a message to the LLM and processes the response
	SendMessage(ctx context.Context, message string, handler MessageHandler, opt MessageOpt) (finalOutput string, err error)
	// GetUsage returns the current token usage for the thread
	GetUsage() Usage
	// GetConversationID returns the current conversation ID
	GetConversationID() string
	// SetConversationID sets the conversation ID
	SetConversationID(id string)
	// SaveConversation saves the current thread to the conversation store
	SaveConversation(ctx context.Context, summarise bool) error
	// IsPersisted returns whether this thread is being persisted
	IsPersisted() bool
	// EnablePersistence enables conversation persistence for this thread
	EnablePersistence(ctx context.Context, enabled bool)
	// Provider returns the provider of the thread
	Provider() string
	// GetMessages returns the messages from the thread
	GetMessages() ([]Message, error)
	// GetConfig returns the configuration of the thread
	GetConfig() Config
	// AggregateSubagentUsage aggregates usage from a subagent into this thread's usage
	// This aggregates token counts and costs but NOT context window (which should remain isolated)
	AggregateSubagentUsage(usage Usage)
	// SetRecipeHooks sets the recipe hook configurations for the thread
	SetRecipeHooks(hooks map[string]HookConfig)
	// GetRecipeHooks returns the recipe hook configurations for the thread
	GetRecipeHooks() map[string]HookConfig
}

type ToolMode string

type Usage struct {
	InputTokens              int     `json:"inputTokens"`              // Regular input tokens count
	OutputTokens             int     `json:"outputTokens"`             // Output tokens generated
	CacheCreationInputTokens int     `json:"cacheCreationInputTokens"` // Tokens used for creating cache entries
	CacheReadInputTokens     int     `json:"cacheReadInputTokens"`     // Tokens used for reading from cache
	InputCost                float64 `json:"inputCost"`                // Cost for input tokens in USD
	OutputCost               float64 `json:"outputCost"`               // Cost for output tokens in USD
	CacheCreationCost        float64 `json:"cacheCreationCost"`        // Cost for cache creation in USD
	CacheReadCost            float64 `json:"cacheReadCost"`            // Cost for cache read in USD
	CurrentContextWindow     int     `json:"currentContextWindow"`     // Current context window size
	MaxContextWindow         int     `json:"maxContextWindow"`         // Max context window size
}