tui

type A2ATaskCoordinator ¶

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

A2ATaskCoordinator owns the UI side of A2A (agent-to-agent) task lifecycle events. It translates the six A2A event types into status updates, streaming-content events, and conversation-history refreshes, and keeps the chat session listener pumping. Self-contained - depends only on the conversation repo, task retention, the chat state manager, and a chat event listener.

type AgentReadinessState ¶

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

AgentReadinessState represents the current state of A2A agents during startup

type AgentStatus ¶

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

AgentStatus represents the status of an individual A2A agent

type AgentStatusUpdateEvent ¶

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

AgentStatusUpdateEvent indicates an agent's status has changed

type ApplicationState ¶

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

ApplicationState represents the overall application state with proper typing

func NewApplicationState() *ApplicationState

func (s *ApplicationState) AddQueuedMessage(message sdk.Message, requestID string)

func (s *ApplicationState) AreAllAgentsReady() bool

func (s *ApplicationState) ClearAgentReadiness()

func (s *ApplicationState) ClearApprovalUIState()

func (s *ApplicationState) ClearComputerUsePauseState()

func (s *ApplicationState) ClearFileSelectionState()

func (s *ApplicationState) ClearLastClickCoordinates()

func (s *ApplicationState) ClearLastFocusedApp()

func (s *ApplicationState) ClearMessageEditState()

func (s *ApplicationState) ClearPlanApprovalUIState()

func (s *ApplicationState) ClearQueuedMessages()

func (s *ApplicationState) ClearUserQuestionUIState()

func (s *ApplicationState) CompleteCurrentTool(result *agentdomain.ToolExecutionResult) error

func (s *ApplicationState) CycleAgentMode() agentdomain.AgentMode

func (s *ApplicationState) EndChatSession()

func (s *ApplicationState) EndToolExecution()

func (s *ApplicationState) FailCurrentTool(result *agentdomain.ToolExecutionResult) error

func (s *ApplicationState) GetAgentMode() agentdomain.AgentMode

func (s *ApplicationState) GetAgentReadiness() *AgentReadinessState

func (s *ApplicationState) GetApprovalUIState() *agentdomain.ApprovalUIState

func (s *ApplicationState) GetChatSession() *agentdomain.ChatSession

func (s *ApplicationState) GetCurrentView() ViewState

func (s *ApplicationState) GetDimensions() (int, int)

func (s *ApplicationState) GetFileSelectionState() *FileSelectionState

func (s *ApplicationState) GetLastClickCoordinates() (x, y int)

func (s *ApplicationState) GetLastFocusedApp() string

func (s *ApplicationState) GetMessageEditState() *MessageEditState

func (s *ApplicationState) GetPausedRequestID() string

func (s *ApplicationState) GetPlanApprovalUIState() *agentdomain.PlanApprovalUIState

func (s *ApplicationState) GetPreviousView() ViewState

func (s *ApplicationState) GetQueuedMessages() []convdomain.QueuedMessage

func (s *ApplicationState) GetRetryStatus() *agentdomain.RetryStatus

func (s *ApplicationState) GetTodos() []agentdomain.TodoItem

func (s *ApplicationState) GetToolExecution() *agentdomain.ToolExecutionSession

func (s *ApplicationState) GetUserQuestionUIState() *agentdomain.UserQuestionUIState

func (s *ApplicationState) InitializeAgentReadiness(totalAgents int)

func (s *ApplicationState) IsComputerUsePaused() bool

func (s *ApplicationState) IsDebugMode() bool

func (s *ApplicationState) IsEditingMessage() bool

func (s *ApplicationState) PopQueuedMessage() *convdomain.QueuedMessage

func (s *ApplicationState) RemoveAgent(name string)

func (s *ApplicationState) SetAgentError(name string, err error)

func (s *ApplicationState) SetAgentMode(mode agentdomain.AgentMode)

func (s *ApplicationState) SetChatPending()

func (s *ApplicationState) SetComputerUsePaused(paused bool, requestID string)

