copilot

type APIConfig struct {
	// BaseURL is the API base URL (OpenAI-compatible endpoint).
	// Examples:
	//   https://api.openai.com/v1           (OpenAI)
	//   https://api.z.ai/api/anthropic      (GLM / Anthropic proxy)
	//   https://api.anthropic.com/v1        (Anthropic direct)
	BaseURL string `yaml:"base_url"`

	// APIKey is the authentication key for the provider.
	// Can also be set via the DEVCLAW_API_KEY environment variable.
	APIKey string `yaml:"api_key"`

	// Provider hints which SDK to use ("openai", "anthropic", "glm").
	// Auto-detected from base_url if omitted.
	Provider string `yaml:"provider"`

	// Params holds provider-specific parameters:
	//   context1m: true   — enable Anthropic 1M context beta for Opus/Sonnet
	//   tool_stream: true — enable real-time tool call streaming (Z.AI)
	Params map[string]any `yaml:"params"`
}

type AccessConfig struct {
	// DefaultPolicy determines behavior for unknown contacts.
	// "deny" (default) = ignore unknown, "allow" = respond to all, "ask" = request access.
	DefaultPolicy AccessPolicy `yaml:"default_policy"`

	// Owners have full control (phone numbers or JIDs).
	Owners []string `yaml:"owners"`

	// Admins can manage users and workspaces.
	Admins []string `yaml:"admins"`

	// AllowedUsers can interact with the bot.
	AllowedUsers []string `yaml:"allowed_users"`

	// BlockedUsers are explicitly blocked.
	BlockedUsers []string `yaml:"blocked_users"`

	// AllowedGroups are group IDs where the bot responds.
	AllowedGroups []string `yaml:"allowed_groups"`

	// BlockedGroups are group IDs where the bot stays silent.
	BlockedGroups []string `yaml:"blocked_groups"`

	// AllowGroupAdmins grants "user" access to group admins automatically.
	AllowGroupAdmins bool `yaml:"allow_group_admins"`

	// PendingMessage is the message sent to unknown contacts when policy is "ask".
	PendingMessage string `yaml:"pending_message"`
}

type AccessEntry struct {
	// JID is the contact identifier (phone@server or group@server).
	JID string

	// Level is the access level.
	Level AccessLevel

	// AddedBy is the JID of the admin/owner who granted access.
	AddedBy string

	// AddedAt is when access was granted.
	AddedAt time.Time

	// Note is an optional admin note about this contact.
	Note string
}

type AccessLevel string

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

type AccessPolicy string

type ActivationMode string

type ActivityType string

type AgentConfig struct {
	// RunTimeoutSeconds is the max seconds for the entire agent run (default: 600).
	// One timer for the whole run, not per-turn.
	RunTimeoutSeconds int `yaml:"run_timeout_seconds"`

	// LLMCallTimeoutSeconds is the safety-net timeout per individual LLM call
	// (default: 300). Only catches hung connections — not the primary timeout.
	LLMCallTimeoutSeconds int `yaml:"llm_call_timeout_seconds"`

	// MaxTurns is a soft safety limit on LLM round-trips (default: 0 = unlimited).
	// When > 0, the agent will request a summary after this many turns.
	MaxTurns int `yaml:"max_turns"`

	// MaxContinuations is how many auto-continue rounds are allowed when
	// MaxTurns is hit and the agent is still using tools.
	// Only relevant when MaxTurns > 0. Default: 2.
	MaxContinuations int `yaml:"max_continuations"`

	// ReflectionEnabled enables periodic budget awareness nudges (default: true).
	ReflectionEnabled bool `yaml:"reflection_enabled"`

	// MaxCompactionAttempts is how many times to retry after context overflow (default: 3).
	MaxCompactionAttempts int `yaml:"max_compaction_attempts"`

	// ToolLoop configures tool loop detection thresholds.
	ToolLoop ToolLoopConfig `yaml:"tool_loop"`
}

