domain

type A2AAgentService interface {
	GetAgentCards(ctx context.Context) ([]*CachedAgentCard, error)
	GetConfiguredAgents() []string
}

type A2AClearer interface {
	ClearAllAgents()
}

type A2AStateProvider interface {
	A2APollingState() TaskPollingState
}

type A2ATaskCompletedEvent struct {
	RequestID string
	Timestamp time.Time
	TaskID    string
	Result    ToolExecutionResult
}

type A2ATaskCoordinator interface {
	HandleTaskSubmitted(msg A2ATaskSubmittedEvent) tea.Cmd
	HandleTaskCompleted(msg A2ATaskCompletedEvent) tea.Cmd
	HandleTaskFailed(msg A2ATaskFailedEvent) tea.Cmd
	HandleTaskStatusUpdate(msg A2ATaskStatusUpdateEvent) tea.Cmd
	HandleTaskInputRequired(msg A2ATaskInputRequiredEvent) tea.Cmd
	HandleToolCallExecuted(msg A2AToolCallExecutedEvent) tea.Cmd
}

type A2ATaskFailedEvent struct {
	RequestID string
	Timestamp time.Time
	TaskID    string
	Result    ToolExecutionResult
	Error     string
}

type A2ATaskInputRequiredEvent struct {
	RequestID string
	Timestamp time.Time
	TaskID    string
	Message   string
	Required  bool
}

type A2ATaskStatusUpdateEvent struct {
	RequestID string
	Timestamp time.Time
	TaskID    string
	AgentURL  string
	Status    string
	Progress  float64
	Message   string
}

type A2ATaskSubmittedEvent struct {
	RequestID string
	Timestamp time.Time
	TaskID    string
	AgentName string
	AgentURL  string
	TaskType  string
}

type A2ATaskTracker interface {
	// Context management (contexts are server-generated and tracked here).
	// Multiple contexts per agent enable multi-tenant/multi-session support.
	RegisterContext(agentURL, contextID string)
	GetLatestContextForAgent(agentURL string) string
	HasContext(contextID string) bool

	// Task management (tasks are server-generated and scoped to contexts per A2A spec)
	AddTask(contextID, taskID string)
	GetLatestTaskForContext(contextID string) string
	RemoveTask(taskID string)

	// Agent management
	ClearAllAgents()

	// Polling state management (one polling state per task)
	StartPolling(taskID string, state *TaskPollingState)
	StopPolling(taskID string)
	GetPollingState(taskID string) *TaskPollingState
	GetAllPollingTasks() []string
}

type A2AToolCallExecutedEvent struct {
	RequestID         string
	Timestamp         time.Time
	ToolCallID        string
	ToolName          string
	Arguments         string
	ExecutedOnGateway bool
	TaskID            string
}

type ActiveToolTracker interface {
	GetActiveToolCallID() string
	SetActiveToolCallID(id string)
}

type AgentContext struct {
	RequestID        string
	Conversation     *[]sdk.Message
	MessageQueue     MessageQueue
	ConversationRepo ConversationRepository
	ToolCalls        []*sdk.ChatCompletionMessageToolCall
	Turns            int
	MaxTurns         int
	HasToolResults   bool
	LastToolFailed   bool
	ApprovalPolicy   ApprovalPolicy
	Ctx              context.Context
	IsChatMode       bool
}

type AgentErrorMessage struct {
	Type    string `json:"type"` // "agent_error"
	Message string `json:"message"`
}

type AgentEvent interface {
	EventType() string
}

type AgentExecutionState int

type AgentManager interface {
	// StartAgents starts all agents configured with run: true
	StartAgents(ctx context.Context) error

	// StopAgents stops all running agent containers
	StopAgents(ctx context.Context) error

	// StopAgent stops a specific agent container by name
	StopAgent(ctx context.Context, agentName string) error

	// IsRunning returns whether any agents are running
	IsRunning() bool

	// SetStatusCallback sets the callback function for agent status updates
	SetStatusCallback(callback func(agentName string, state AgentState, message string, url string, image string))

	// SetPullProgressCallback sets the callback function for image pull progress updates
	SetPullProgressCallback(callback func(agentName string, done, total int))
}

type AgentMode int

type AgentModeManager interface {
	GetAgentMode() AgentMode
	SetAgentMode(mode AgentMode)
	CycleAgentMode() AgentMode
}

type AgentReadinessManager interface {
	InitializeAgentReadiness(totalAgents int)
	UpdateAgentStatus(name string, state AgentState, message string, url string, image string)
	SetAgentError(name string, err error)
	GetAgentReadiness() *AgentReadinessState
	AreAllAgentsReady() bool
	ClearAgentReadiness()
	RemoveAgent(name string)
}

type AgentReadinessState struct {
	TotalAgents int                     `json:"total_agents"`
	ReadyAgents int                     `json:"ready_agents"`
	Agents      map[string]*AgentStatus `json:"agents"`
	StartTime   time.Time               `json:"start_time"`
}

type AgentRequest struct {
	RequestID  string        `json:"request_id"`
	Model      string        `json:"model"`
	Messages   []sdk.Message `json:"messages"`
	IsChatMode bool          `json:"is_chat_mode"`
}