func (s *ApplicationState) SetDebugMode(enabled bool)

func (s *ApplicationState) SetDimensions(width, height int)

func (s *ApplicationState) SetFileSelectedIndex(index int)

func (s *ApplicationState) SetLastClickCoordinates(x, y int)

func (s *ApplicationState) SetLastFocusedApp(appID string)

func (s *ApplicationState) SetMessageEditState(state *MessageEditState)

func (s *ApplicationState) SetPlanApprovalSelectedIndex(index int)

func (s *ApplicationState) SetRetryStatus(status *agentdomain.RetryStatus)

func (s *ApplicationState) SetTodos(todos []agentdomain.TodoItem)

func (s *ApplicationState) SetupApprovalUIState(toolCall *sdk.ChatCompletionMessageToolCall, responseChan chan agentdomain.ApprovalAction)

func (s *ApplicationState) SetupFileSelection(files []string)

func (s *ApplicationState) SetupPlanApprovalUIState(planContent, planID string, responseChan chan agentdomain.PlanApprovalAction)

func (s *ApplicationState) SetupUserQuestionUIState(questions []agentdomain.UserQuestion, responseChan chan []agentdomain.UserQuestionAnswer)

func (s *ApplicationState) StartChatSession(requestID, model string, eventChan <-chan agentdomain.ChatEvent)

func (s *ApplicationState) StartToolExecution(tools []agentdomain.ToolCall)

func (s *ApplicationState) TouchChatActivity()

func (s *ApplicationState) TransitionToView(newView ViewState) error

func (s *ApplicationState) UpdateAgentPullProgress(name string, done, total int)

func (s *ApplicationState) UpdateAgentStatus(name string, state agentdomain.AgentState, message string, url string, image string)

func (s *ApplicationState) UpdateChatStatus(status agentdomain.ChatStatus) error

func (s *ApplicationState) UpdateFileSearchQuery(query string)

type ApprovalCoordinator ¶

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

ApprovalCoordinator owns the "pause the assistant turn pending external decision" family of events: plan approval (the agent stops, presents a plan, awaits user accept/reject) and computer-use pause/resume (the user hits a key to interrupt computer-use execution and later resumes).

Response handlers return a restart bool so the orchestrator can fire ChatCompletionRunner.Start() after the cmds without ApprovalCoordinator having to depend on the runner.

type AutocompleteCompleteEvent ¶

type AutocompleteCompleteEvent struct {
	Completion string
	CursorPos  int
}

AutocompleteCompleteEvent is fired when a completion is selected

type AutocompleteComponent ¶

type AutocompleteComponent interface {
	Update(inputText string, cursorPos int)
	HandleKey(key tea.KeyPressMsg) (bool, string)
	IsVisible() bool
	SetWidth(width int)
	SetHeight(height int)
	Render() string
	GetSelectedShortcut() string
	GetCompletionCursorPos() int
	Hide()
	RefreshToolsList()
	GetUsageHint() string
	ClearUsageHint()
}

AutocompleteComponent defines the interface for autocomplete functionality

type AutocompleteHideEvent ¶

type AutocompleteHideEvent struct{}

AutocompleteHideEvent is fired when autocomplete should be hidden

type AutocompleteUpdateEvent ¶

type AutocompleteUpdateEvent struct {
	Text      string
	CursorPos int
}

AutocompleteUpdateEvent is fired when input text changes and autocomplete should update

type BashCommandCompletedEvent ¶

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

BashCommandCompletedEvent indicates a direct bash command (! prefix) has completed

type ChatCompletionRunner ¶

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

ChatCompletionRunner owns the LLM streaming lifecycle - initiating streaming, translating chat-start / chat-chunk / chat-complete / chat-error events into UI state transitions, and handling the model-restoration side effect after a temporary /model switch.

Start takes a BashDetachChannelHolder because the agent core needs that narrow interface attached to its context when launching tools that may require backgrounding. In #529 commit 3 that holder is the orchestrator itself; in commit 4 it becomes the DirectExecutionService.

type ChatEventListener ¶

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

