domain

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

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

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 A2ATaskStatusUpdate struct {
	TaskID    string
	AgentURL  string
	State     string
	Message   string
	Timestamp time.Time
}

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

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

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

type AgentErrorEvent struct {
	AgentName string
	Error     error
}

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))
}

type AgentMode int

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 AgentReadyEvent struct {
	AgentName   string
	ReadyAgents int
	TotalAgents int
}

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
}

type AgentState int

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

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

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

type ApprovalAction int

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 ApprovalUIState struct {
	SelectedIndex   int                                `json:"selected_index"`
	PendingToolCall *sdk.ChatCompletionMessageToolCall `json:"pending_tool_call"`
	ResponseChan    chan ApprovalAction                `json:"-"`
}

type AutocompleteCompleteEvent struct {
	Completion         string
	ExecuteImmediately bool
}

type AutocompleteHideEvent struct{}

type AutocompleteUpdateEvent struct {
	Text      string
	CursorPos int
}

type AutocompleteVisibilityCheckEvent struct {
	ResponseChan chan bool
}

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
}

type BackgroundShellRequestEvent struct{}

type BackgroundShellService interface {
	// DetachToBackground moves a running command to background
	DetachToBackground(ctx context.Context, cmd *exec.Cmd, command string, outputBuffer OutputRingBuffer) (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 BackgroundTaskService interface {
	// GetBackgroundTasks returns all current background polling tasks
	GetBackgroundTasks() []TaskPollingState

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

type BaseChatEvent struct {
	RequestID string
	Timestamp time.Time
}

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

type BashCommandCompletedEvent struct {
	History []ConversationEntry
}

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

type BashOutputCallback func(line 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 CancelledEvent struct {
	RequestID string
	Timestamp time.Time
	Reason    string
}

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
}

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

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

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
}

type ChatSessionSnapshot struct {
	RequestID    string    `json:"request_id"`
	Status       string    `json:"status"`
	Model        string    `json:"model"`
	StartTime    time.Time `json:"start_time"`
	IsFirstChunk bool      `json:"is_first_chunk"`
	HasToolCalls bool      `json:"has_tool_calls"`
	LastActivity time.Time `json:"last_activity"`
}

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"`
	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 ComputerUsePauseRequestedEvent struct {
	RequestID string
	Timestamp time.Time
}

type ComputerUsePausedEvent struct {
	RequestID string
	Timestamp time.Time
}

type ComputerUseResumeRequestedEvent struct {
	RequestID string
	Timestamp time.Time
}

type ComputerUseResumedEvent struct {
	RequestID string
	Timestamp time.Time
}

type ComputerUseScreenshotEvent struct {
	RequestID string
	Timestamp time.Time
	Width     int
	Height    int
	Region    *ScreenRegion
	ImageData string
}

type ConfigService interface {
	// Tool approval configuration
	IsApprovalRequired(toolName string) bool
	IsBashCommandWhitelisted(command string) bool

	// Debug and output configuration
	GetOutputDirectory() string

	// Gateway configuration
	GetGatewayURL() string
	GetAPIKey() string
	GetTimeout() int

	// Chat configuration
	GetAgentConfig() *config.AgentConfig

	// Sandbox configuration
	GetSandboxDirectories() []string
	GetProtectedPaths() []string

	// Full configuration access
	GetConfig() *config.Config
}

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
	PullImage(ctx context.Context, image string) 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 ConversationOptimizer interface {
	OptimizeMessages(messages []sdk.Message, model string, force bool) []sdk.Message
}

type ConversationRepository interface {
	AddMessage(msg ConversationEntry) error
	GetMessages() []ConversationEntry
	Clear() error
	ClearExceptFirstUserMessage() error
	Export(format ExportFormat) ([]byte, error)
	GetMessageCount() int
	UpdateLastMessage(content string) error
	UpdateLastMessageToolCalls(toolCalls *[]sdk.ChatCompletionMessageToolCall) error
	AddTokenUsage(model string, inputTokens, outputTokens, totalTokens int) error
	GetSessionTokens() SessionTokenStats
	GetSessionCostStats() SessionCostStats
	FormatToolResultForLLM(result *ToolExecutionResult) string
	FormatToolResultForUI(result *ToolExecutionResult, terminalWidth int) string
	FormatToolResultExpanded(result *ToolExecutionResult, terminalWidth int) string
	RemovePendingToolCallByID(toolCallID string)
	StartNewConversation(title string) error
	DeleteMessagesAfterIndex(index int) error
	GetCurrentConversationTitle() string
}

type ConversationSelectedEvent struct {
	ConversationID string
}

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 DraculaTheme 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"`
}

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

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 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 FileSelectedEvent struct {
	FilePath string
}

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 FocusRequestEvent struct {
	ComponentID string
}

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 GitHubBranch struct {
	Label string           `json:"label"`
	Ref   string           `json:"ref"`
	SHA   string           `json:"sha"`
	User  GitHubUser       `json:"user"`
	Repo  GitHubRepository `json:"repo"`
}

type GitHubComment struct {
	ID        int        `json:"id"`
	Body      string     `json:"body"`
	User      GitHubUser `json:"user"`
	CreatedAt time.Time  `json:"created_at"`
	UpdatedAt time.Time  `json:"updated_at"`
	HTMLURL   string     `json:"html_url"`
}

type GitHubError struct {
	Message          string `json:"message"`
	DocumentationURL string `json:"documentation_url,omitempty"`
}

type GitHubIssue struct {
	ID          int              `json:"id"`
	Number      int              `json:"number"`
	Title       string           `json:"title"`
	Body        string           `json:"body"`
	State       string           `json:"state"`
	User        GitHubUser       `json:"user"`
	Assignees   []GitHubUser     `json:"assignees,omitempty"`
	Labels      []GitHubLabel    `json:"labels,omitempty"`
	Milestone   *GitHubMilestone `json:"milestone,omitempty"`
	Comments    int              `json:"comments"`
	CreatedAt   time.Time        `json:"created_at"`
	UpdatedAt   time.Time        `json:"updated_at"`
	ClosedAt    *time.Time       `json:"closed_at,omitempty"`
	HTMLURL     string           `json:"html_url"`
	PullRequest *struct {
		URL      string `json:"url"`
		HTMLURL  string `json:"html_url"`
		DiffURL  string `json:"diff_url"`
		PatchURL string `json:"patch_url"`
	} `json:"pull_request,omitempty"`
}

type GitHubLabel struct {
	ID          int    `json:"id"`
	Name        string `json:"name"`
	Color       string `json:"color"`
	Description string `json:"description,omitempty"`
}

type GitHubMilestone struct {
	ID          int        `json:"id"`
	Number      int        `json:"number"`
	Title       string     `json:"title"`
	Description string     `json:"description,omitempty"`
	State       string     `json:"state"`
	DueOn       *time.Time `json:"due_on,omitempty"`
	CreatedAt   time.Time  `json:"created_at"`
	UpdatedAt   time.Time  `json:"updated_at"`
}

type GitHubPullRequest struct {
	ID           int              `json:"id"`
	Number       int              `json:"number"`
	Title        string           `json:"title"`
	Body         string           `json:"body"`
	State        string           `json:"state"`
	User         GitHubUser       `json:"user"`
	Assignees    []GitHubUser     `json:"assignees,omitempty"`
	Labels       []GitHubLabel    `json:"labels,omitempty"`
	Milestone    *GitHubMilestone `json:"milestone,omitempty"`
	Comments     int              `json:"comments"`
	Commits      int              `json:"commits"`
	Additions    int              `json:"additions"`
	Deletions    int              `json:"deletions"`
	ChangedFiles int              `json:"changed_files"`
	CreatedAt    time.Time        `json:"created_at"`
	UpdatedAt    time.Time        `json:"updated_at"`
	ClosedAt     *time.Time       `json:"closed_at,omitempty"`
	MergedAt     *time.Time       `json:"merged_at,omitempty"`
	Merged       bool             `json:"merged"`
	Mergeable    *bool            `json:"mergeable,omitempty"`
	Head         GitHubBranch     `json:"head"`
	Base         GitHubBranch     `json:"base"`
	HTMLURL      string           `json:"html_url"`
	DiffURL      string           `json:"diff_url"`
	PatchURL     string           `json:"patch_url"`
}

type GitHubRepository struct {
	ID       int        `json:"id"`
	Name     string     `json:"name"`
	FullName string     `json:"full_name"`
	Owner    GitHubUser `json:"owner"`
	Private  bool       `json:"private"`
	HTMLURL  string     `json:"html_url"`
	CloneURL string     `json:"clone_url"`
}

type GitHubUser struct {
	ID        int    `json:"id"`
	Login     string `json:"login"`
	AvatarURL string `json:"avatar_url"`
	HTMLURL   string `json:"html_url"`
	Type      string `json:"type"`
}

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 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 InitializeA2ATaskManagementEvent struct{}

type InitializeConversationSelectionEvent struct{}

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

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

	// StartMonitoring begins background health monitoring and returns a channel for status updates
	StartMonitoring(ctx context.Context) <-chan MCPServerStatusUpdateEvent

	// 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 Message = sdk.Message

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 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
	IsVisionModel(modelID string) bool
}

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