type AgentEvent struct {
	RunID     string    `json:"run_id"`
	SessionID string    `json:"session_id"`
	Seq       int64     `json:"seq"`
	Stream    string    `json:"stream"` // lifecycle, assistant, tool, error
	Type      string    `json:"type"`   // delta, tool_use, tool_result, done, error, run_start, etc.
	Timestamp time.Time `json:"timestamp"`
	Data      any       `json:"data"`
}

type AgentLevel string

type AgentProfileConfig struct {
	// ID is the unique identifier for this agent profile.
	ID string `yaml:"id"`

	// Model is the LLM model to use (e.g., "gpt-4o", "claude-sonnet-4").
	Model string `yaml:"model"`

	// Instructions override the base system prompt for this agent.
	Instructions string `yaml:"instructions"`

	// Skills are the skill names to enable for this agent.
	Skills []string `yaml:"skills"`

	// Channels route messages from these channels to this agent.
	Channels []string `yaml:"channels"`

	// Users route messages from these users to this agent.
	Users []string `yaml:"users"`

	// Groups route messages from these groups to this agent.
	Groups []string `yaml:"groups"`

	// MaxTurns is the max LLM turns for this agent (0 = unlimited).
	MaxTurns int `yaml:"max_turns"`

	// RunTimeoutSeconds is the max run time for this agent.
	RunTimeoutSeconds int `yaml:"run_timeout_seconds"`
}

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

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

type AgentStatus string

type AgentWorkingState struct {
	// AgentID is the agent this state belongs to.
	AgentID string `json:"agent_id" yaml:"agent_id"`

	// TeamID is the team the agent belongs to.
	TeamID string `json:"team_id" yaml:"team_id"`

	// CurrentTaskID is the task the agent is currently working on.
	CurrentTaskID string `json:"current_task_id,omitempty" yaml:"current_task_id,omitempty"`

	// Status is the work status (idle, working, blocked, waiting).
	Status string `json:"status" yaml:"status"`

	// NextSteps describes what the agent plans to do next (markdown).
	NextSteps string `json:"next_steps,omitempty" yaml:"next_steps,omitempty"`

	// Context holds additional context for resuming work.
	Context string `json:"context,omitempty" yaml:"context,omitempty"`

	// UpdatedAt is when the state was last updated.
	UpdatedAt time.Time `json:"updated_at" yaml:"updated_at"`
}

type AgentsConfig struct {
	// Profiles is the list of agent profiles.
	Profiles []AgentProfileConfig `yaml:"profiles"`

	// Routing defines how messages are routed.
	Routing RoutingConfig `yaml:"routing"`
}

type AnnounceCallback func(run *SubagentRun)

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

type ApprovalResult struct {
	Approved bool
	Reason   string
}

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

type AuditRecord struct {
	ID            int64
	Tool          string
	Caller        string
	Level         string
	Allowed       bool
	ArgsSummary   string
	ResultSummary string
	CreatedAt     string
}

type AuditRecordShort struct {
	ID          int64     `json:"id"`
	Tool        string    `json:"tool"`
	Caller      string    `json:"caller"`
	Level       string    `json:"level"`
	Allowed     bool      `json:"allowed"`
	ArgsSummary string    `json:"args_summary"`
	CreatedAt   time.Time `json:"created_at"`
}

type BlockStreamConfig struct {
	// Enabled turns block streaming on/off (default: true).
	Enabled bool `yaml:"enabled"`

	// MinChars is the minimum characters to accumulate before sending a block (default: 20).
	// Kept low for near-instant first-block feedback.
	MinChars int `yaml:"min_chars"`

	// MaxChars is the maximum characters per block before a forced flush (default: 600).
	MaxChars int `yaml:"max_chars"`

	// IdleMs is the idle timeout in milliseconds: if no new tokens arrive within
	// this window, flush whatever is buffered (default: 200).
	IdleMs int `yaml:"idle_ms"`
}

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