type AgentService interface {
	// Run executes an agent task synchronously (for background/batch processing)
	Run(ctx context.Context, req *AgentRequest) (*ChatSyncResponse, error)

	// RunWithStream executes an agent task with streaming (for interactive chat)
	RunWithStream(ctx context.Context, req *AgentRequest) (<-chan ChatEvent, error)

	// CancelRequest cancels an active request
	CancelRequest(requestID string) error

	// GetMetrics returns metrics for a completed request
	GetMetrics(requestID string) *ChatMetrics

	// BuildSystemPrompt returns the static system prompt sent as message[0],
	// byte-stable across turns; volatile context travels separately as a hidden
	// per-request message (see `infer debug agent system_prompt`).
	BuildSystemPrompt() string

	// SetReasoningEffort updates the reasoning effort applied to subsequent
	// requests. An empty string resets to the provider default.
	SetReasoningEffort(effort string) error

	// GetReasoningEffort returns the effort level currently applied to
	// requests ("" = provider default).
	GetReasoningEffort() string
}

type AgentState int

type AgentStateMachine interface {
	// Transition attempts to transition to the target state
	Transition(ctx *AgentContext, targetState AgentExecutionState) error

	// GetCurrentState returns the current state (thread-safe)
	GetCurrentState() AgentExecutionState

	// GetPreviousState returns the previous state (thread-safe)
	GetPreviousState() AgentExecutionState

	// CanTransition checks if a transition is valid without executing it
	CanTransition(ctx *AgentContext, targetState AgentExecutionState) bool

	// GetValidTransitions returns all valid transitions from current state
	GetValidTransitions(ctx *AgentContext) []AgentExecutionState

	// Reset resets the state machine to idle
	Reset()
}

type AgentStatus struct {
	Name        string     `json:"name"`
	URL         string     `json:"url"`
	Image       string     `json:"image"`
	State       AgentState `json:"state"`
	Message     string     `json:"message,omitempty"`
	StartTime   time.Time  `json:"start_time"`
	ReadyTime   *time.Time `json:"ready_time,omitempty"`
	Error       string     `json:"error,omitempty"`
	LayersDone  int        `json:"layers_done,omitempty"`
	LayersTotal int        `json:"layers_total,omitempty"`
}

type AgentStatusUpdateEvent struct {
	AgentName string
	State     AgentState
	Message   string
	URL       string
	Image     string
}

type AllToolsProcessedEvent struct{}

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

type ApprovalAction int

type ApprovalChannel interface {
	SendApproval(ctx context.Context, recipientID string, req *ApprovalRequest) error
}

type ApprovalCoordinator interface {
	HandlePlanApprovalRequested(msg PlanApprovalRequestedEvent) tea.Cmd
	HandlePlanApprovalResponse(msg PlanApprovalResponseEvent) (cmd tea.Cmd, restart bool)
	HandleUserQuestionRequested(msg UserQuestionRequestedEvent) tea.Cmd
	HandleComputerUsePaused(msg ComputerUsePausedEvent) tea.Cmd
	HandleComputerUseResumed(msg ComputerUseResumedEvent) (cmd tea.Cmd, restart bool)
}

type ApprovalFailedEvent struct {
	Error error
}

type ApprovalPolicy interface {
	// ShouldRequireApproval returns true if the tool execution requires user approval
	// ctx: context for the approval decision
	// toolCall: the tool being invoked with its arguments
	// isChatMode: whether execution is in interactive chat mode
	ShouldRequireApproval(ctx context.Context, toolCall *sdk.ChatCompletionMessageToolCall, isChatMode bool) bool
}

type ApprovalRequest struct {
	Type       string `json:"type"` // "approval_request"
	ToolName   string `json:"tool_name"`
	ToolArgs   string `json:"tool_args"`
	ToolCallID string `json:"tool_call_id"`
}

type ApprovalResponse struct {
	Type       string `json:"type"` // "approval_response"
	ToolCallID string `json:"tool_call_id"`
	Approved   bool   `json:"approved"`
}

type ApprovalUIManager interface {
	SetupApprovalUIState(toolCall *sdk.ChatCompletionMessageToolCall, responseChan chan ApprovalAction)
	GetApprovalUIState() *ApprovalUIState
	ClearApprovalUIState()
}

type ApprovalUIState struct {
	PendingToolCall *sdk.ChatCompletionMessageToolCall `json:"pending_tool_call"`
	ResponseChan    chan ApprovalAction                `json:"-"`
}

type AutocompleteCompleteEvent struct {
	Completion string
	CursorPos  int
}

type AutocompleteHideEvent struct{}

type AutocompleteUpdateEvent struct {
	Text      string
	CursorPos int
}

type BackgroundJob interface {
	// Meta returns the job's identity/display snapshot.
	Meta() JobMeta
	// Run blocks until the job reaches a terminal state or ctx is cancelled,
	// emitting intermediate JobSignals via emit, and returns the terminal result.
	// It MUST return promptly once ctx is cancelled.
	Run(ctx context.Context, emit func(JobSignal)) ToolExecutionResult
	// Wind delivers a graceful wind-down (WindWrapUp) or hard stop (WindStop) to a
	// RUNNING job. It must be safe to call from another goroutine while Run is in
	// flight, be idempotent, and a no-op once the job has finished.
	Wind(ctx context.Context, sig WindSignal) error
	// Close tears down the resources the job owns (its per-kind tracker record, an
	// interactive subagent's tmux pane and temp files, ...). The supervisor calls
	// it exactly once when it reaps a finished job after the retention window. It
	// must be idempotent and must not touch the running process (use Wind for that).
	Close()
}

type BackgroundShell struct {
	ShellID      string
	Command      string
	Cmd          *exec.Cmd
	StartedAt    time.Time
	CompletedAt  *time.Time
	State        ShellState
	ExitCode     *int
	OutputBuffer OutputRingBuffer
	CancelFunc   context.CancelFunc
	ReadOffset   int64

	ReadersDone <-chan struct{}
}