ChatEventListener wraps the small "read one message off a channel as a tea.Cmd" pattern used throughout the handlers. Extracted so services can chain channel reads back into the Bubble Tea event loop without each one re-implementing the same closure.

type ChatHandler ¶

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 agentdomain.UserInputEvent) tea.Cmd
	HandleFileSelectionRequestEvent(msg FileSelectionRequestEvent) tea.Cmd
	HandleConversationSelectedEvent(msg ConversationSelectedEvent) tea.Cmd
	HandleToolApprovalRequestedEvent(msg agentdomain.ToolApprovalRequestedEvent) tea.Cmd
	HandleToolApprovalResponseEvent(msg agentdomain.ToolApprovalResponseEvent) tea.Cmd
	HandlePlanApprovalRequestedEvent(msg agentdomain.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 agentdomain.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()
}

ChatHandler defines the interface for the chat handler This interface enables testing handlers in isolation and provides a clear contract

type ClearErrorEvent ¶

type ClearErrorEvent struct{}

ClearErrorEvent clears any displayed error

type ClearInputEvent ¶

type ClearInputEvent struct{}

ClearInputEvent clears the input field

type ConversationRenderer ¶

type ConversationRenderer interface {
	SetConversation([]convdomain.ConversationEntry)
	GetScrollOffset() int
	CanScrollUp() bool
	CanScrollDown() bool
	ToggleToolResultExpansion(index int)
	ToggleAllToolResultsExpansion()
	IsToolResultExpanded(index int) bool
	ToggleAllThinkingExpansion()
	IsThinkingExpanded(index int) bool
	ToggleRawFormat()
	IsRawFormat() bool
	ResetUserScroll()
	SetWidth(width int)
	SetHeight(height int)
	Render() string
}

ConversationRenderer interface for conversation display

type ConversationSelectedEvent ¶

type ConversationSelectedEvent struct {
	ConversationID string
}

ConversationSelectedEvent indicates conversation selection

type ConversationsLoadedEvent ¶

type ConversationsLoadedEvent struct {
	Conversations []any
	Error         error
}

ConversationsLoadedEvent indicates conversations have been loaded

type DebugKeyEvent ¶

type DebugKeyEvent struct {
	Key     string
	Handler string
}

DebugKeyEvent provides debug information about key presses

type DefaultTheme ¶

type DefaultTheme struct{}

DefaultTheme provides a concrete implementation of the Theme interface

func NewDefaultTheme() *DefaultTheme

func (t *DefaultTheme) GetAccentColor() string

func (t *DefaultTheme) GetAssistantColor() string

func (t *DefaultTheme) GetBorderColor() string

func (t *DefaultTheme) GetDiffAddColor() string

func (t *DefaultTheme) GetDiffRemoveColor() string

func (t *DefaultTheme) GetDimColor() string

func (t *DefaultTheme) GetErrorColor() string

func (t *DefaultTheme) GetStatusColor() string

func (t *DefaultTheme) GetSuccessColor() string

func (t *DefaultTheme) GetUserColor() string

type DirectExecutionService ¶