type NavigateBackInTimeEvent struct {
	RequestID string
	Timestamp time.Time
}

type OptimizationStatusEvent struct {
	RequestID      string
	Timestamp      time.Time
	Message        string
	IsActive       bool
	OriginalCount  int
	OptimizedCount int
}

type OutputRingBuffer interface {
	Write(p []byte) (n int, err error)
	ReadFrom(offset int64) (string, int64)
	Recent(maxBytes int) string
	TotalWritten() int64
	Size() int
	String() string
	Clear()
}

type PlanApprovalAction int

type PlanApprovalRequestedEvent struct {
	RequestID    string
	Timestamp    time.Time
	PlanContent  string
	ResponseChan chan PlanApprovalAction `json:"-"`
}

type PlanApprovalResponseEvent struct {
	Action PlanApprovalAction
}

type PlanApprovalStatus int

type PlanApprovalUIState struct {
	SelectedIndex int                     `json:"selected_index"`
	PlanContent   string                  `json:"plan_content"`
	ResponseChan  chan PlanApprovalAction `json:"-"`
}

type PlanApprovedAndAutoAcceptEvent struct {
	RequestID string
	Timestamp time.Time
}

type PlanApprovedEvent struct {
	RequestID string
	Timestamp time.Time
}

type PlanRejectedEvent struct {
	RequestID string
	Timestamp time.Time
}