type BackgroundShellRequestEvent struct{}

type BackgroundShellService interface {
	// DetachToBackground moves a running command to background. readersDone, when
	// non-nil, is closed once the caller's pipe readers reach EOF; the supervisor
	// waits on it before reaping so trailing output is not truncated.
	DetachToBackground(ctx context.Context, cmd *exec.Cmd, command string, outputBuffer OutputRingBuffer, readersDone <-chan struct{}) (string, error)

	// GetShellOutput retrieves output from a shell
	GetShellOutput(shellID string, fromOffset int64) (string, int64, ShellState, error)

	// GetShellOutputWithFilter retrieves filtered output from a shell
	GetShellOutputWithFilter(shellID string, fromOffset int64, filterPattern string) (string, int64, ShellState, error)

	// GetShell returns a specific shell by ID
	GetShell(shellID string) *BackgroundShell

	// GetAllShells returns all tracked shells
	GetAllShells() []*BackgroundShell

	// CancelShell cancels a running background shell
	CancelShell(shellID string) error

	// RemoveShell removes a shell from tracking
	RemoveShell(shellID string) error
}

type BackgroundTaskRegistry interface {
	A2ATaskTracker
	ShellTracker
	SubagentTracker

	// HasPending reports whether *any* background work is still in flight,
	// regardless of type. True when there is at least one A2A task being
	// polled, one running background shell, OR one running HEADLESS subagent.
	// It deliberately excludes interactive subagents so a one-shot `infer agent`
	// does not hang at exit waiting on a user-driven tmux pane.
	HasPending() bool

	// Submit hands a background job to the supervisor, which spawns its monitor
	// goroutine and folds its result back onto the conversation when it finishes.
	// This is the single entry point every kind (A2A task, shell, subagent) uses
	// instead of running its own poller.
	Submit(job BackgroundJob)

	// Snapshot returns the supervisor's view of all live and recently-finished
	// jobs for the task view and status line.
	Snapshot() []TrackedJob

	// CountRunningJobs returns how many supervised jobs are running, optionally
	// filtered to one kind (pass "" for all kinds).
	CountRunningJobs(kind JobKind) int

	// IsJobRunning reports whether the supervised job with the given id is still
	// running. It is the per-id liveness query a tool uses (via the narrow
	// JobLivenessReporter projection) to defer to the supervisor - the single
	// source of truth - instead of racing it with a manual read.
	IsJobRunning(id string) bool

	// WindJob sends a graceful wind-down or hard stop to one supervised job.
	WindJob(id string, sig WindSignal) error
}

type BackgroundTaskService interface {
	// GetBackgroundTasks returns all current background polling tasks
	GetBackgroundTasks() []TaskPollingState

	// CancelBackgroundTask cancels a background task by task ID
	CancelBackgroundTask(taskID string) error
}

type BackgroundTasksChangedEvent struct{}

type BaseChatEvent struct {
	RequestID string
	Timestamp time.Time
}

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

type BashCommandCompletedEvent struct {
	History       []ConversationEntry
	Failed        bool
	UserInitiated bool
	ErrorMessage  string
}

type BashDetachChannelHolder interface {
	SetBashDetachChan(chan<- struct{})
	GetBashDetachChan() chan<- struct{}
	ClearBashDetachChan()
}

type BashOutputCallback func(output string)

type BashOutputChunkEvent struct {
	BaseChatEvent
	ToolCallID string
	Output     string
	IsComplete bool
}

type BashToolResult struct {
	Command  string `json:"command"`
	Output   string `json:"output"`
	Error    string `json:"error,omitempty"`
	ExitCode int    `json:"exit_code"`
	Duration string `json:"duration"`
}

type BorderOverlayEvent struct {
	BaseChatEvent
	BorderAction string
}

type CachedAgentCard struct {
	Card      *adk.AgentCard `json:"card"`
	URL       string         `json:"url"`
	FetchedAt time.Time      `json:"fetched_at"`
}

type Channel interface {
	// Name returns the channel identifier (e.g., "whatsapp", "telegram")
	Name() string
	// Start begins listening for inbound messages. Blocks until ctx is cancelled.
	Start(ctx context.Context, inbox chan<- InboundMessage) error
	// Send delivers an outbound message through this channel
	Send(ctx context.Context, msg OutboundMessage) error
	// Stop gracefully shuts down the channel
	Stop() error
}

type ChannelCommand struct {
	Name        string
	Description string
}

type CharmTheme struct{}

type ChatChunkEvent struct {
	RequestID        string
	Timestamp        time.Time
	Content          string
	ReasoningContent string
	ToolCalls        []sdk.ChatCompletionMessageToolCallChunk
	Delta            bool
	Usage            *sdk.CompletionUsage
}

type ChatCompleteEvent struct {
	RequestID        string
	Timestamp        time.Time
	Message          string
	ReasoningContent string
	ToolCalls        []sdk.ChatCompletionMessageToolCall
	Metrics          *ChatMetrics
	Cancelled        bool
}

type ChatCompletionRunner interface {
	Start(holder BashDetachChannelHolder) tea.Cmd
	HandleChatStart(msg ChatStartEvent) tea.Cmd
	HandleChatChunk(msg ChatChunkEvent) tea.Cmd
	HandleChatComplete(msg ChatCompleteEvent) tea.Cmd
	HandleChatError(msg ChatErrorEvent) tea.Cmd
	HandleOptimizationStatus(msg OptimizationStatusEvent) tea.Cmd
	SetPendingRestoration(originalModel string)
}

