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,
    pub mcp_tools: Vec<Value>,
    pub mcp_init_task: Option<JoinHandle<McpInitResult>>,
    pub instructions: Option<LoadedInstructions>,
}

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

mcp_tools: Vec<Value>

MCP tool definitions in Ollama JSON format (injected at startup or background init)

mcp_init_task: Option<JoinHandle<McpInitResult>>

Background MCP server initialization task. Polled in the event loop; when done, mcp_tools and global manager are set.

instructions: Option<LoadedInstructions>

Project instructions auto-loaded from MERMAID.md (Step 5h). None when no MERMAID.md exists in the bounded walk from cwd. Refreshed before every model call by loop_coordinator::call_model.

Implementations

impl App

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

Create a new app instance

pub fn build_model_config(&self) -> ModelConfig

Build a ModelConfig with MCP tools included.

pub async fn poll_mcp_init(&mut self)

Poll for completed MCP background initialization (non-blocking).

Returns immediately if init is still in progress or already done. When init completes, sets mcp_tools on self and registers the global MCP manager so tool calls can be dispatched.

Called from both the main event loop and the agent loop so that MCP tools become available to the model as soon as servers are ready, even mid-agent-loop.

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 commit_message(&mut self, message: ChatMessage)

Commit a message to session state and conversation history

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; once tripped, subsequent calls are silently dropped so we don’t pay O(n) per chunk re-truncating (and don’t emit duplicate [TRUNCATED…] markers).

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. Also clears the response_truncated flag so the next model call starts fresh.

pub fn clear_response(&mut self)

Clear the response buffer (for per-model-call reset within a turn) and the truncated flag so the new call’s buffer is fresh.