type PricingService interface {
	// IsEnabled returns whether pricing is enabled in the configuration.
	IsEnabled() bool

	// GetInputPrice retrieves the input price per million tokens for a specific model.
	// Returns 0.0 for unknown models (e.g., Ollama, custom models).
	GetInputPrice(model string) float64

	// GetOutputPrice retrieves the output price per million tokens for a specific model.
	// Returns 0.0 for unknown models (e.g., Ollama, custom models).
	GetOutputPrice(model string) float64

	// CalculateCost computes the total cost for a given number of input and output tokens.
	CalculateCost(model string, inputTokens, outputTokens int) (inputCost, outputCost, totalCost float64)

	// FormatModelPricing returns a formatted string describing the model's pricing.
	// Returns empty string if pricing is disabled.
	// Returns "free" if both input and output prices are 0.0.
	// Returns "$X.XX/$Y.YY per MTok" for paid models.
	FormatModelPricing(model string) string
}

type QueuedMessage struct {
	Message   sdk.Message
	QueuedAt  time.Time
	RequestID string
}

type RateLimiter interface {
	// CheckAndRecord checks if the action is within rate limits and records it
	CheckAndRecord(toolName string) error
	// GetCurrentCount returns the number of actions in the current window
	GetCurrentCount() int
	// Reset clears all recorded actions
	Reset()
}

type RefreshAutocompleteEvent struct{}

type ResizeEvent struct {
	Width  int
	Height int
}

type RunContainerOptions struct {
	Name         string
	Image        string
	Network      string
	Ports        []string // Format: "host:container" or "host:container/protocol"
	Environment  map[string]string
	Volumes      []string // Format: "host:container" or "host:container:mode"
	Entrypoint   []string
	Command      []string
	Args         []string
	HealthCmd    string
	HealthConfig *HealthCheckConfig
	RemoveOnExit bool
	Detached     bool
	EnvFile      string // Optional .env file path
}

type SDKClient interface {
	WithOptions(opts *sdk.CreateChatCompletionRequest) SDKClient
	WithMiddlewareOptions(opts *sdk.MiddlewareOptions) SDKClient
	WithTools(tools *[]sdk.ChatCompletionTool) SDKClient
	GenerateContent(ctx context.Context, provider sdk.Provider, model string, messages []sdk.Message) (*sdk.CreateChatCompletionResponse, error)
	GenerateContentStream(ctx context.Context, provider sdk.Provider, model string, messages []sdk.Message) (<-chan sdk.SSEvent, error)
}

type ScreenRegion struct {
	X      int `json:"x"`
	Y      int `json:"y"`
	Width  int `json:"width"`
	Height int `json:"height"`
}