type BrowserConfig struct {
	// Enabled turns the browser tool on/off (default: true if Chrome is found).
	Enabled bool `yaml:"enabled"`

	// ChromePath is the path to the Chrome/Chromium binary.
	// Auto-detected if empty.
	ChromePath string `yaml:"chrome_path"`

	// Headless runs the browser without a visible window (default: true).
	Headless bool `yaml:"headless"`

	// TimeoutSeconds is the max time for a single browser operation (default: 30).
	TimeoutSeconds int `yaml:"timeout_seconds"`

	// MaxPages is the max number of simultaneous pages/tabs (default: 3).
	MaxPages int `yaml:"max_pages"`

	// ViewportWidth is the browser viewport width (default: 1280).
	ViewportWidth int `yaml:"viewport_width"`

	// ViewportHeight is the browser viewport height (default: 720).
	ViewportHeight int `yaml:"viewport_height"`
}

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

type BudgetConfig struct {
	// MonthlyLimitUSD is the maximum monthly spend (0 = unlimited).
	MonthlyLimitUSD float64 `yaml:"monthly_limit_usd"`

	// WarnAtPercent triggers a warning when this % of budget is reached (default: 80).
	WarnAtPercent int `yaml:"warn_at_percent"`

	// ActionAtLimit defines behavior when limit is reached: "warn", "block", "fallback_local".
	ActionAtLimit string `yaml:"action_at_limit"`
}