type ChatErrorEvent struct {
	RequestID string
	Timestamp time.Time
	Error     error
}

type ChatEvent interface {
	GetRequestID() string
	GetTimestamp() time.Time
}

type ChatEventListener interface {
	ListenForChatEvents(eventChan <-chan ChatEvent) tea.Cmd
	ListenForEvents(eventChan <-chan tea.Msg) tea.Cmd
}

type ChatHandler interface {
	// Core event handling (to be deprecated as we move to component-based handling)
	Handle(msg tea.Msg) tea.Cmd

	// Specific event handlers
	HandleUserInputEvent(msg UserInputEvent) tea.Cmd
	HandleFileSelectionRequestEvent(msg FileSelectionRequestEvent) tea.Cmd
	HandleConversationSelectedEvent(msg ConversationSelectedEvent) tea.Cmd
	HandleToolApprovalRequestedEvent(msg ToolApprovalRequestedEvent) tea.Cmd
	HandleToolApprovalResponseEvent(msg ToolApprovalResponseEvent) tea.Cmd
	HandlePlanApprovalRequestedEvent(msg PlanApprovalRequestedEvent) tea.Cmd
	HandlePlanApprovalResponseEvent(msg PlanApprovalResponseEvent) tea.Cmd

	// Command handlers
	HandleCommand(commandText string) tea.Cmd
	HandleBashCommand(commandText string) tea.Cmd
	HandleToolCommand(commandText string) tea.Cmd
	HandleBackgroundShellRequest() tea.Cmd

	// Event channel listeners
	ListenForEvents(eventChan <-chan tea.Msg) tea.Cmd
	ListenForChatEvents(eventChan <-chan ChatEvent) tea.Cmd

	// State management
	GetActiveToolCallID() string
	SetActiveToolCallID(id string)

	// Utility methods
	ParseToolCall(input string) (string, map[string]any, error)
	ParseArguments(argsStr string) (map[string]any, error)
	SetBashDetachChan(chan<- struct{})
	GetBashDetachChan() chan<- struct{}
	ClearBashDetachChan()
}

type ChatMetrics struct {
	Duration time.Duration
	Usage    *sdk.CompletionUsage
}

type ChatService interface {
	CancelRequest(requestID string) error
	GetMetrics(requestID string) *ChatMetrics
}

type ChatSession struct {
	RequestID    string
	Status       ChatStatus
	StartTime    time.Time
	Model        string
	EventChannel <-chan ChatEvent
	IsFirstChunk bool
	HasToolCalls bool
	LastActivity time.Time
	RetryStatus  *RetryStatus
}

type ChatSessionManager interface {
	SetChatPending()
	StartChatSession(requestID, model string, eventChan <-chan ChatEvent) error
	UpdateChatStatus(status ChatStatus) error
	EndChatSession()
	GetChatSession() *ChatSession
	IsAgentBusy() bool
	SetRetryStatus(status *RetryStatus)
	GetRetryStatus() *RetryStatus
	TouchChatActivity()
}

type ChatStartEvent struct {
	RequestID string
	Timestamp time.Time
	Model     string
}

type ChatStatus int

type ChatSyncResponse struct {
	RequestID        string                              `json:"request_id"`
	Content          string                              `json:"content"`
	ReasoningContent string                              `json:"reasoning_content,omitempty"`
	ToolCalls        []sdk.ChatCompletionMessageToolCall `json:"tool_calls,omitempty"`
	Usage            *sdk.CompletionUsage                `json:"usage,omitempty"`
	Duration         time.Duration                       `json:"duration"`
}

type ClearErrorEvent struct{}

type ClearInputEvent struct{}

type ClickIndicatorEvent struct {
	BaseChatEvent
	X              int  `json:"X"`
	Y              int  `json:"Y"`
	ClickIndicator bool `json:"ClickIndicator"`
}

type CompletionRequestedEvent struct{}

type ComputerUsePauseManager interface {
	SetComputerUsePaused(paused bool, requestID string)
	IsComputerUsePaused() bool
	GetPausedRequestID() string
	ClearComputerUsePauseState()
}

type ComputerUsePausedEvent struct {
	RequestID string
	Timestamp time.Time
}

type ComputerUseResumedEvent struct {
	RequestID string
	Timestamp time.Time
}

type ContainerInfo struct {
	ID   string
	Name string
}

type ContainerRuntime interface {
	// Network operations
	GetNetworkName() string
	EnsureNetwork(ctx context.Context) error
	CleanupNetwork(ctx context.Context) error

	// Container lifecycle operations
	ContainerExists(containerIDOrName string) bool
	RunContainer(ctx context.Context, opts RunContainerOptions) (containerID string, err error)
	StopContainer(ctx context.Context, containerIDOrName string) error

	// Image operations. The optional progress callback receives layer counts
	// as the pull advances.
	PullImage(ctx context.Context, image string, progress func(done, total int)) error

	// Container inspection
	GetContainerHealth(ctx context.Context, containerIDOrName string) (HealthStatus, error)
	ListRunningContainers(ctx context.Context, nameFilter string) ([]ContainerInfo, error)
}

type ContextKey string