type Screenshot struct {
	ID             string    `json:"id"`
	Timestamp      time.Time `json:"timestamp"`
	Data           string    `json:"data"`            // base64 encoded image
	Width          int       `json:"width"`           // Final image width (after scaling)
	Height         int       `json:"height"`          // Final image height (after scaling)
	Format         string    `json:"format"`          // "png" or "jpeg"
	Method         string    `json:"method"`          // "x11" or "wayland"
	OriginalWidth  int       `json:"original_width"`  // Screen width before scaling
	OriginalHeight int       `json:"original_height"` // Screen height before scaling
}

type ScreenshotProvider interface {
	GetLatestScreenshot() (*Screenshot, error)
}

type ScreenshotToolResult struct {
	Display string        `json:"display"`
	Region  *ScreenRegion `json:"region,omitempty"`
	Width   int           `json:"width"`
	Height  int           `json:"height"`
	Format  string        `json:"format"`
	Method  string        `json:"method"`
}

type ScrollDirection int

type ScrollRequestEvent struct {
	ComponentID string
	Direction   ScrollDirection
	Amount      int
}

type SessionCostStats struct {
	TotalCost       float64
	TotalInputCost  float64
	TotalOutputCost float64
	PerModelStats   map[string]*ModelCostStats // keyed by model name
	Currency        string
}

type SessionID string

type SessionTokenStats struct {
	TotalInputTokens  int `json:"total_input_tokens"`
	TotalOutputTokens int `json:"total_output_tokens"`
	TotalTokens       int `json:"total_tokens"`
	RequestCount      int `json:"request_count"`
	LastInputTokens   int `json:"last_input_tokens"`
}

type SetInputEvent struct {
	Text string
}

type SetStatusEvent struct {
	Message    string
	Spinner    bool
	StatusType StatusType
	Progress   *StatusProgress
	ToolName   string
}

type SetupFileSelectionEvent struct {
	Files []string
}

type ShellCancelledEvent struct {
	RequestID string
	Timestamp time.Time
	ShellID   string
}

type ShellCompletedEvent struct {
	RequestID string
	Timestamp time.Time
	ShellID   string
	ExitCode  int
	Duration  time.Duration
}

type ShellDetachedEvent struct {
	RequestID string
	Timestamp time.Time
	ShellID   string
	Command   string
}

type ShellFailedEvent struct {
	RequestID string
	Timestamp time.Time
	ShellID   string
	Error     string
	ExitCode  int
}

type ShellInfo struct {
	ShellID     string
	Command     string
	State       ShellState
	StartedAt   time.Time
	CompletedAt *time.Time
	ExitCode    *int
	OutputSize  int64
	Elapsed     time.Duration
}

type ShellOutputUpdateEvent struct {
	RequestID  string
	Timestamp  time.Time
	ShellID    string
	NewOutput  string
	TotalBytes int64
}

type ShellState string

type ShellTracker interface {
	// Add adds a new shell to the tracker.
	// Returns an error if max concurrent limit is reached.
	Add(shell *BackgroundShell) error

	// Get retrieves a shell by ID.
	// Returns nil if not found.
	Get(shellID string) *BackgroundShell

	// GetAll returns all tracked shells.
	GetAll() []*BackgroundShell

	// Remove removes a shell from the tracker.
	Remove(shellID string) error

	// Cleanup removes shells in terminal states older than the specified duration.
	Cleanup(olderThan time.Duration) int

	// Count returns the number of tracked shells.
	Count() int

	// CountRunning returns the number of shells in running state.
	CountRunning() int
}

type ShowErrorEvent struct {
	Error  string
	Sticky bool // Whether error persists until dismissed
}

type ShowPlanApprovalEvent struct {
	PlanContent  string
	ResponseChan chan PlanApprovalAction
}