type Canvas struct {
	ID        string    `json:"id"`
	Title     string    `json:"title"`
	HTML      string    `json:"-"`
	Port      int       `json:"port"`
	URL       string    `json:"url"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
	// contains filtered or unexported fields
}

type CanvasConfig struct {
	// Enabled turns canvas hosting on/off (default: true).
	Enabled bool `yaml:"enabled"`

	// BasePort is the starting port for canvas servers (default: 9100).
	// Each canvas gets its own port: BasePort, BasePort+1, etc.
	BasePort int `yaml:"base_port"`

	// MaxCanvases is the max number of simultaneous canvas servers (default: 5).
	MaxCanvases int `yaml:"max_canvases"`

	// TTLMinutes is how long a canvas stays alive without updates (default: 30).
	TTLMinutes int `yaml:"ttl_minutes"`
}

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

type ChannelDiagnostic struct {
	Name       string `json:"name"`
	Connected  bool   `json:"connected"`
	TestResult string `json:"test_result"`
	LatencyMs  int64  `json:"latency_ms"`
}

type ChannelHealth struct {
	Connected     bool           `json:"connected"`
	LastMessageAt time.Time      `json:"last_message_at,omitempty"`
	ErrorCount    int            `json:"error_count"`
	LatencyMs     int64          `json:"latency_ms"`
	Details       map[string]any `json:"details,omitempty"`
}

type ChannelsConfig struct {
	// WhatsApp is the WhatsApp channel config (core).
	WhatsApp whatsapp.Config `yaml:"whatsapp"`

	// Telegram is the Telegram channel config (core).
	Telegram telegram.Config `yaml:"telegram"`

	// Discord is the Discord channel config (core).
	Discord discord.Config `yaml:"discord"`

	// Slack is the Slack channel config (core).
	Slack slack.Config `yaml:"slack"`
}

type CheckResult struct {
	// Allowed is true if the contact can interact.
	Allowed bool

	// Level is the resolved access level.
	Level AccessLevel

	// ShouldAsk is true if we should send a "request access" message.
	ShouldAsk bool

	// Reason explains why access was denied (for logging).
	Reason string
}

type CommandResult struct {
	// Response is the text to send back.
	Response string

	// Handled is true if the message was a valid command.
	Handled bool
}

type Config struct {
	// Name is the assistant name shown in responses.
	Name string `yaml:"name"`

	// Trigger is the keyword that activates the bot (e.g. "@devclaw").
	Trigger string `yaml:"trigger"`

	// Model is the LLM model to use (e.g. "glm-4.7-flash").
	Model string `yaml:"model"`

	// API configures the LLM provider endpoint.
	API APIConfig `yaml:"api"`

	// Instructions are the base system prompt instructions.
	Instructions string `yaml:"instructions"`

	// Timezone is the user's timezone (e.g. "America/Sao_Paulo").
	Timezone string `yaml:"timezone"`

	// Language is the preferred response language (e.g. "pt-BR").
	Language string `yaml:"language"`

	// Access configures who can use the bot (allowlist/blocklist).
	Access AccessConfig `yaml:"access"`

	// Workspaces configures isolated profiles/contexts.
	Workspaces WorkspaceConfig `yaml:"workspaces"`

	// Channels configures communication channels.
	Channels ChannelsConfig `yaml:"channels"`

	// Memory configures the memory system.
	Memory MemoryConfig `yaml:"memory"`

	// Security configures security guardrails.
	Security SecurityConfig `yaml:"security"`

	// TokenBudget configures per-layer token limits.
	TokenBudget TokenBudgetConfig `yaml:"token_budget"`

	// Plugins configures the plugin loader.
	Plugins plugins.Config `yaml:"plugins"`

	// Sandbox configures the script sandbox.
	Sandbox sandbox.Config `yaml:"sandbox"`

	// Skills configures which skills are enabled.
	Skills SkillsConfig `yaml:"skills"`

	// Scheduler configures the task scheduler.
	Scheduler SchedulerConfig `yaml:"scheduler"`

	// Heartbeat configures the proactive heartbeat system.
	Heartbeat HeartbeatConfig `yaml:"heartbeat"`

	// Subagents configures the subagent orchestration system.
	Subagents SubagentConfig `yaml:"subagents"`

	// Agent configures the agent loop parameters (turns, timeouts, auto-continue).
	Agent AgentConfig `yaml:"agent"`

	// Fallback configures model fallback with retry and backoff.
	Fallback FallbackConfig `yaml:"fallback"`

	// Budget configures monthly cost tracking and limits.
	Budget BudgetConfig `yaml:"budget"`

	// Team configures multi-user mode.
	Team TeamConfig `yaml:"team"`

	// Media configures vision and audio transcription.
	Media MediaConfig `yaml:"media"`

	// Logging configures log output.
	Logging LoggingConfig `yaml:"logging"`

	// Queue configures message debouncing for bursts.
	Queue QueueConfig `yaml:"queue"`

	// Database configures the central SQLite database (devclaw.db).
	Database DatabaseConfig `yaml:"database"`

	// Gateway configures the HTTP API gateway.
	Gateway GatewayConfig `yaml:"gateway"`

	// BlockStream configures progressive message delivery (stream text to channel
	// in chunks instead of waiting for the complete response).
	BlockStream BlockStreamConfig `yaml:"block_stream"`

	// WebSearch configures the web search tool provider.
	WebSearch WebSearchConfig `yaml:"web_search"`

	// TTS configures text-to-speech synthesis.
	TTS TTSConfig `yaml:"tts"`

	// WebUI configures the web dashboard.
	WebUI webui.Config `yaml:"webui"`

	// Group configures group chat behavior.
	Group GroupConfig `yaml:"group"`

	// Agents configures specialized agent profiles and routing.
	Agents AgentsConfig `yaml:"agents"`

	// Groups configures group-specific policies and activation modes.
	Groups GroupsPolicyConfig `yaml:"groups"`

	// Hooks configures lifecycle hooks and webhooks.
	Hooks HooksConfig `yaml:"hooks"`

	// MCP configures Model Context Protocol servers.
	MCP MCPConfig `yaml:"mcp"`

	// Routines configures background routines (metrics, memory indexer, etc).
	Routines RoutinesConfig `yaml:"routines"`

	// NativeMedia configures the native media handling system.
	NativeMedia NativeMediaConfig `yaml:"native_media"`
}

type ConfigHealth struct {
	Valid    bool     `json:"valid"`
	Path     string   `json:"path"`
	Errors   []string `json:"errors,omitempty"`
	Sections []string `json:"sections"`
}

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

type ConversationEntry struct {
	UserMessage       string
	AssistantResponse string
	Timestamp         time.Time
}

type CooldownConfig struct {
	BillingBackoffHours   float64 `yaml:"billing_backoff_hours"`   // Default: 5
	BillingMaxHours       float64 `yaml:"billing_max_hours"`       // Default: 24
	FailureWindowHours    float64 `yaml:"failure_window_hours"`    // Default: 24
	InitialBackoffMinutes float64 `yaml:"initial_backoff_minutes"` // Default: 1
	MaxBackoffMinutes     float64 `yaml:"max_backoff_minutes"`     // Default: 60
}

type Daemon struct {
	Label     string    `json:"label"`
	Command   string    `json:"command"`
	PID       int       `json:"pid"`
	Port      int       `json:"port,omitempty"`
	Status    string    `json:"status"` // running, stopped, failed
	StartedAt time.Time `json:"started_at"`
	ExitCode  int       `json:"exit_code,omitempty"`
	Error     string    `json:"error,omitempty"`
	// contains filtered or unexported fields
}

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

type DatabaseConfig struct {
	// Path is the database file path for SQLite (default: "./data/devclaw.db").
	// Kept for backward compatibility with existing configs.
	Path string `yaml:"path"`

	// Hub enables the new Database Hub system with multi-backend support.
	// When Hub.Backend is not set, falls back to Path for SQLite.
	Hub database.HubConfig `yaml:"hub"`
}

type DatabaseHealth struct {
	Connected bool           `json:"connected"`
	SizeMB    float64        `json:"size_mb"`
	Tables    map[string]int `json:"tables"`
	Error     string         `json:"error,omitempty"`
}

type DeliveryTarget struct {
	Channel string
	ChatID  string
}

type DiagnosticsResult struct {
	Database     DatabaseHealth      `json:"database"`
	Config       ConfigHealth        `json:"config"`
	Channels     []ChannelDiagnostic `json:"channels"`
	RecentErrors []AuditRecordShort  `json:"recent_errors,omitempty"`
	Memory       MemoryStats         `json:"memory"`
	Disk         DiskStats           `json:"disk"`
}

type DiskStats struct {
	TotalGB float64 `json:"total_gb"`
	FreeGB  float64 `json:"free_gb"`
	UsedPct float64 `json:"used_pct"`
}

type DocumentType string

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

type EventListener func(event AgentEvent)

type ExecAnalysisConfig struct {
	// Enabled turns the analysis on/off.
	Enabled bool `yaml:"enabled"`

	// Categories configures each risk category.
	Categories map[RiskLevel]RiskCategoryConfig `yaml:"categories"`

	// SafeBins lists binary paths that are always safe.
	SafeBins []string `yaml:"safe_bins"`

	// Trust configures per-role trust levels.
	Trust TrustConfig `yaml:"trust"`

	// SuspiciousPatterns are regex patterns for suspicious constructs.
	SuspiciousPatterns []string `yaml:"suspicious_patterns"`

	// DefaultAction is the action for commands that don't match any category.
	DefaultAction RiskAction `yaml:"default_action"`
}

type ExecAnalysisResult struct {
	// Risk is the determined risk level.
	Risk RiskLevel

	// Action is the action to take.
	Action RiskAction

	// Reason explains why this risk level was assigned.
	Reason string

	// MatchedPattern is the pattern that matched (if any).
	MatchedPattern string

	// IsSuspicious indicates if suspicious constructs were found.
	IsSuspicious bool

	// SuspiciousMatches lists the suspicious patterns found.
	SuspiciousMatches []string
}

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

type ExecQueueItem struct {
	ID          string    `json:"id"`
	Tool        string    `json:"tool"`
	Caller      string    `json:"caller"`
	SessionID   string    `json:"session_id"`
	Description string    `json:"description"`
	CreatedAt   time.Time `json:"created_at"`
}

type ExportedMessage struct {
	User      string    `json:"user"`
	Assistant string    `json:"assistant"`
	Timestamp time.Time `json:"timestamp"`
}

type FailoverReason string

type FallbackConfig struct {
	// Models is the ordered list of fallback models to try on failure.
	// Supports N providers: primary -> fallback1 -> fallback2 -> ... -> local.
	Models []string `yaml:"models"`

	// Chain defines provider-specific fallback with separate base_url/api_key.
	// Each entry is a complete provider config tried in order on failure.
	Chain []ProviderChainEntry `yaml:"chain"`

	// MaxRetries per model before moving to next (default: 2).
	MaxRetries int `yaml:"max_retries"`

	// InitialBackoffMs is the initial retry delay in ms (default: 1000).
	InitialBackoffMs int `yaml:"initial_backoff_ms"`

	// MaxBackoffMs caps the backoff (default: 30000).
	MaxBackoffMs int `yaml:"max_backoff_ms"`

	// RetryOnStatusCodes lists HTTP codes that trigger retry (default: [429, 500, 502, 503, 529]).
	RetryOnStatusCodes []int `yaml:"retry_on_status_codes"`
}

type FunctionCall struct {
	Name      string `json:"name"`
	Arguments string `json:"arguments"`
}

type FunctionDef struct {
	Name        string          `json:"name"`
	Description string          `json:"description"`
	Parameters  json.RawMessage `json:"parameters"`
}

type GatewayConfig struct {
	// Enabled turns the gateway on/off (default: false).
	Enabled bool `yaml:"enabled"`

	// Address is the listen address (default: ":8085").
	Address string `yaml:"address"`

	// AuthToken is the Bearer token for /api/* and /v1/* auth (empty = no auth).
	AuthToken string `yaml:"auth_token"`

	// CORSOrigins lists allowed origins for CORS (empty = no CORS).
	CORSOrigins []string `yaml:"cors_origins"`
}

type GroupConfig struct {
	// ActivationMode controls when the bot responds in groups:
	//   "always"  — responds to all messages (default)
	//   "mention" — only when mentioned by name/trigger
	//   "reply"   — only when replied to directly
	ActivationMode string `yaml:"activation_mode"`

	// IntroMessage is sent when the bot joins a new group.
	// Empty = no intro. Supports template variables: {{name}}, {{trigger}}.
	IntroMessage string `yaml:"intro_message"`

	// ContextInjection adds group-specific context to the system prompt.
	// Useful for per-group instructions, rules, or personas.
	ContextInjection map[string]string `yaml:"context_injection"`

	// MaxParticipants limits context tracking for group participants.
	// Names of the last N participants are included in the prompt for
	// natural multi-party conversation (default: 20).
	MaxParticipants int `yaml:"max_participants"`

	// QuietHours defines time ranges when the bot won't respond in groups
	// (e.g. "23:00-07:00"). Empty = always active.
	QuietHours string `yaml:"quiet_hours"`

	// IgnorePatterns are regex patterns for messages the bot should ignore
	// even when activated (e.g. forwarded messages, bot commands for other bots).
	IgnorePatterns []string `yaml:"ignore_patterns"`
}

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

type GroupPolicy string

type GroupPolicyConfig struct {
	// ID is the group JID.
	ID string `yaml:"id"`
	// Name is a human-readable name for the group.
	Name string `yaml:"name"`
	// Policy is the access policy for this group.
	Policy GroupPolicy `yaml:"policy"`
	// Activation is the activation mode.
	Activation ActivationMode `yaml:"activation"`
	// Keywords trigger the bot in keyword mode.
	Keywords []string `yaml:"keywords"`
	// Workspace is the workspace to use for this group.
	Workspace string `yaml:"workspace"`
	// QuietHours defines when the bot should be silent.
	QuietHours *QuietHoursConfig `yaml:"quiet_hours"`
	// MaxParticipants ignores messages in groups larger than this (0 = unlimited).
	MaxParticipants int `yaml:"max_participants"`
	// AllowedUsers is the list of allowed user JIDs for allowlist policy.
	AllowedUsers []string `yaml:"allowed_users"`
}

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

type GroupsPolicyConfig struct {
	// DefaultPolicy is the policy for groups not explicitly configured.
	DefaultPolicy GroupPolicy `yaml:"default_policy"`
	// Groups is the list of group-specific configurations.
	Groups []GroupPolicyConfig `yaml:"groups"`
	// Blocked is the list of blocked group JIDs.
	Blocked []string `yaml:"blocked"`
}

type HandlerConfig struct {
	// Event is the hook event to listen to.
	Event string `yaml:"event"`

	// Action is the action to take (notify_admins, send_message).
	Action string `yaml:"action"`

	// Template is a Go template for the action output.
	Template string `yaml:"template"`

	// Enabled controls whether this handler is active.
	Enabled bool `yaml:"enabled"`
}

type HealthCheckResult struct {
	Component string `json:"component"`
	Status    string `json:"status"` // "PASS", "FAIL", "WARN"
	Message   string `json:"message"`
	LatencyMs int64  `json:"latency_ms,omitempty"`
}

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

type HeartbeatConfig struct {
	// Enabled turns the heartbeat on/off.
	Enabled bool `yaml:"enabled"`

	// Interval is the time between heartbeat ticks.
	// Default: 30 minutes.
	Interval time.Duration `yaml:"interval"`

	// ActiveStart is the earliest hour the heartbeat runs (e.g., 9 for 9 AM).
	ActiveStart int `yaml:"active_start"`

	// ActiveEnd is the latest hour the heartbeat runs (e.g., 22 for 10 PM).
	ActiveEnd int `yaml:"active_end"`

	// Channel is the default channel to send proactive messages to.
	Channel string `yaml:"channel"`

	// ChatID is the default chat to send proactive messages to.
	ChatID string `yaml:"chat_id"`

	// WorkspaceDir is the workspace directory where HEARTBEAT.md is located.
	WorkspaceDir string `yaml:"workspace_dir"`
}

type HookAction struct {
	// Block prevents the operation from proceeding (PreToolUse, UserPromptSubmit).
	Block bool

	// Reason explains why the operation was blocked.
	Reason string

	// ModifiedArgs replaces ToolArgs if non-nil (PreToolUse only).
	ModifiedArgs map[string]any

	// ModifiedMessage replaces the user message if non-empty (UserPromptSubmit).
	ModifiedMessage string
}

type HookEvent string

type HookHandler func(ctx context.Context, payload HookPayload) HookAction

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

type HookPayload struct {
	// Event is the hook event type.
	Event HookEvent

	// SessionID is the session this event relates to (if applicable).
	SessionID string

	// Channel is the originating channel (if applicable).
	Channel string

	// ToolName is the tool being called (PreToolUse/PostToolUse).
	ToolName string

	// ToolArgs are the tool arguments (PreToolUse only).
	ToolArgs map[string]any

	// ToolResult is the tool output (PostToolUse only).
	ToolResult string

	// Message is a human-readable description or the user message content.
	Message string

	// Error is set for HookError events.
	Error error

	// Extra holds arbitrary key-value data for extensibility.
	Extra map[string]any
}

type HookSummary struct {
	Name        string      `json:"name"`
	Description string      `json:"description"`
	Source      string      `json:"source"`
	Events      []HookEvent `json:"events"`
	Priority    int         `json:"priority"`
	Enabled     bool        `json:"enabled"`
}

type HooksConfig struct {
	// Enabled turns the hooks system on/off.
	Enabled bool `yaml:"enabled"`

	// Webhooks is the list of external webhook configurations.
	Webhooks []WebhookConfig `yaml:"webhooks"`

	// Handlers is the list of internal hook handlers.
	Handlers []HandlerConfig `yaml:"handlers"`
}

type IDEConfig struct {
	MCPPort   int    `yaml:"mcp_port" json:"mcp_port"`
	MCPHost   string `yaml:"mcp_host" json:"mcp_host"`
	Transport string `yaml:"transport" json:"transport"` // stdio, sse
}

type IndexConfig struct {
	// Auto enables automatic re-indexing on file changes (default: true).
	Auto bool `yaml:"auto"`

	// ChunkMaxTokens is the max tokens per chunk (default: 500).
	ChunkMaxTokens int `yaml:"chunk_max_tokens"`
}

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

type LLMErrorKind int

type LLMResponse struct {
	Content      string
	ToolCalls    []ToolCall
	FinishReason string
	Usage        LLMUsage
	ModelUsed    string // The model that actually produced the response
}

type LLMUsage struct {
	PromptTokens     int
	CompletionTokens int
	TotalTokens      int
}

type Lane struct {
	Name          string
	MaxConcurrent int
	// contains filtered or unexported fields
}

type LaneConfig struct {
	SessionMax  int `yaml:"session_max"`  // Default: 1 (one agent run per session)
	GlobalMax   int `yaml:"global_max"`   // Default: 3
	CronMax     int `yaml:"cron_max"`     // Default: 2
	SubagentMax int `yaml:"subagent_max"` // Default: 8
}

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

type LaneTask struct {
	ID       string
	Fn       func(ctx context.Context) error
	Priority int // Lower = higher priority (0 is highest)
}

type LoggingConfig struct {
	// Level is the log level ("debug", "info", "warn", "error").
	Level string `yaml:"level"`

	// Format is the log format ("json", "text").
	Format string `yaml:"format"`
}

type LoopDetectionResult struct {
	Severity LoopSeverity
	Message  string // Injected into the conversation as a system hint
	Streak   int    // Number of consecutive repeats detected
	Pattern  string // "repeat", "ping-pong", "known_poll", "global_breaker", or ""
}

type LoopSeverity int

type MCPConfig struct {
	// Enabled turns MCP support on/off.
	Enabled bool `yaml:"enabled" json:"enabled"`

	// Servers is the list of configured MCP servers.
	Servers []ManagedMCPServerConfig `yaml:"servers" json:"servers"`
}

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

type MCPServerConfig struct {
	Name      string            `yaml:"name"`
	Transport string            `yaml:"transport"` // "stdio", "sse", "streamable-http"
	Command   string            `yaml:"command,omitempty"`
	Args      []string          `yaml:"args,omitempty"`
	URL       string            `yaml:"url,omitempty"`
	Env       map[string]string `yaml:"env,omitempty"`
}

type MCPServerInfo struct {
	Config ManagedMCPServerConfig `json:"config"`
	Status MCPServerStatus        `json:"status"`
}

type MCPServerStatus struct {
	Name        string    `json:"name"`
	Connected   bool      `json:"connected"`
	LastChecked time.Time `json:"last_checked"`
	Error       string    `json:"error,omitempty"`
	Tools       []string  `json:"tools,omitempty"`
}

type MCPType string

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

type MaintenanceMode struct {
	Enabled bool      `json:"enabled"`
	Message string    `json:"message"`
	SetBy   string    `json:"set_by"`
	SetAt   time.Time `json:"set_at"`
}

type ManagedMCPServerConfig struct {
	// Name is the unique identifier for this MCP server.
	Name string `yaml:"name" json:"name"`

	// Type is the connection type (stdio, sse, http, websocket).
	Type MCPType `yaml:"type" json:"type"`

	// Command is the executable for stdio type.
	Command string `yaml:"command" json:"command,omitempty"`

	// Args are command-line arguments for stdio type.
	Args []string `yaml:"args" json:"args,omitempty"`

	// URL is the endpoint for SSE/HTTP/WebSocket types.
	URL string `yaml:"url" json:"url,omitempty"`

	// Headers are custom HTTP headers for SSE/HTTP/WebSocket types.
	Headers map[string]string `yaml:"headers" json:"headers,omitempty"`

	// Env are environment variables for stdio type.
	Env map[string]string `yaml:"env" json:"env,omitempty"`

	// Enabled controls whether this MCP server is active.
	Enabled bool `yaml:"enabled" json:"enabled"`

	// AutoStart controls whether to start on launch.
	AutoStart bool `yaml:"auto_start" json:"auto_start"`

	// Timeout is the connection timeout in seconds.
	Timeout int `yaml:"timeout" json:"timeout"`

	// Description is a human-readable description.
	Description string `yaml:"description" json:"description,omitempty"`
}