type ConversationEntry struct {
	// Core message fields
	Message          Message           `json:"message"`
	Model            string            `json:"model,omitempty"`
	Time             time.Time         `json:"time"`
	Hidden           bool              `json:"hidden,omitempty"`
	Images           []ImageAttachment `json:"images,omitempty"`
	ReasoningContent string            `json:"reasoning_content,omitempty"`

	// Tool-related fields
	ToolExecution      *ToolExecutionResult               `json:"tool_execution,omitempty"`
	PendingToolCall    *sdk.ChatCompletionMessageToolCall `json:"pending_tool_call,omitempty"`
	ToolApprovalStatus ToolApprovalStatus                 `json:"tool_approval_status,omitempty"`

	// Plan mode fields
	Rejected           bool               `json:"rejected,omitempty"`
	IsPlan             bool               `json:"is_plan,omitempty"`
	PlanApprovalStatus PlanApprovalStatus `json:"plan_approval_status,omitempty"`
}

type ConversationExporter interface {
	Export(format ExportFormat) ([]byte, error)
}

type ConversationLifecycleManager interface {
	StartNewConversation(title string) error
	LoadConversation(ctx context.Context, conversationID string) error
	GetCurrentConversationTitle() string
	GetCurrentConversationID() string
}

type ConversationMetadata struct {
	ID                  string            `json:"id"`
	Title               string            `json:"title"`
	CreatedAt           time.Time         `json:"created_at"`
	UpdatedAt           time.Time         `json:"updated_at"`
	MessageCount        int               `json:"message_count"`
	TokenStats          SessionTokenStats `json:"token_stats"`
	CostStats           SessionCostStats  `json:"cost_stats,omitempty"`
	Model               string            `json:"model,omitempty"`
	Tags                []string          `json:"tags,omitempty"`
	TitleGenerated      bool              `json:"title_generated,omitempty"`
	TitleInvalidated    bool              `json:"title_invalidated,omitempty"`
	TitleGenerationTime *time.Time        `json:"title_generation_time,omitempty"`
	ContextID           string            `json:"context_id,omitempty"`
}

type ConversationOptimizer interface {
	OptimizeMessages(messages []sdk.Message, model string, force bool) []sdk.Message
}

type ConversationRepository interface {
	MessageRepository
	TokenUsageRepository
	ToolResultFormatter
	PendingToolCallManager
	ConversationLifecycleManager
	ConversationExporter
}

type ConversationSelectedEvent struct {
	ConversationID string
}

type ConversationSummary struct {
	ID                  string            `json:"id"`
	Title               string            `json:"title"`
	CreatedAt           time.Time         `json:"created_at"`
	UpdatedAt           time.Time         `json:"updated_at"`
	MessageCount        int               `json:"message_count"`
	TokenStats          SessionTokenStats `json:"token_stats"`
	CostStats           SessionCostStats  `json:"cost_stats,omitempty"`
	Model               string            `json:"model,omitempty"`
	Tags                []string          `json:"tags,omitempty"`
	Summary             string            `json:"summary,omitempty"`
	TitleGenerated      bool              `json:"title_generated,omitempty"`
	TitleInvalidated    bool              `json:"title_invalidated,omitempty"`
	TitleGenerationTime *time.Time        `json:"title_generation_time,omitempty"`
}

type ConversationsLoadedEvent struct {
	Conversations []any
	Error         error
}

type CustomFormatter struct {
	BaseFormatter
	// contains filtered or unexported fields
}

type DebugKeyEvent struct {
	Key     string
	Handler string
}

type DeleteToolResult struct {
	Path              string   `json:"path"`
	DeletedFiles      []string `json:"deleted_files"`
	DeletedDirs       []string `json:"deleted_dirs"`
	TotalFilesDeleted int      `json:"total_files_deleted"`
	TotalDirsDeleted  int      `json:"total_dirs_deleted"`
	WildcardExpanded  bool     `json:"wildcard_expanded"`
	Errors            []string `json:"errors,omitempty"`
}

type DimensionsManager interface {
	SetDimensions(width, height int)
	GetDimensions() (int, int)
}

type DirectExecutionService interface {
	BashDetachChannelHolder

	HandleBashCommand(commandText string) tea.Cmd
	HandleToolCommand(commandText string) tea.Cmd
	HandleBackgroundShellRequest() tea.Cmd
	HandleBashOutputChunk(msg BashOutputChunkEvent) tea.Cmd
	HandleBashCommandCompleted(msg BashCommandCompletedEvent) tea.Cmd

	ParseToolCall(input string) (string, map[string]any, error)
	ParseArguments(argsStr string) (map[string]any, error)

	PendingBashChannel() <-chan tea.Msg
	PendingToolChannel() <-chan tea.Msg
}

type DraculaTheme struct{}

type DrainQueueEvent struct{}

type DrainQueueRetryEvent struct{}

type EditOperationResult struct {
	OldString     string `json:"old_string"`
	NewString     string `json:"new_string"`
	ReplaceAll    bool   `json:"replace_all"`
	ReplacedCount int    `json:"replaced_count"`
	Success       bool   `json:"success"`
	Error         string `json:"error,omitempty"`
	// WhitespaceNormalized is true when this edit matched via the indentation-tolerant fallback.
	WhitespaceNormalized bool `json:"whitespace_normalized,omitempty"`
}