type DirectExecutionService interface {
	agentdomain.BashDetachChannelHolder

	HandleBashCommand(commandText string) tea.Cmd
	HandleToolCommand(commandText string) tea.Cmd
	HandleBackgroundShellRequest() tea.Cmd
	HandleBashOutputChunk(msg agentdomain.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
}

DirectExecutionService owns user-typed `!command` (bash) and `!!Tool(...)` (tool) execution. It synthesizes the conversation entries, spawns the async goroutines, owns the per-call event/detach channels, and exposes the channels via PendingBashChannel / PendingToolChannel so the ToolExecutionCoordinator can keep pumping them.

Implements BashDetachChannelHolder so the agent core can find it on the request context (see WithChatHandler / GetChatHandler in context_helpers.go).

type DrainQueueRetryEvent ¶

type DrainQueueRetryEvent struct{}

DrainQueueRetryEvent is the bounded retry behind DrainQueueEvent, and is NOT a clock. A DrainQueueEvent can land while the agent is momentarily busy (e.g. a background job finishes in the same instant the turn is still completing); the gate drops it, so without a retry the queue would strand. HandleDrainQueueEvent arms a single DrainQueueRetryEvent in that case, and the drainRetryArmed guard keeps it to exactly one outstanding timer no matter how many DrainQueueEvents arrived. When it fires, HandleDrainQueueRetryEvent re-runs the gate, which re-arms only while work is still stranded and stops the moment the queue drains.

type FileSelectionRequestEvent ¶

type FileSelectionRequestEvent struct{}

FileSelectionRequestEvent requests file selection UI

type FileSelectionState ¶

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

FileSelectionState represents the state of file selection UI

type FocusStatusBarEvent ¶

type FocusStatusBarEvent struct{}

FocusStatusBarEvent moves keyboard focus to the status-indicator row below the input, fired when arrow-down would otherwise be a no-op

type GitPRResolvedEvent ¶

type GitPRResolvedEvent struct {
	PR string
}

GitPRResolvedEvent carries the PR number for the current branch, resolved asynchronously by the input view's fetch command. An empty PR means no PR exists (or gh is unavailable). Defined here rather than as a component-local msg because the chat application only routes domain-prefixed messages to UI components.

type HelpBarComponent ¶

type HelpBarComponent interface {
	SetShortcuts(shortcuts []key.Binding)
	IsEnabled() bool
	SetEnabled(enabled bool)
	SetWidth(width int)
	SetHeight(height int)
	Render() string
}

HelpBarComponent interface for help bar

type HideHelpBarEvent ¶

type HideHelpBarEvent struct{}

HideHelpBarEvent hides the help bar when typing other characters

type InputComponent ¶

type InputComponent interface {
	GetInput() string
	ClearInput()
	SetPlaceholder(text string)
	GetCursor() int
	SetCursor(position int)
	SetText(text string)
	SetWidth(width int)
	SetHeight(height int)
	Render() string
	HandleKey(key tea.KeyPressMsg) (tea.Model, tea.Cmd)
	CanHandle(key tea.KeyPressMsg) bool
	NavigateHistoryUp()
	NavigateHistoryDown()
	IsNavigatingHistory() bool
	AddImageAttachment(image agentdomain.ImageAttachment)
	GetImageAttachments() []agentdomain.ImageAttachment
	ClearImageAttachments()
	AddToHistory(text string) error
	SetUsageHint(hint string)
	GetUsageHint() string
	IsDisabled() bool
}

InputComponent interface for input handling

type InputStatusBarComponent ¶

type InputStatusBarComponent interface {
	SetWidth(width int)
	SetHeight(height int)
	SetInputText(text string)
	UpdateMCPStatus(status *agentdomain.MCPServerStatus)
	Focus() bool
	Blur()
	IsFocused() bool
	SelectNext()
	SelectPrev()
	SelectedAction() StatusIndicatorAction
	Render() string
}

InputStatusBarComponent interface for input status bar

type KeyShortcut ¶

type KeyShortcut struct {
	Key         string
	Description string
}

KeyShortcut represents a keyboard shortcut with description

type MessageEditState ¶

type MessageEditState struct {
	OriginalMessageIndex int `json:"original_message_index"`
}

MessageEditState represents the state when editing a message

type MessageHistoryEditEvent ¶

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

MessageHistoryEditEvent is emitted when user wants to edit a selected message

func (e MessageHistoryEditEvent) GetRequestID() string

func (e MessageHistoryEditEvent) GetTimestamp() time.Time

type MessageHistoryEditReadyEvent ¶

type MessageHistoryEditReadyEvent struct {
	MessageIndex int
	Content      string
	Snapshot     MessageSnapshot
}

MessageHistoryEditReadyEvent indicates editing is ready to begin

type MessageHistoryReadyEvent ¶

type MessageHistoryReadyEvent struct {
	Messages []MessageSnapshot
}

MessageHistoryReadyEvent indicates message history has been loaded and is ready to display

type MessageSnapshot ¶

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

MessageSnapshot represents a snapshot of a message for the history view

type ModelSelectedEvent ¶

type ModelSelectedEvent struct {
	Model string
}

ModelSelectedEvent indicates model selection

type PlanApprovalResponseEvent ¶

type PlanApprovalResponseEvent struct {
	Action agentdomain.PlanApprovalAction
}

PlanApprovalResponseEvent captures the user's plan approval decision

type PlanApprovalSelectionChangedEvent ¶

type PlanApprovalSelectionChangedEvent struct {
	NewIndex int
}

PlanApprovalSelectionChangedEvent signals that the plan-approval button selection has moved and the conversation viewport needs to re-render so the highlighted button reflects the new index.

type RestoreStatusStateEvent ¶

type RestoreStatusStateEvent struct{}

RestoreStatusStateEvent restores a previously saved status state

type RolloverCompletedEvent ¶

type RolloverCompletedEvent struct {
	Message sdk.Message
	Images  []agentdomain.ImageAttachment
}

RolloverCompletedEvent is dispatched when an asynchronous auto-rollover finishes in chat mode. It carries the already-built sdk.Message + images that were pending while the summary LLM call was in flight, so the post-rollover handler can resume the deferred AddMessage + start-chat completion flow without re-parsing user input.

type SaveStatusStateEvent ¶

type SaveStatusStateEvent struct{}

SaveStatusStateEvent saves the current status state for later restoration

type ScrollDirection ¶

type ScrollDirection int

ScrollDirection represents different scroll directions

const (
	ScrollUp ScrollDirection = iota
	ScrollDown
	ScrollLeft
	ScrollRight
	ScrollToTop
	ScrollToBottom
)

type ScrollRequestEvent ¶

type ScrollRequestEvent struct {
	ComponentID string
	Direction   ScrollDirection
	Amount      int
}

ScrollRequestEvent requests scrolling in a component

type SetInputEvent ¶

type SetInputEvent struct {
	Text string
}

SetInputEvent sets text in the input field

type SetStatusEvent ¶

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

SetStatusEvent sets a status message

type SetupFileSelectionEvent ¶

type SetupFileSelectionEvent struct {
	Files []string
}

SetupFileSelectionEvent sets up file selection state with files

type ShowErrorEvent ¶

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

ShowErrorEvent displays an error message

type StatusComponent ¶

type StatusComponent interface {
	ShowStatus(message string)
	ShowError(message string)
	ShowSpinner(message string)
	ClearStatus()
	IsShowingError() bool
	IsShowingSpinner() bool
	SetWidth(width int)
	SetHeight(height int)
	Render() string
	SaveCurrentState()
	RestoreSavedState() tea.Cmd
	HasSavedState() bool
}

StatusComponent interface for status display

type StatusIndicatorAction ¶

type StatusIndicatorAction int

StatusIndicatorAction identifies the view a status-bar indicator opens when activated; indicators without a view map to StatusIndicatorActionNone

const (
	StatusIndicatorActionNone StatusIndicatorAction = iota
	StatusIndicatorActionModelSelection
	StatusIndicatorActionTaskManagement
	StatusIndicatorActionThemeSelection
	StatusIndicatorActionToolsList
	StatusIndicatorActionA2AAgents
)

type StatusProgress ¶

type StatusProgress struct {
	Current int
	Total   int
}

StatusProgress represents progress information for status messages

type StatusType ¶

type StatusType int

StatusType represents different types of status messages

const (
	StatusDefault StatusType = iota
	StatusThinking
	StatusGenerating
	StatusWorking
	StatusProcessing
	StatusPreparing
	StatusError
)

type StreamingContentEvent ¶

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

StreamingContentEvent delivers live streaming content for immediate UI display

type TaskCancelledEvent ¶

type TaskCancelledEvent struct {
	TaskID string
	Error  error
}

TaskCancelledEvent indicates a task has been cancelled

type TasksLoadedEvent ¶

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

TasksLoadedEvent indicates tasks have been loaded

type Theme ¶

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

Theme interface for UI theming

type ThemeSelectedEvent ¶

type ThemeSelectedEvent struct {
	Theme string
}

ThemeSelectedEvent indicates theme selection

type ThemeService ¶

type ThemeService interface {
	ListThemes() []string
	GetCurrentTheme() Theme
	GetCurrentThemeName() string
	SetTheme(themeName string) error
}

ThemeService handles theme management

type TodoUpdateEvent ¶

type TodoUpdateEvent struct {
	Todos []agentdomain.TodoItem
}

TodoUpdateEvent indicates the todo list has been updated

type ToggleHelpBarEvent ¶

type ToggleHelpBarEvent struct{}

ToggleHelpBarEvent toggles the help bar visibility

type ToggleTodoBoxEvent ¶

type ToggleTodoBoxEvent struct{}

ToggleTodoBoxEvent toggles the todo box expanded/collapsed state

type ToolExecutionCoordinator ¶

type ToolExecutionCoordinator interface {
	GetActiveToolCallID() string
	SetActiveToolCallID(id string)

	HandleToolCallUpdate(msg agentdomain.ToolCallUpdateEvent) tea.Cmd
	HandleToolCallReady(msg agentdomain.ToolCallReadyEvent) tea.Cmd
	HandleToolApprovalRequested(msg agentdomain.ToolApprovalRequestedEvent) tea.Cmd
	HandleToolApprovalResponse(msg agentdomain.ToolApprovalResponseEvent) tea.Cmd
	HandleToolExecutionStarted(msg ToolExecutionStartedEvent) tea.Cmd
	HandleToolExecutionProgress(msg agentdomain.ToolExecutionProgressEvent) tea.Cmd
	HandleToolExecutionCompleted(msg agentdomain.ToolExecutionCompletedEvent) tea.Cmd
	HandleToolCancelled(msg agentdomain.ToolCancelledEvent) tea.Cmd
}

ToolExecutionCoordinator owns the tool round-trip: streaming-status updates emitted while the model is producing a tool call, approval coordination (forwarding the user's decision back to the agent), and execution-progress events while the tool runs. Also owns the active-tool-call indicator the UI uses to render the in-flight tool name.

type ToolExecutionStartedEvent ¶

type ToolExecutionStartedEvent struct {
	SessionID  string
	TotalTools int
}

ToolExecutionStartedEvent indicates tool execution has started

type TriggerGithubActionSetupEvent ¶

type TriggerGithubActionSetupEvent struct{}

TriggerGithubActionSetupEvent triggers the GitHub App setup flow

type TriggerHelpViewEvent ¶

type TriggerHelpViewEvent struct{}

TriggerHelpViewEvent opens the full-screen, scrollable help overlay that lists every slash command and keybinding in two tables.

type UpdateHistoryEvent ¶

type UpdateHistoryEvent struct {
	History []convdomain.ConversationEntry
}

UpdateHistoryEvent updates the conversation history display

type UpdateStatusEvent ¶

type UpdateStatusEvent struct {
	Message    string
	StatusType StatusType
	ToolName   string
}

UpdateStatusEvent updates an existing status message without resetting timer

type VersionInfo ¶

type VersionInfo struct {
	Version string
}

VersionInfo contains build-time version information

type ViewManager ¶

type ViewManager interface {
	GetCurrentView() ViewState
	GetPreviousView() ViewState
	TransitionToView(newView ViewState) error
}

ViewManager handles view state transitions

type ViewState ¶

type ViewState int

ViewState represents the current view with proper state management

const (
	ViewStateModelSelection ViewState = iota
	ViewStateChat
	ViewStateFileSelection
	ViewStateConversationSelection
	ViewStateThemeSelection
	ViewStateA2ATaskManagement
	ViewStatePlanApproval
	ViewStateGithubActionSetup
	ViewStateDiffViewer
	ViewStateExplorer
	ViewStateHelp
	ViewStateToolsList
	ViewStateA2AAgents
)

func (v ViewState) String() string