type StateManager interface {
	// View state management
	GetCurrentView() ViewState
	GetPreviousView() ViewState
	TransitionToView(newView ViewState) error

	// Agent mode management
	GetAgentMode() AgentMode
	SetAgentMode(mode AgentMode)
	CycleAgentMode() AgentMode

	// Chat session management
	SetChatPending()
	StartChatSession(requestID, model string, eventChan <-chan ChatEvent) error
	UpdateChatStatus(status ChatStatus) error
	EndChatSession()
	GetChatSession() *ChatSession
	IsAgentBusy() bool

	// Event multicast for floating window
	SetEventBridge(bridge EventBridge)
	GetEventBridge() EventBridge
	BroadcastEvent(event ChatEvent)

	// Tool execution management
	StartToolExecution(toolCalls []sdk.ChatCompletionMessageToolCall) error
	CompleteCurrentTool(result *ToolExecutionResult) error
	FailCurrentTool(result *ToolExecutionResult) error
	EndToolExecution()
	GetToolExecution() *ToolExecutionSession

	// Dimensions management
	SetDimensions(width, height int)
	GetDimensions() (int, int)

	// File selection management
	SetupFileSelection(files []string)
	GetFileSelectionState() *FileSelectionState
	UpdateFileSearchQuery(query string)
	SetFileSelectedIndex(index int)
	ClearFileSelectionState()

	// Approval management
	SetupApprovalUIState(toolCall *sdk.ChatCompletionMessageToolCall, responseChan chan ApprovalAction)
	GetApprovalUIState() *ApprovalUIState
	SetApprovalSelectedIndex(index int)
	ClearApprovalUIState()

	// Plan approval management
	SetupPlanApprovalUIState(planContent string, responseChan chan PlanApprovalAction)
	GetPlanApprovalUIState() *PlanApprovalUIState
	SetPlanApprovalSelectedIndex(index int)
	ClearPlanApprovalUIState()

	// Todo management
	SetTodos(todos []TodoItem)
	GetTodos() []TodoItem

	// Agent readiness management
	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)

	// Message edit state management
	SetMessageEditState(state *MessageEditState)
	GetMessageEditState() *MessageEditState
	ClearMessageEditState()
	IsEditingMessage() bool

	// Focus management (macOS computer-use tools)
	SetLastFocusedApp(appID string)
	GetLastFocusedApp() string
	ClearLastFocusedApp()
	SetLastClickCoordinates(x, y int)
	GetLastClickCoordinates() (x, y int)
	ClearLastClickCoordinates()

	// Computer Use Pause State
	SetComputerUsePaused(paused bool, requestID string)
	IsComputerUsePaused() bool
	GetPausedRequestID() string
	ClearComputerUsePauseState()
}

type StateSnapshot struct {
	CurrentView   string                 `json:"current_view"`
	PreviousView  string                 `json:"previous_view"`
	Width         int                    `json:"width"`
	Height        int                    `json:"height"`
	DebugMode     bool                   `json:"debug_mode"`
	Timestamp     time.Time              `json:"timestamp"`
	ChatSession   *ChatSessionSnapshot   `json:"chat_session,omitempty"`
	ToolExecution *ToolExecutionSnapshot `json:"tool_execution,omitempty"`
}

type StatusProgress struct {
	Current int
	Total   int
}

type StatusType int

type StreamingContentEvent struct {
	RequestID        string
	Content          string
	ReasoningContent string
	Delta            bool
	Model            string
}

type TaskCancelledEvent struct {
	TaskID string
	Error  error
}

type TaskInfo struct {
	// ADK Task contains: ID, ContextID, Status (with State), History, Artifacts, Metadata
	Task adk.Task

	// UI-specific fields
	AgentURL    string
	StartedAt   time.Time
	CompletedAt time.Time
}

type TaskPollingState struct {
	TaskID          string
	ContextID       string
	AgentURL        string
	TaskDescription string
	IsPolling       bool
	StartedAt       time.Time
	LastPollAt      time.Time
	NextPollTime    time.Time
	CurrentInterval time.Duration
	LastKnownState  string
	CancelFunc      context.CancelFunc
	ResultChan      chan *ToolExecutionResult
	ErrorChan       chan error
	StatusChan      chan *A2ATaskStatusUpdate
}

type TaskRetentionService interface {
	// AddTask adds a terminal task (completed, failed, canceled, etc.) to retention
	AddTask(task TaskInfo)

	// GetTasks returns all retained tasks
	GetTasks() []TaskInfo

	// Clear removes all retained tasks
	Clear()

	// SetMaxRetention updates the maximum retention count
	SetMaxRetention(maxRetention int)

	// GetMaxRetention returns the current maximum retention count
	GetMaxRetention() int
}

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

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

	// Agent management
	GetAllAgents() []string
	GetAllContexts() []string
	ClearAllAgents()

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

type TasksLoadedEvent struct {
	ActiveTasks    []any
	CompletedTasks []any
	Error          error
}

type Theme interface {
	GetUserColor() string
	GetAssistantColor() string
	GetErrorColor() string
	GetSuccessColor() string
	GetStatusColor() string
	GetAccentColor() string
	GetDimColor() string
	GetBorderColor() string
	GetDiffAddColor() string
	GetDiffRemoveColor() string
}