type EditToolResult struct {
	FilePath             string `json:"file_path"`
	OldString            string `json:"old_string"`
	NewString            string `json:"new_string"`
	ReplacedCount        int    `json:"replaced_count"`
	ReplaceAll           bool   `json:"replace_all"`
	FileModified         bool   `json:"file_modified"`
	OriginalSize         int64  `json:"original_size"`
	NewSize              int64  `json:"new_size"`
	BytesDifference      int64  `json:"bytes_difference"`
	OriginalLines        int    `json:"original_lines"`
	NewLines             int    `json:"new_lines"`
	LinesDifference      int    `json:"lines_difference"`
	Diff                 string `json:"diff,omitempty"`
	WhitespaceNormalized bool   `json:"whitespace_normalized,omitempty"`
	StartLine            int    `json:"start_line,omitempty"`
}

type EventBridge interface {
	// Tap intercepts an event stream and multicasts it to all subscribers
	// Returns a new channel that mirrors the input channel
	Tap(input <-chan ChatEvent) <-chan ChatEvent

	// Publish broadcasts an event to all subscribers
	Publish(event ChatEvent)

	// Subscribe creates a new event channel and returns it
	Subscribe() chan ChatEvent

	// Unsubscribe removes a subscriber and closes its channel
	Unsubscribe(ch chan ChatEvent)
}

type EventBridgeManager interface {
	SetEventBridge(bridge EventBridge)
	GetEventBridge() EventBridge
	BroadcastEvent(event ChatEvent)
}

type ExportFormat string

type FetchResult struct {
	Content     string            `json:"content"`
	URL         string            `json:"url"`
	Status      int               `json:"status"`
	Size        int64             `json:"size"`
	ContentType string            `json:"content_type"`
	Cached      bool              `json:"cached"`
	SavedPath   string            `json:"saved_path,omitempty"`
	Metadata    map[string]string `json:"metadata,omitempty"`
	Warning     string            `json:"warning,omitempty"`
}

type FileInfo struct {
	Path  string
	Size  int64
	IsDir bool
}

type FileReadToolResult struct {
	FilePath  string `json:"file_path"`
	Content   string `json:"content"`
	Size      int64  `json:"size"`
	StartLine int    `json:"start_line,omitempty"`
	EndLine   int    `json:"end_line,omitempty"`
	Error     string `json:"error,omitempty"`
}

type FileSelectionManager interface {
	SetupFileSelection(files []string)
	GetFileSelectionState() *FileSelectionState
	UpdateFileSearchQuery(query string)
	SetFileSelectedIndex(index int)
	ClearFileSelectionState()
}

type FileSelectionRequestEvent struct{}

type FileSelectionState struct {
	Files         []string `json:"files"`
	SearchQuery   string   `json:"search_query"`
	SelectedIndex int      `json:"selected_index"`
}

type FileService interface {
	ListProjectFiles() ([]string, error)
	ReadFile(path string) (string, error)
	ReadFileLines(path string, startLine, endLine int) (string, error)
	ValidateFile(path string) error
	GetFileInfo(path string) (FileInfo, error)
}

type FileWriteToolResult struct {
	FilePath     string `json:"file_path"`
	BytesWritten int64  `json:"bytes_written"`
	LinesWritten int    `json:"lines_written"`
	Created      bool   `json:"created"`
	Overwritten  bool   `json:"overwritten"`
	DirsCreated  bool   `json:"dirs_created"`
	Appended     bool   `json:"appended"`
	ChunkIndex   int    `json:"chunk_index,omitempty"`
	TotalChunks  int    `json:"total_chunks,omitempty"`
	IsComplete   bool   `json:"is_complete"`
	Error        string `json:"error,omitempty"`
}

type FocusManager interface {
	SetLastFocusedApp(appID string)
	GetLastFocusedApp() string
	ClearLastFocusedApp()
	SetLastClickCoordinates(x, y int)
	GetLastClickCoordinates() (x, y int)
	ClearLastClickCoordinates()
}

type FocusStatusBarEvent struct{}

type FormatterType string

type GatewayManager interface {
	// Start starts the gateway container or binary if configured to run locally
	Start(ctx context.Context) error

	// Stop stops the gateway container or binary
	Stop(ctx context.Context) error

	// IsRunning returns whether the gateway is running
	IsRunning() bool

	// GetGatewayURL returns the actual gateway URL with the assigned port
	GetGatewayURL() string

	// EnsureStarted starts the gateway if configured and not already running
	// This is a convenience method that checks config and running state before starting
	EnsureStarted() error
}

type GitHubIssue struct {
	Number    int
	Title     string
	Body      string
	State     string
	URL       string
	UpdatedAt time.Time
	Author    string
	Comments  []GitHubIssueComment
}

type GitHubIssueComment struct {
	Author    string
	Body      string
	CreatedAt time.Time
}

type GitHubIssueService interface {
	// ListIssues returns recent open issues for the current repo, newest first.
	// Results are cached for a short TTL so repeated autocomplete keystrokes
	// don't shell out per character. Returns ([], nil) on environment failures.
	ListIssues(ctx context.Context) ([]GitHubIssue, error)

	// GetIssue fetches an issue with body and the most-recent comments (capped
	// internally). Uncached. Returns (nil, err) on failure so the expansion
	// path can leave the raw token in place.
	GetIssue(ctx context.Context, number int) (*GitHubIssue, error)

	// IsAvailable reports whether the service can serve requests in the
	// current environment. Used by the autocomplete trigger to short-circuit
	// a slow first shell-out when gh / repo / auth are missing.
	IsAvailable() bool
}

type GitHubSetupService interface {
	GetCurrentRepo() (string, error)
	IsOrgRepo(repo string) (bool, error)
	CheckOrgSecretsExist(orgName string) (bool, error)
	SetOrgSecret(orgName, name, value string) error
	PreparePRCreation(repo, workflowPath string) (string, error)
	WriteWorkflowFile(path, content string) error
	GenerateStandardWorkflowContent() string
	GenerateGithubActionWorkflowContent() string
}

