Struct App 

pub struct App {
    pub input: InputBuffer,
    pub running: bool,
    pub working_dir: String,
    pub error_log: VecDeque<ErrorEntry>,
    pub app_state: AppState,
    pub model_state: ModelState,
    pub ui_state: UIState,
    pub session_state: ConversationState,
    pub operation_state: OperationState,
    pub status_state: StatusState,
    pub attachment_state: AttachmentState,
}

Application state coordinator

Fields

input: InputBuffer

User input buffer

running: bool

Is the app running?

working_dir: String

Current working directory

error_log: VecDeque<ErrorEntry>

Error log - keeps last N errors for visibility

app_state: AppState

State machine for application lifecycle

model_state: ModelState

Model state - LLM configuration

ui_state: UIState

UI state - visual presentation and widget states

session_state: ConversationState

Session state - conversation history and persistence

operation_state: OperationState

Operation state - file reading and tool calls

status_state: StatusState

Status state - UI status messages

attachment_state: AttachmentState

Attachment state - pending image attachments

Implementations

impl App

pub fn new(model: Box<dyn Model>, model_id: String) -> Self

Create a new app instance

pub fn add_message(&mut self, role: MessageRole, content: String)

Add a message to the chat (extracts thinking blocks automatically)

pub fn add_message_with_images( &mut self, role: MessageRole, content: String, images: Option<Vec<String>>, )

Add a message with optional image attachments

pub fn add_assistant_message_with_tool_calls( &mut self, content: String, tool_calls: Vec<ToolCall>, )

Add an assistant message with tool_calls attached

pub fn add_tool_result( &mut self, tool_call_id: String, tool_name: String, content: String, )

Add a tool result message

pub fn clear_input(&mut self)

Clear the input buffer

pub fn set_status(&mut self, message: impl Into<String>)

Set status message

pub fn clear_status(&mut self)

Clear status message

pub fn display_error( &mut self, summary: impl Into<String>, detail: impl Into<String>, )

Display an error consistently across the UI

pub fn display_error_simple(&mut self, message: impl Into<String>)

Display an error with just a message

pub fn log_error(&mut self, entry: ErrorEntry)

Log an error to the error log

pub fn log_error_msg(&mut self, severity: ErrorSeverity, msg: impl Into<String>)

Log a simple error message

pub fn log_error_with_context( &mut self, severity: ErrorSeverity, msg: impl Into<String>, context: impl Into<String>, )

Log error with context

pub fn recent_errors(&self, count: usize) -> Vec<&ErrorEntry>

Get recent errors

pub fn set_terminal_title(&self, title: &str)

Set terminal window title

pub fn spawn_title_generation(&self) -> Option<JoinHandle<Option<String>>>

Spawn title generation as a background task (non-blocking). Returns a JoinHandle the caller can poll with is_finished().

pub fn scroll_up(&mut self, amount: u16)

pub fn scroll_down(&mut self, amount: u16)

pub fn quit(&mut self)

pub fn build_message_history(&self) -> Vec<ChatMessage>

Build message history for model API calls (all messages, no truncation)

pub fn build_managed_message_history( &self, max_context_tokens: usize, reserve_tokens: usize, ) -> Vec<ChatMessage>

pub fn load_conversation(&mut self, conversation: ConversationHistory)

pub fn save_conversation(&mut self) -> Result<()>

pub fn auto_save_conversation(&mut self)

pub fn start_generation(&mut self, abort_handle: AbortHandle)

pub fn update_abort_handle(&mut self, abort_handle: AbortHandle)

Update the abort handle for a new model call within the same turn. Keeps the existing start_time and token count (cumulative for the turn).

pub fn transition_to_sending(&mut self)

Reset status to Sending for a new model call within the same turn.

pub fn transition_to_thinking(&mut self)

pub fn transition_to_streaming(&mut self)

pub fn set_final_tokens(&mut self, count: usize)

Add tokens from a completed model call (accumulates across the turn)

pub fn stop_generation(&mut self)

pub fn abort_generation(&mut self) -> (Option<AbortHandle>, String)

pub fn push_response(&mut self, text: &str)

Append text to the response buffer. No-op if not generating. Enforces MAX_RESPONSE_CHARS size limit.

pub fn response_len(&self) -> usize

Get response buffer length (0 if not generating)

pub fn take_response(&mut self) -> String

Take the response buffer, leaving it empty. Returns empty string if not generating.

pub fn clear_response(&mut self)

Clear the response buffer (for per-model-call reset within a turn)