Struct App

pub struct App {

    pub state: AppState,
    pub messages: Vec<String>,
    pub logs: Vec<String>,
    pub available_models: Vec<ModelConfig>,
    pub error_message: Option<String>,
    pub last_query_time: Instant,
    pub use_agent: bool,
    pub agent: Option<Agent>,
    pub tokio_runtime: Option<Runtime>,
    pub api_key: Option<String>,
    pub current_working_dir: Option<String>,
    pub tasks: Vec<Task>,
    pub current_task_id: Option<String>,
    pub conversation_summaries: Vec<ConversationSummary>,
    pub session_manager: Option<SessionManager>,
    pub session_id: String,
    pub tool_executions: HashMap<String, ToolExecution>,
}

Main backend application state

Fields

state: AppState

messages: Vec<String>

logs: Vec<String>

available_models: Vec<ModelConfig>

error_message: Option<String>

last_query_time: Instant

use_agent: bool

agent: Option<Agent>

tokio_runtime: Option<Runtime>

api_key: Option<String>

current_working_dir: Option<String>

tasks: Vec<Task>

current_task_id: Option<String>

conversation_summaries: Vec<ConversationSummary>

session_manager: Option<SessionManager>

session_id: String

tool_executions: HashMap<String, ToolExecution>

Implementations

impl App

pub fn new() -> Self

Create a new App instance

pub fn current_model(&self, index: usize) -> Result<&ModelConfig>

Get the current model configuration

pub fn query_model(&mut self, prompt: &str) -> Result<String>

Query the model with the given prompt

pub fn has_active_tasks(&self) -> bool

Check if there are any active tasks

pub fn get_task_statuses(&self) -> Vec<Value>

Get the task statuses for all tasks

pub fn create_task(&mut self, description: &str) -> String

Create a new task and set it as current

pub fn current_task(&self) -> Option<&Task>

Get the current task if any

pub fn current_task_mut(&mut self) -> Option<&mut Task>

Get the current task as mutable if any

pub fn add_tool_use(&mut self)

Add a tool use to the current task

pub fn add_input_tokens(&mut self, tokens: u32)

Add input tokens to the current task

pub fn complete_current_task(&mut self, tokens: u32)

Complete the current task

pub fn fail_current_task(&mut self, error: &str)

Mark the current task as failed

pub fn start_tool_execution(&mut self, name: &str) -> Option<String>

Start a new tool execution

pub fn update_tool_progress( &mut self, tool_id: &str, message: &str, metadata: Option<HashMap<String, Value>>, )

Update tool execution progress

pub fn complete_tool_execution( &mut self, tool_id: &str, message: &str, metadata: Option<HashMap<String, Value>>, )

Complete a tool execution

pub fn fail_tool_execution(&mut self, tool_id: &str, error: &str)

Mark a tool execution as failed

pub fn cleanup_old_tool_executions(&mut self)

Clean up old completed tool executions (older than 10 minutes)

pub fn log(&mut self, _message: &str)

👎Deprecated since 0.2.0: Use eprintln with format_log_with_color instead

Add a log message (now deprecated in favor of direct eprintln calls)

Trait Implementations

impl ContextCompressor for App

fn compress_context(&mut self) -> Result<()>

Generate a summary of the conversation history

fn should_compress(&self) -> bool

Check if conversation should be summarized based on thresholds

fn conversation_char_count(&self) -> usize

Get the total character count of conversation history

fn summary_count(&self) -> usize

Get summaries count

fn clear_history(&mut self)

Clear all summaries and history

fn display_to_session_messages( &self, display_messages: &[String], ) -> Vec<Message>

Convert display messages to session messages

fn session_to_display_messages( &self, session_messages: &[Message], ) -> Vec<String>

Convert session messages to display messages

impl Default for App

fn default() -> Self

Returns the “default value” for a type.