type GitPRResolvedEvent struct {
	PR string
}

type GithubLightTheme struct{}

type HealthCheckConfig struct {
	Interval    string // e.g., "10s"
	Timeout     string // e.g., "5s"
	Retries     int
	StartPeriod string // e.g., "10s"
}

type HealthStatus string

type HideHelpBarEvent struct{}

type HistoryCleaner interface {
	ClearHistory(ctx context.Context, recipientID string) error
}

type HookCommand struct {
	Name    string
	Command string
	Timeout time.Duration
}

type HookCommandProvider interface {
	CommandsDue(hook HookPoint) []HookCommand
}

type HookPoint string

type ImageAttachment struct {
	Data        string `json:"data"`
	MimeType    string `json:"mime_type"`
	Filename    string `json:"filename,omitempty"`
	DisplayName string `json:"display_name"`
	SourcePath  string `json:"-"`
}

type ImageService interface {
	// ReadImageFromFile reads an image from a file path and returns it as a base64 attachment
	ReadImageFromFile(filePath string) (*ImageAttachment, error)
	// ReadImageFromBinary reads an image from binary data and returns it as a base64 attachment
	ReadImageFromBinary(imageData []byte, filename string) (*ImageAttachment, error)
	// ReadImageFromURL fetches an image from a URL and returns it as a base64 attachment
	ReadImageFromURL(imageURL string) (*ImageAttachment, error)
	// CreateDataURL creates a data URL from an image attachment
	CreateDataURL(attachment *ImageAttachment) string
	// IsImageFile checks if a file is a supported image format
	IsImageFile(filePath string) bool
	// IsImageURL checks if a string is a valid image URL
	IsImageURL(urlStr string) bool
}

type InboundMessage struct {
	ChannelName string            `json:"channel_name"`
	SenderID    string            `json:"sender_id"`
	Content     string            `json:"content"`
	Images      []ImageAttachment `json:"images,omitempty"`
	Timestamp   time.Time         `json:"timestamp"`
	Metadata    map[string]string `json:"metadata,omitempty"`
}

type JobKind string

type JobLivenessReporter interface {
	IsJobRunning(id string) bool
}

type JobMeta struct {
	ID          string
	Kind        JobKind
	Label       string
	Description string
	Detail      string
	StartedAt   time.Time

	Silent bool

	// HoldsSession keeps a headless session alive until the job terminates (A2A
	// tasks, shells, headless subagents). False for user-driven interactive
	// subagent panes so a one-shot `infer agent` does not hang at exit.
	HoldsSession bool
}

type JobNotifier interface {
	Notification(result ToolExecutionResult) string
}

type JobOutputProvider interface {
	Output() string
}

type JobSignal struct {
	// Note is a human-facing line surfaced to the UI and, when Enqueue is set,
	// landed on the message queue so the agent reads it on its next turn.
	Note string
	// Enqueue lands Note on the message queue and wakes the agent loop; otherwise
	// Note is a UI-only status update.
	Enqueue bool
	// State is an optional kind-specific status token (e.g. an A2A task state).
	State string
}

type JobStatus string

type JobStopper interface {
	WindJob(id string, sig WindSignal) error
}

type JobSubmitter interface {
	Submit(job BackgroundJob)
}

type KeyboardTypeToolResult struct {
	Text     string `json:"text,omitempty"`
	KeyCombo string `json:"key_combo,omitempty"`
	Display  string `json:"display"`
	Method   string `json:"method"`
}

type MCPClient interface {
	// DiscoverTools discovers all tools from enabled MCP servers
	DiscoverTools(ctx context.Context) (map[string][]MCPDiscoveredTool, error)

	// CallTool executes a tool on an MCP server
	CallTool(ctx context.Context, serverName, toolName string, args map[string]any) (any, error)

	// PingServer sends a ping request to check if a specific server is alive
	PingServer(ctx context.Context, serverName string) error

	// Close cleans up MCP client resources
	Close() error
}

type MCPDiscoveredTool struct {
	ServerName  string
	Name        string
	Description string
	InputSchema any
}

type MCPManager interface {
	// Returns a list of clients
	GetClients() []MCPClient

	// GetClient returns the client for a specific server by name, or nil if
	// no client is registered for that name. This is the O(1) lookup variant
	// of GetClients and should be preferred when the server name is known -
	// it avoids re-running DiscoverTools across every client just to find
	// the owning one.
	GetClient(serverName string) MCPClient

	// GetTotalServers returns the total number of configured MCP servers
	GetTotalServers() int

	// StartMonitoring begins background health monitoring, pushing every
	// MCPServerStatusUpdateEvent through the UI notifier injected at
	// construction. Idempotent; the initial status is emitted asynchronously.
	StartMonitoring(ctx context.Context)

	// UpdateToolCount updates the tool count for a specific server
	UpdateToolCount(serverName string, count int)

	// ClearToolCount removes the tool count for a specific server
	ClearToolCount(serverName string)

	// Container lifecycle management
	// StartServers starts all MCP servers that have run=true (non-fatal)
	StartServers(ctx context.Context) error

	// StopServers stops all running MCP server containers
	StopServers(ctx context.Context) error

	// Close stops monitoring, stops containers, and cleans up resources
	Close() error
}

type MCPServerEntry struct {
	Name         string
	URL          string
	Enabled      bool
	Timeout      int
	Description  string
	IncludeTools []string
	ExcludeTools []string
}

type MCPServerStatus struct {
	TotalServers     int `json:"total_servers"`
	ConnectedServers int `json:"connected_servers"`
	TotalTools       int `json:"total_tools"`
}

type MCPServerStatusUpdateEvent struct {
	ServerName       string
	Connected        bool
	TotalServers     int
	ConnectedServers int
	TotalTools       int
	Tools            []MCPDiscoveredTool
}

type MCPToolResult struct {
	ServerName string `json:"server_name"`
	ToolName   string `json:"tool_name"`
	Content    string `json:"content"`
	Error      string `json:"error,omitempty"`
}

type MarkdownRenderer interface {
	// Render converts markdown text to styled terminal output
	Render(content string) string
	// SetWidth updates the renderer width for responsive rendering
	SetWidth(width int)
}

type MemoryBackend interface {
	SyncIn(ctx context.Context) error
	SyncOut(ctx context.Context) error
}

type Message = sdk.Message

type MessageButton struct {
	Text string `json:"text"`
	Data string `json:"data"`
}

type MessageEditManager interface {
	SetMessageEditState(state *MessageEditState)
	GetMessageEditState() *MessageEditState
	ClearMessageEditState()
	IsEditingMessage() bool
}

type MessageEditState struct {
	OriginalMessageIndex int       `json:"original_message_index"`
	OriginalContent      string    `json:"original_content"`
	EditTimestamp        time.Time `json:"edit_timestamp"`
}

type MessageEditSubmitEvent struct {
	RequestID     string
	Timestamp     time.Time
	OriginalIndex int
	EditedContent string
	Images        []ImageAttachment
}

type MessageHistoryEditEvent struct {
	RequestID       string
	Timestamp       time.Time
	MessageIndex    int
	MessageContent  string
	MessageSnapshot MessageSnapshot
}

type MessageHistoryEditReadyEvent struct {
	MessageIndex int
	Content      string
	Snapshot     MessageSnapshot
}

type MessageHistoryReadyEvent struct {
	Messages []MessageSnapshot
}

type MessageHistoryRestoreEvent struct {
	RequestID      string
	Timestamp      time.Time
	RestoreToIndex int
}

type MessageQueue interface {
	// Enqueue adds a message to the queue
	Enqueue(message Message, requestID string)

	// Dequeue removes and returns the next message from the queue
	// Returns nil if the queue is empty
	Dequeue() *QueuedMessage

	// Peek returns the next message without removing it
	// Returns nil if the queue is empty
	Peek() *QueuedMessage

	// Size returns the number of messages in the queue
	Size() int

	// IsEmpty returns true if the queue has no messages
	IsEmpty() bool

	// Clear removes all messages from the queue
	Clear()

	// GetAll returns all messages in the queue without removing them
	GetAll() []QueuedMessage
}

type MessageQueuedEvent struct {
	RequestID string
	Timestamp time.Time
	Message   sdk.Message
}

type MessageReceivedEvent struct {
	Message sdk.Message
}

type MessageRepository interface {
	AddMessage(msg ConversationEntry) error
	GetMessages() []ConversationEntry
	Clear() error
	ClearExceptFirstUserMessage() error
	GetMessageCount() int
	UpdateLastMessage(content string) error
	UpdateLastMessageToolCalls(toolCalls *[]sdk.ChatCompletionMessageToolCall) error
	DeleteMessagesAfterIndex(index int) error
}

type MessageSnapshot struct {
	Index        int             `json:"index"`
	Role         sdk.MessageRole `json:"role"`
	Content      string          `json:"content"`
	Timestamp    time.Time       `json:"timestamp"`
	TruncatedMsg string          `json:"truncated_msg"`
}

type ModelCostStats struct {
	Model        string
	InputTokens  int
	OutputTokens int
	InputCost    float64
	OutputCost   float64
	TotalCost    float64
	RequestCount int
}

type ModelSelectedEvent struct {
	Model string
}

type ModelService interface {
	ListModels(ctx context.Context) ([]string, error)
	SelectModel(modelID string) error
	GetCurrentModel() string
	IsModelAvailable(modelID string) bool
	ValidateModel(modelID string) error
}

type MouseClickToolResult struct {
	Button  string `json:"button"`
	Clicks  int    `json:"clicks"`
	X       int    `json:"x"`
	Y       int    `json:"y"`
	Display string `json:"display"`
	Method  string `json:"method"`
}

type MouseMoveToolResult struct {
	FromX   int    `json:"from_x"`
	FromY   int    `json:"from_y"`
	ToX     int    `json:"to_x"`
	ToY     int    `json:"to_y"`
	Display string `json:"display"`
	Method  string `json:"method"`
}

type MoveIndicatorEvent struct {
	BaseChatEvent
	FromX         int  `json:"FromX"`
	FromY         int  `json:"FromY"`
	ToX           int  `json:"ToX"`
	ToY           int  `json:"ToY"`
	MoveIndicator bool `json:"MoveIndicator"`
}

type MultiEditToolResult struct {
	FilePath        string                `json:"file_path"`
	Edits           []EditOperationResult `json:"edits"`
	TotalEdits      int                   `json:"total_edits"`
	SuccessfulEdits int                   `json:"successful_edits"`
	FileModified    bool                  `json:"file_modified"`
	OriginalSize    int64                 `json:"original_size"`
	NewSize         int64                 `json:"new_size"`
	BytesDifference int64                 `json:"bytes_difference"`
	NormalizedEdits int                   `json:"normalized_edits,omitempty"`
}