steer_core/app/

mod.rs

use crate::api::Client as ApiClient;
use crate::app::cancellation::ActiveTool;
use crate::app::command::ApprovalType;
use crate::app::conversation::{AppCommandType, AssistantContent, CompactResult, UserContent};
use crate::auth::ProviderRegistry;
use crate::catalog::CatalogConfig;
use crate::config::LlmConfigProvider;
use crate::config::model::ModelId;
use crate::error::{Error, Result};
use crate::model_registry::ModelRegistry;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::sync::Arc;
use std::time::{Duration, Instant};
use steer_tools::tools::BASH_TOOL_NAME;
use steer_tools::tools::bash::BashParams;
use steer_tools::{ToolCall, ToolError, ToolResult};
use tokio::sync::{Mutex, mpsc, oneshot};
use tokio_util::sync::CancellationToken;

use tracing::{debug, error, info, warn};
use uuid;

pub mod adapters;
mod agent_executor;
pub mod cancellation;
pub mod command;
pub mod context;
pub mod conversation;
pub mod io;

pub mod validation;

#[cfg(test)]
mod tests;

use crate::app::context::TaskOutcome;

pub use cancellation::CancellationInfo;
pub use command::AppCommand;
pub use context::OpContext;
pub use conversation::{Conversation, Message, MessageData};
pub use steer_workspace::EnvironmentInfo;

pub use agent_executor::{
    AgentEvent, AgentExecutor, AgentExecutorError, AgentExecutorRunRequest, ApprovalDecision,
};

#[derive(Debug, Clone)]
pub enum AppEvent {
    MessageAdded {
        message: Message,
        model: ModelId,
    },
    MessageUpdated {
        id: String,
        content: String,
    },
    MessagePart {
        id: String,
        delta: String,
    },

    ToolCallStarted {
        name: String,
        id: String,
        parameters: serde_json::Value,
        model: ModelId,
    },
    ToolCallCompleted {
        name: String,
        result: ToolResult,
        id: String,
        model: ModelId,
    },
    ToolCallFailed {
        name: String,
        error: String,
        id: String,
        model: ModelId,
    },

    ProcessingStarted,   // Started processing a user message
    ProcessingCompleted, // Completed processing a user message

    CommandResponse {
        command: conversation::AppCommandType,
        response: conversation::CommandResponse,
        id: String,
    },

    RequestToolApproval {
        name: String,
        parameters: serde_json::Value,
        id: String,
    },
    OperationCancelled {
        op_id: Option<uuid::Uuid>, // Operation ID if available
        info: CancellationInfo,
    },

    ModelChanged {
        model: ModelId,
    },
    Error {
        message: String,
    },
    WorkspaceChanged,
    WorkspaceFiles {
        files: Vec<String>,
    },
    Started {
        id: uuid::Uuid,
        op: Operation,
    },
    Finished {
        id: uuid::Uuid,
        outcome: OperationOutcome,
    },
    ActiveMessageIdChanged {
        message_id: Option<String>,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Operation {
    Bash { cmd: String },
    Compact,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum OperationOutcome {
    Bash {
        elapsed: Duration,
        result: std::result::Result<(), BashError>,
    },
    Compact {
        elapsed: Duration,
        result: std::result::Result<(), CompactError>,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BashError {
    pub exit_code: i32,
    pub stderr: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompactError {
    pub message: String,
}

#[derive(Clone)]
pub struct AppConfig {
    pub llm_config_provider: LlmConfigProvider,
    pub model_registry: Arc<ModelRegistry>,
    pub provider_registry: Arc<ProviderRegistry>,
}

impl AppConfig {
    /// Create AppConfig from an auth storage instance with default catalog.
    /// Loads both registries once and returns the configured AppConfig.
    pub fn from_auth_storage(auth_storage: Arc<dyn crate::auth::AuthStorage>) -> Result<Self> {
        Self::from_auth_storage_with_catalog(auth_storage, CatalogConfig::default())
    }

    /// Create AppConfig from an auth storage instance with custom catalog config.
    pub fn from_auth_storage_with_catalog(
        auth_storage: Arc<dyn crate::auth::AuthStorage>,
        catalog_config: CatalogConfig,
    ) -> Result<Self> {
        let llm_config_provider = LlmConfigProvider::new(auth_storage);
        let model_registry = Arc::new(ModelRegistry::load(&catalog_config.catalog_paths)?);
        let provider_registry = Arc::new(ProviderRegistry::load(&catalog_config.catalog_paths)?);

        Ok(Self {
            llm_config_provider,
            model_registry,
            provider_registry,
        })
    }

    /// Create AppConfig for production use with default auth storage.
    #[cfg(not(test))]
    pub fn new() -> Result<Self> {
        let auth_storage = Arc::new(crate::auth::DefaultAuthStorage::new()?);
        Self::from_auth_storage(auth_storage)
    }
}

/// Test-only default implementation using in-memory storage.
/// Available in both test and non-test contexts for test utilities.
impl Default for AppConfig {
    fn default() -> Self {
        let storage = Arc::new(crate::test_utils::InMemoryAuthStorage::new());
        Self::from_auth_storage(storage).expect("Failed to create test AppConfig")
    }
}

pub struct App {
    pub config: AppConfig,
    pub conversation: Arc<Mutex<Conversation>>,
    pub tool_executor: Arc<crate::tools::ToolExecutor>,
    pub api_client: ApiClient,
    agent_executor: AgentExecutor,
    event_sender: mpsc::Sender<AppEvent>,
    approved_tools: Arc<tokio::sync::RwLock<HashSet<String>>>, // Tracks tools approved with "Always" for the session
    approved_bash_patterns: std::sync::Arc<tokio::sync::RwLock<HashSet<String>>>, // Tracks bash commands approved for the session
    current_op_context: Option<OpContext>,
    current_model: ModelId,
    session_config: Option<crate::session::state::SessionConfig>, // For tool visibility filtering
    workspace: Option<Arc<dyn crate::workspace::Workspace>>, // Workspace for environment and tool execution
    cached_system_prompt: Option<String>, // Cached system prompt to avoid recomputation
}

/// Check if a command matches any pattern in the given list
fn matches_any_pattern(command: &str, patterns: &[String]) -> bool {
    patterns.iter().any(|pattern| {
        // Check exact match first
        if pattern == command {
            return true;
        }
        // Then check glob pattern
        glob::Pattern::new(pattern)
            .map(|p| p.matches(command))
            .unwrap_or(false)
    })
}

impl App {
    pub async fn new_with_conversation(
        config: AppConfig,
        event_tx: mpsc::Sender<AppEvent>,
        initial_model: ModelId,
        workspace: Arc<dyn crate::workspace::Workspace>,
        tool_executor: Arc<crate::tools::ToolExecutor>,
        session_config: Option<crate::session::state::SessionConfig>,
        conversation: Conversation,
    ) -> Result<Self> {
        let api_client = ApiClient::new_with_deps(
            config.llm_config_provider.clone(),
            config.provider_registry.clone(),
            config.model_registry.clone(),
        );
        let agent_executor = AgentExecutor::new(Arc::new(api_client.clone()));

        // Initialize approved_bash_patterns from session config
        let approved_bash_patterns = if let Some(ref sc) = session_config {
            if let Some(bash_config) = sc.tool_config.tools.get("bash") {
                let crate::session::state::ToolSpecificConfig::Bash(bash) = bash_config;
                bash.approved_patterns.iter().cloned().collect()
            } else {
                HashSet::new()
            }
        } else {
            HashSet::new()
        };
        let approved_bash_patterns =
            std::sync::Arc::new(tokio::sync::RwLock::new(approved_bash_patterns));

        Ok(Self {
            config,
            conversation: Arc::new(Mutex::new(conversation)),
            tool_executor,
            api_client,
            agent_executor,
            event_sender: event_tx,
            approved_tools: Arc::new(tokio::sync::RwLock::new(HashSet::new())),
            approved_bash_patterns,
            current_op_context: None,
            current_model: initial_model,
            session_config,
            workspace: Some(workspace),
            cached_system_prompt: None,
        })
    }

    pub async fn new(
        config: AppConfig,
        event_tx: mpsc::Sender<AppEvent>,
        initial_model: ModelId,
        workspace: Arc<dyn crate::workspace::Workspace>,
        tool_executor: Arc<crate::tools::ToolExecutor>,
        session_config: Option<crate::session::state::SessionConfig>,
    ) -> Result<Self> {
        let conversation = Conversation::new();
        Self::new_with_conversation(
            config,
            event_tx,
            initial_model,
            workspace,
            tool_executor,
            session_config,
            conversation,
        )
        .await
    }

    pub(crate) fn emit_event(&self, event: AppEvent) {
        match self.event_sender.try_send(event.clone()) {
            Ok(_) => {
                // Skip logging message parts for brevity
                if !matches!(event, AppEvent::MessagePart { .. }) {
                    debug!(target: "app.emit_event", "Sent event: {:?}", event);
                }
            }
            Err(mpsc::error::TrySendError::Full(_)) => {
                warn!(target: "app.emit_event", "Event channel full, discarding event: {:?}", event);
            }
            Err(mpsc::error::TrySendError::Closed(_)) => {
                warn!(target: "app.emit_event", "Event channel closed, discarding event: {:?}", event);
            }
        }
    }

    pub(crate) async fn emit_workspace_files(&self) {
        if let Some(workspace) = &self.workspace {
            info!(target: "app.emit_workspace_files", "Attempting to list workspace files...");
            match workspace.list_files(None, Some(10000)).await {
                Ok(files) => {
                    info!(target: "app.emit_workspace_files", "Emitting workspace files event with {} files", files.len());
                    if files.is_empty() {
                        warn!(target: "app.emit_workspace_files", "No files found in workspace - check if directory is correct");
                    }
                    self.emit_event(AppEvent::WorkspaceFiles { files });
                }
                Err(e) => {
                    warn!(target: "app.emit_workspace_files", "Failed to list workspace files: {}", e);
                }
            }
        } else {
            warn!(target: "app.emit_workspace_files", "No workspace available to list files");
        }
    }

    pub fn get_current_model(&self) -> ModelId {
        self.current_model.clone()
    }

    /// Gets or creates the system prompt, using cache if available
    async fn get_or_create_system_prompt(&mut self) -> Result<String> {
        if let Some(ref cached) = self.cached_system_prompt {
            debug!(target: "app.get_or_create_system_prompt", "Using cached system prompt");
            Ok(cached.clone())
        } else {
            debug!(target: "app.get_or_create_system_prompt", "Creating new system prompt");
            let prompt = if let Some(workspace) = &self.workspace {
                create_system_prompt_with_workspace(
                    Some(self.current_model.clone()),
                    workspace.as_ref(),
                )
                .await?
            } else {
                // If no workspace, create a minimal system prompt

                if let Some(model) = Some(self.current_model.clone()) {
                    get_model_system_prompt(model)
                } else {
                    crate::prompts::default_system_prompt()
                }
            };
            // Cache the system prompt
            self.cached_system_prompt = Some(prompt.clone());
            Ok(prompt)
        }
    }

    pub async fn set_model(&mut self, model: ModelId) -> Result<()> {
        // Check if the provider is available (has API key or OAuth)
        let provider_id = model.0.clone();

        let auth = self
            .config
            .llm_config_provider
            .get_auth_for_provider(&provider_id)
            .await?;
        if auth.is_none() {
            return Err(crate::error::Error::Configuration(format!(
                "Cannot set model to {model:?}: missing authentication for {provider_id:?} provider"
            )));
        }

        // Set the model
        self.current_model = model.clone();

        // Clear cached system prompt when model changes
        self.cached_system_prompt = None;

        // Emit an event to notify UI of the change
        self.emit_event(AppEvent::ModelChanged { model });

        Ok(())
    }

    pub async fn add_message(&self, message: Message) {
        let mut conversation_guard = self.conversation.lock().await;
        let message_id = message.id().to_string();
        conversation_guard.add_message(message.clone());
        self.emit_event(AppEvent::MessageAdded {
            message,
            model: self.current_model.clone(),
        });
        self.emit_event(AppEvent::ActiveMessageIdChanged {
            message_id: Some(message_id),
        });
    }

    pub async fn add_message_from_data(&self, message_data: MessageData) {
        let mut conversation_guard = self.conversation.lock().await;
        let message = conversation_guard.add_message_from_data(message_data);

        self.emit_event(AppEvent::MessageAdded {
            message: message.clone(),
            model: self.current_model.clone(),
        });
        self.emit_event(AppEvent::ActiveMessageIdChanged {
            message_id: Some(message.id().to_string()),
        });
    }

    // Renamed from process_user_message to make it clear it starts an op
    // Returns the event receiver if a standard agent operation was started
    pub async fn process_user_message(
        &mut self,
        message: String,
    ) -> Result<Option<mpsc::Receiver<AgentEvent>>> {
        // Cancel any existing operations first
        self.cancel_current_processing().await;

        // Create a new operation context
        let op_context = OpContext::new();
        self.current_op_context = Some(op_context);

        self.add_message_from_data(MessageData::User {
            content: vec![UserContent::Text {
                text: message.clone(),
            }],
        })
        .await;

        // Start thinking and spawn agent operation
        self.emit_event(AppEvent::ProcessingStarted);
        match self.spawn_agent_operation().await {
            Ok(maybe_receiver) => Ok(maybe_receiver), // Return the receiver
            Err(e) => {
                error!(target:
                    "App.start_standard_operation",
                    "Error spawning agent operation task: {}", e,
                );
                self.emit_event(AppEvent::ProcessingCompleted); // Stop thinking on spawn error
                self.emit_event(AppEvent::Error {
                    message: format!("Failed to start agent operation: {e}"),
                });
                self.current_op_context = None; // Clean up context
                Err(e)
            }
        }
    }

    async fn spawn_agent_operation(&mut self) -> Result<Option<mpsc::Receiver<AgentEvent>>> {
        debug!(target:
            "app.spawn_agent_operation",
            "Spawning agent operation task...",
        );

        // Get tools for the operation
        // Always get all tools from the tool executor (includes workspace tools)
        let mut tool_schemas = self.tool_executor.get_tool_schemas().await;

        // Then apply visibility filtering if we have a session config
        if let Some(session_config) = &self.session_config {
            tool_schemas = session_config.filter_tools_by_visibility(tool_schemas);
        }

        // Get or create system prompt from cache (before accessing op_context mutably)
        let system_prompt = self.get_or_create_system_prompt().await?;

        // Get mutable access to OpContext and its token
        let op_context = match &mut self.current_op_context {
            Some(ctx) => ctx,
            None => {
                return Err(crate::error::Error::InvalidOperation(
                    "No operation context available to spawn agent operation".to_string(),
                ));
            }
        };
        let token = op_context.cancel_token.clone();

        // Get messages (snapshot)
        let api_messages = {
            let conversation_guard = self.conversation.lock().await;
            conversation_guard
                .get_thread_messages()
                .into_iter()
                .cloned()
                .collect()
        };

        let current_model = self.current_model.clone();
        let agent_executor = self.agent_executor.clone();

        // --- Tool Approval Callback ---
        let approved_tools_for_approval = self.approved_tools.clone();
        let tool_executor_for_approval = self.tool_executor.clone();
        let command_tx_for_approval = OpContext::command_tx().clone();
        let approved_bash_patterns_clone = self.approved_bash_patterns.clone(); // Clone for capture
        let session_config_clone = self.session_config.clone(); // Clone for capture

        let tool_approval_callback = move |tool_call: ToolCall| {
            let approved_tools = approved_tools_for_approval.clone();
            let executor = tool_executor_for_approval.clone();
            let command_tx = command_tx_for_approval.clone();
            let tool_name = tool_call.name.clone();
            let tool_id = tool_call.id.clone();
            let approved_bash_patterns = approved_bash_patterns_clone.clone();
            let session_config = session_config_clone.clone();

            async move {
                match executor.requires_approval(&tool_name).await {
                    Ok(false) => return Ok(ApprovalDecision::Approved),
                    Ok(true) => {}
                    Err(e) => {
                        return Err(ToolError::InternalError(format!(
                            "Failed to check tool approval status for {tool_name}: {e}"
                        )));
                    }
                };

                if approved_tools.read().await.contains(&tool_name) {
                    return Ok(ApprovalDecision::Approved);
                }

                // Check if this is a bash command that matches an approved pattern
                if tool_name == BASH_TOOL_NAME {
                    // Extract command from tool parameters
                    let params: BashParams = match serde_json::from_value(
                        tool_call.parameters.clone(),
                    ) {
                        Ok(p) => p,
                        Err(e) => {
                            debug!(tool_id=%tool_id, tool_name=%tool_name, "Failed to parse BashParams from tool_call.parameters: {}", e);
                            return Err(ToolError::invalid_params(
                                "bash",
                                format!("Failed to parse BashParams: {e}"),
                            ));
                        }
                    };

                    // Check against static patterns from session config
                    let static_patterns = if let Some(ref session_config) = session_config {
                        if let Some(bash_config) = session_config.tool_config.tools.get("bash") {
                            let crate::session::state::ToolSpecificConfig::Bash(bash) = bash_config;
                            &bash.approved_patterns
                        } else {
                            &Vec::new()
                        }
                    } else {
                        &Vec::new()
                    };

                    if matches_any_pattern(params.command.as_str(), static_patterns) {
                        debug!(tool_id=%tool_id, tool_name=%tool_name, "Bash command {} matches static patterns: {:?}", params.command, static_patterns);
                        return Ok(ApprovalDecision::Approved);
                    } else {
                        debug!(tool_id=%tool_id, tool_name=%tool_name, "Bash command {} does not match static patterns: {:?}", params.command, static_patterns);
                    }

                    // Check against dynamically approved patterns (convert HashSet to Vec)
                    let dynamic_patterns: Vec<String> = {
                        let patterns = approved_bash_patterns.read().await;
                        debug!(tool_id=%tool_id, tool_name=%tool_name, "Dynamic patterns: {:?}", patterns);
                        patterns.iter().cloned().collect()
                    };

                    if matches_any_pattern(params.command.as_str(), &dynamic_patterns) {
                        debug!(tool_id=%tool_id, tool_name=%tool_name, "Bash command {} matches dynamic patterns: {:?}", params.command, dynamic_patterns);
                        return Ok(ApprovalDecision::Approved);
                    } else {
                        debug!(tool_id=%tool_id, tool_name=%tool_name, "Bash command {} does not match dynamic patterns: {:?}", params.command, dynamic_patterns);
                    }
                }

                // Needs interactive approval - create oneshot channel for receiving the decision
                let (tx, rx) = oneshot::channel();

                // Send approval request to the actor loop via command channel
                if let Err(e) = command_tx
                    .send(AppCommand::RequestToolApprovalInternal {
                        tool_call,
                        responder: tx,
                    })
                    .await
                {
                    // If we can't send the request, treat as an error
                    error!(tool_id=%tool_id, tool_name=%tool_name, "Failed to send tool approval request: {}", e);
                    return Err(ToolError::InternalError(format!(
                        "Failed to request tool approval: {e}"
                    )));
                }

                // Wait for the decision
                match rx.await {
                    Ok(d) => Ok(d), // User made a choice
                    Err(_) => {
                        // Responder was dropped (likely due to cancellation elsewhere or shutdown)
                        warn!(tool_id=%tool_id, tool_name=%tool_name, "Approval decision channel closed for tool.");
                        Ok(ApprovalDecision::Denied) // Treat as denied
                    }
                }
            }
        };

        // --- Tool Execution Callback ---
        let tool_executor_for_execution = self.tool_executor.clone();
        let tool_execution_callback =
            move |tool_call: ToolCall, callback_token: CancellationToken| {
                let executor = tool_executor_for_execution.clone();
                let tool_name = tool_call.name.clone();
                let tool_id = tool_call.id.clone();

                async move {
                    info!(tool_id=%tool_id, tool_name=%tool_name, "Executing tool via callback.");
                    executor
                        .execute_tool_with_cancellation(&tool_call, callback_token)
                        .await
                }
            };

        let (agent_event_tx, agent_event_rx) = mpsc::channel(100);
        op_context.tasks.spawn(async move {
            debug!(target:
                "spawn_agent_operation task",
                "Agent operation task started.",
            );
            let request = AgentExecutorRunRequest {
                model: current_model,
                initial_messages: api_messages,
                system_prompt: Some(system_prompt),
                available_tools: tool_schemas,
                tool_approval_callback,
                tool_execution_callback,
            };
            let operation_result = agent_executor
                .run(request, agent_event_tx, token)
                .await;

            debug!(target: "spawn_agent_operation task", "Agent operation task finished with result: {:?}", operation_result.is_ok());

            TaskOutcome::AgentOperationComplete {
                result: operation_result,
            }
        });

        debug!(target:
            "app.spawn_agent_operation",
            "Agent operation task successfully spawned.",
        );
        Ok(Some(agent_event_rx))
    }

    // Modified handle_command to return only the response string (or None)
    // It now starts tasks directly but doesn't return the receiver.
    pub async fn handle_command(
        &mut self,
        command: AppCommandType,
    ) -> Result<Option<conversation::CommandResponse>> {
        // Cancel any previous operation before starting a command
        // Note: This is also called by start_standard_operation if user input isn't a command
        self.cancel_current_processing().await;

        match command {
            AppCommandType::Clear => {
                self.conversation.lock().await.clear();
                self.approved_tools.write().await.clear(); // Also clear tool approvals
                self.cached_system_prompt = None; // Clear cached system prompt
                self.emit_event(AppEvent::ActiveMessageIdChanged { message_id: None });

                Ok(Some(conversation::CommandResponse::Text(
                    "Conversation and tool approvals cleared.".to_string(),
                )))
            }
            AppCommandType::Compact => {
                // Create unique operation ID
                let op_id = uuid::Uuid::new_v4();
                let start_time = Instant::now();

                // Emit Started event
                self.emit_event(AppEvent::Started {
                    id: op_id,
                    op: Operation::Compact,
                });

                // Create OpContext for cancellable command
                let op_context = OpContext::new_with_id(op_id);
                self.current_op_context = Some(op_context);
                let token = self
                    .current_op_context
                    .as_ref()
                    .unwrap()
                    .cancel_token
                    .clone();

                // Spawn the compaction task within the context
                // TODO: Add TaskOutcome::CompactResult and handle in actor loop
                // For now, await directly and clear context
                warn!(target:
                    "handle_command",
                    "Compact command task spawning needs TaskOutcome handling in actor loop.",
                );
                let result = match self.compact_conversation(token).await {
                    Ok(result) => {
                        let elapsed = start_time.elapsed();
                        // Emit Finished event on success
                        self.emit_event(AppEvent::Finished {
                            id: op_id,
                            outcome: OperationOutcome::Compact {
                                elapsed,
                                result: Ok(()),
                            },
                        });
                        Ok(Some(conversation::CommandResponse::Compact(result)))
                    }
                    Err(e) => {
                        let elapsed = start_time.elapsed();
                        error!(target:
                            "App.handle_command",
                            "Error during compact: {}", e,
                        );
                        // Emit Finished event with error
                        self.emit_event(AppEvent::Finished {
                            id: op_id,
                            outcome: OperationOutcome::Compact {
                                elapsed,
                                result: Err(CompactError {
                                    message: e.to_string(),
                                }),
                            },
                        });
                        Err(e) // Propagate actual errors
                    }
                }?;
                self.current_op_context = None; // Clear context after command
                Ok(result)
            }
            AppCommandType::Model { target } => {
                if target.is_none() {
                    // If no model specified, list available models

                    let current_model = self.get_current_model();

                    // Use injected model registry
                    let model_registry = &self.config.model_registry;

                    let mut items: Vec<(bool, String, String, String, String)> = model_registry
                        .all()
                        .map(|config| {
                            let model_id = (config.provider.clone(), config.id.clone());
                            let is_current = model_id == current_model;
                            let prov = config.provider.storage_key();
                            let sort_name = config
                                .display_name
                                .as_deref()
                                .filter(|s| !s.trim().is_empty())
                                .unwrap_or(&config.id)
                                .to_string();
                            let id = config.id.clone();
                            let alias_str = if config.aliases.is_empty() {
                                String::new()
                            } else if config.aliases.len() == 1 {
                                format!(" (alias: {})", config.aliases[0])
                            } else {
                                format!(" (aliases: {})", config.aliases.join(", "))
                            };
                            (is_current, prov, sort_name, id, alias_str)
                        })
                        .collect();

                    items.sort_by(|a, b| {
                        (a.1.as_str(), a.2.as_str()).cmp(&(b.1.as_str(), b.2.as_str()))
                    });

                    let available_models: Vec<String> = items
                        .into_iter()
                        .map(|(is_current, prov, _sort_name, id, alias_str)| {
                            let model_str = format!("{prov}/{id}");
                            if is_current {
                                format!("* {model_str}{alias_str}")
                            } else {
                                format!("  {model_str}{alias_str}")
                            }
                        })
                        .collect();

                    Ok(Some(conversation::CommandResponse::Text(format!(
                        "Current model: {}/{}\nAvailable models:\n{}",
                        current_model.0.storage_key(),
                        current_model.1,
                        available_models.join("\n")
                    ))))
                } else if let Some(ref model_name) = target {
                    // Try to set the model

                    // Use injected model registry
                    let model_registry = &self.config.model_registry;

                    match model_registry.resolve(model_name) {
                        Ok(model_id) => {
                            // Clone id for lookup after mutation
                            let lookup_id = model_id.clone();
                            match self.set_model(model_id).await {
                                Ok(()) => {
                                    // Build friendly display: provider/display_name or fallback to provider/id
                                    let display = if let Some(cfg) =
                                        self.config.model_registry.get(&lookup_id)
                                    {
                                        let name = cfg
                                            .display_name
                                            .as_deref()
                                            .filter(|s| !s.trim().is_empty())
                                            .unwrap_or(&cfg.id);
                                        format!("{}/{}", cfg.provider.storage_key(), name)
                                    } else {
                                        format!("{}/{}", lookup_id.0.storage_key(), lookup_id.1)
                                    };
                                    Ok(Some(conversation::CommandResponse::Text(format!(
                                        "Model changed to {display}"
                                    ))))
                                }
                                Err(e) => Ok(Some(conversation::CommandResponse::Text(format!(
                                    "Failed to set model: {e}"
                                )))),
                            }
                        }
                        Err(e) => Ok(Some(conversation::CommandResponse::Text(format!(
                            "Failed to resolve model '{model_name}': {e}"
                        )))),
                    }
                } else {
                    // This should not happen with the current enum structure
                    Ok(None)
                }
            }
        }
    }

    pub async fn compact_conversation(
        &mut self,
        token: CancellationToken,
    ) -> Result<CompactResult> {
        info!(target:"App.compact_conversation", "Compacting conversation...");
        let client = self.api_client.clone();
        let conversation_arc = self.conversation.clone();
        let model = self.current_model.clone();

        // Run directly but make it cancellable.
        let result = tokio::select! {
            biased;
            res = async { conversation_arc.lock().await.compact(&client, model, token.clone()).await } => res.map_err(|e| Error::InvalidOperation(format!("Compact failed: {e}")))?,
            _ = token.cancelled() => {
                 info!(target:"App.compact_conversation", "Compaction cancelled.");
                 return Ok(CompactResult::Cancelled);
             }
        };

        // If compaction succeeded, emit active message ID change event
        if matches!(result, CompactResult::Success(_)) {
            let active_id = conversation_arc.lock().await.active_message_id.clone();
            self.emit_event(AppEvent::ActiveMessageIdChanged {
                message_id: active_id,
            });
        }

        info!(target:"App.compact_conversation", "Conversation compacted.");
        Ok(result)
    }

    pub async fn cancel_current_processing(&mut self) {
        // Use operation context for cancellation if available
        if let Some(mut op_context) = self.current_op_context.take() {
            info!(target:
                "App.cancel_current_processing",
                "Cancelling current operation via OpContext",
            );

            // Capture the current state for the cancellation info
            let active_tools = op_context
                .active_tools
                .values()
                .map(|(_, _, name)| ActiveTool {
                    id: name.clone(), // Using name as ID for cancellation info
                    name: name.clone(),
                })
                .collect();
            // TODO: Get accurate pending approval status from the actor loop's ApprovalState
            let cancellation_info = CancellationInfo {
                api_call_in_progress: false, // Handled by AgentExecutor now
                active_tools,
                pending_tool_approvals: false, // TODO: Update this based on actor state
            };

            // Get the operation ID before canceling
            let op_id = op_context.operation_id;

            op_context.cancel_and_shutdown().await;

            self.emit_event(AppEvent::OperationCancelled {
                op_id,
                info: cancellation_info,
            });

            // Inject cancelled tool results after cancelling
            self.inject_cancelled_tool_results().await;

            // Emit ProcessingCompleted only when we actually cancelled something
            self.emit_event(AppEvent::ProcessingCompleted);
            // Don't return here, actor loop needs to clear receiver if present
        } else {
            warn!(target:
                "App.cancel_current_processing",
                "Attempted to cancel processing, but no active operation context was found.",
            );
        }
    }

    /// Inject cancelled tool results for any incomplete tool calls in the conversation.
    /// This ensures that LLM APIs receive proper tool_result blocks for every tool_use block.
    pub async fn inject_cancelled_tool_results(&mut self) {
        let incomplete_tool_calls = {
            let conversation_guard = self.conversation.lock().await;
            self.find_incomplete_tool_calls(&conversation_guard)
        };

        if !incomplete_tool_calls.is_empty() {
            info!(target: "App.inject_cancelled_tool_results",
                  "Found {} incomplete tool calls, injecting cancellation results",
                  incomplete_tool_calls.len());

            for tool_call in incomplete_tool_calls {
                self.add_message_from_data(MessageData::Tool {
                    tool_use_id: tool_call.id.clone(),
                    result: ToolResult::Error(ToolError::Cancelled(tool_call.name.clone())),
                })
                .await;

                // Emit ToolCallFailed event so UI can render cancellation result
                self.emit_event(AppEvent::ToolCallFailed {
                    id: tool_call.id.clone(),
                    name: tool_call.name.clone(),
                    error: "Cancelled".to_string(),
                    model: self.current_model.clone(),
                });

                debug!(target: "App.inject_cancelled_tool_results",
                       "Injected cancellation result for tool call: {} ({})",
                       tool_call.name, tool_call.id);
            }
        }
    }

    /// Find tool calls that don't have corresponding tool results
    fn find_incomplete_tool_calls(&self, conversation: &Conversation) -> Vec<ToolCall> {
        let mut tool_calls = Vec::new();
        let mut tool_results = std::collections::HashSet::new();

        // First pass: collect all tool results
        for message in &conversation.messages {
            if let MessageData::Tool { tool_use_id, .. } = &message.data {
                tool_results.insert(tool_use_id.clone());
            }
        }

        // Second pass: find tool calls without results
        for message in &conversation.messages {
            if let MessageData::Assistant { content, .. } = &message.data {
                for block in content {
                    if let AssistantContent::ToolCall { tool_call } = block {
                        if !tool_results.contains(&tool_call.id) {
                            tool_calls.push(tool_call.clone());
                        }
                    }
                }
            }
        }

        tool_calls
    }

    async fn get_active_message_id(&self) -> Option<String> {
        let conv = self.conversation.lock().await;
        conv.active_message_id.clone()
    }
}

// Approval queue helper struct
struct ApprovalQueue {
    current: Option<(String, ToolCall, oneshot::Sender<ApprovalDecision>)>,
    queued: std::collections::VecDeque<(String, ToolCall, oneshot::Sender<ApprovalDecision>)>,
}

impl ApprovalQueue {
    fn new() -> Self {
        Self {
            current: None,
            queued: std::collections::VecDeque::new(),
        }
    }

    fn add_request(
        &mut self,
        id: String,
        tool_call: ToolCall,
        responder: oneshot::Sender<ApprovalDecision>,
    ) {
        self.queued.push_back((id, tool_call, responder));
    }

    fn cancel_all(&mut self) {
        // Drop current request responder to signal cancellation
        if let Some((id, _, _)) = self.current.take() {
            info!(target: "ApprovalQueue", "Cancelled active tool approval request for ID '{}'", id);
        }
        // Drop all queued responders
        if !self.queued.is_empty() {
            info!(target: "ApprovalQueue", "Clearing {} queued tool approval requests", self.queued.len());
            self.queued.clear();
        }
    }
}

// Define the App actor loop function with minimal refactoring
pub async fn app_actor_loop(mut app: App, mut command_rx: mpsc::Receiver<AppCommand>) {
    info!(target: "app_actor_loop", "App actor loop started.");

    // Emit initial workspace files for the UI
    app.emit_workspace_files().await;

    // Approval queue state
    let mut approval_queue = ApprovalQueue::new();

    // Active agent event receiver
    let mut active_agent_event_rx: Option<mpsc::Receiver<AgentEvent>> = None;

    // Track if the associated task for the active receiver has completed
    let mut agent_task_completed = false;

    loop {
        tokio::select! {
            // Handle incoming commands from the UI/Main thread
            Some(command) = command_rx.recv() => {
                match handle_app_command(
                    &mut app,
                    command,
                    &mut approval_queue,
                    &mut active_agent_event_rx,
                )
                .await
                {
                    Ok(should_exit) => {
                        if should_exit {
                            break; // Exit loop if Shutdown command was received
                        }
                    }
                    Err(e) => {
                        error!(target: "app_actor_loop", "Error handling app command: {}", e);
                        app.emit_event(AppEvent::Error {
                            message: format!("Command failed: {e}"),
                        });
                    }
                }
                // Reset task completion flag only if a new operation started
                if active_agent_event_rx.is_some() {
                    debug!(target: "app_actor_loop", "Resetting agent_task_completed flag due to new operation.");
                    agent_task_completed = false;
                }
            }

            // Poll for completed tasks (Agent Operations) from OpContext
            // This arm MUST be polled *before* the event receiver arm
            result = async {
                if let Some(ctx) = app.current_op_context.as_mut() {
                    if ctx.tasks.is_empty() { None } else { ctx.tasks.join_next().await }
                } else {
                    None
                }
            }, if app.current_op_context.is_some() => {
                if let Some(join_result) = result {
                    match join_result {
                        Ok(task_outcome) => {
                            let is_standard_op = matches!(task_outcome, TaskOutcome::AgentOperationComplete{..});

                            handle_task_outcome(&mut app, task_outcome).await;

                            if is_standard_op {
                                debug!(target: "app_actor_loop", "Agent task completed flag set to true.");
                                agent_task_completed = true;
                            }

                            // Check if we should signal ProcessingCompleted now
                            if agent_task_completed && active_agent_event_rx.is_none() {
                                debug!(target: "app_actor_loop", "Signaling ProcessingCompleted (Task done, receiver drained).");
                                app.emit_event(AppEvent::ProcessingCompleted);
                                agent_task_completed = false;
                            }
                        }
                        Err(join_err) => {
                            error!(target: "app_actor_loop", "Task join error: {}", join_err);
                            app.current_op_context = None;
                            active_agent_event_rx = None;
                            agent_task_completed = false;
                            app.emit_event(AppEvent::ProcessingCompleted);
                            app.emit_event(AppEvent::Error {
                                message: format!("A task failed unexpectedly: {join_err}")
                            });
                        }
                    }
                } else {
                    // JoinSet returned None - all tasks finished
                    if let Some(_ctx) = app.current_op_context.take() {
                        debug!(target: "app_actor_loop", "JoinSet empty. Clearing context.");
                        agent_task_completed = true;

                        if agent_task_completed && active_agent_event_rx.is_none() {
                            debug!(target: "app_actor_loop", "Signaling ProcessingCompleted (JoinSet empty, receiver drained).");
                            app.emit_event(AppEvent::ProcessingCompleted);
                            agent_task_completed = false;
                        }
                    }
                }
            }

            // Poll for incoming AgentEvents
            // Poll this *after* task completion to ensure correct ordering
            maybe_agent_event = async { active_agent_event_rx.as_mut().unwrap().recv().await },
            if active_agent_event_rx.is_some() => {
                match maybe_agent_event {
                    Some(event) => {
                        handle_agent_event(&mut app, event).await;
                    }
                    None => {
                        // Channel closed
                        debug!(target: "app_actor_loop", "Agent event channel closed.");
                        active_agent_event_rx = None;

                        if agent_task_completed {
                            debug!(target: "app_actor_loop", "Signaling ProcessingCompleted (Receiver closed, task completed).");
                            app.emit_event(AppEvent::ProcessingCompleted);
                            agent_task_completed = false;
                        }
                    }
                }
            }

            // Default branch if no other arms are ready
            else => {}
        }
    }
    info!(target: "app_actor_loop", "App actor loop finished.");
}

// Process the next approval request from the queue
async fn process_next_approval_request(app: &mut App, queue: &mut ApprovalQueue) {
    if queue.current.is_some() {
        debug!(target: "process_next_approval", "An approval request is already active.");
        return;
    }

    while let Some((id, tool_call, responder)) = queue.queued.pop_front() {
        if app.approved_tools.read().await.contains(&tool_call.name) {
            info!(target: "process_next_approval", "Auto-approving tool '{}' (ID: {})", tool_call.name, id);
            if responder.send(ApprovalDecision::Approved).is_err() {
                warn!(target: "process_next_approval", "Failed to send auto-approval for tool ID '{}'", id);
            }
        } else {
            // Not auto-approved, send to UI
            info!(target: "process_next_approval", "Sending tool approval request to UI for '{}' (ID: {})", tool_call.name, id);
            let parameters = tool_call.parameters.clone();
            let name = tool_call.name.clone();

            queue.current = Some((id.clone(), tool_call, responder));

            app.emit_event(AppEvent::RequestToolApproval {
                name,
                parameters,
                id,
            });
            return;
        }
    }
    debug!(target: "process_next_approval", "Approval queue processed.");
}

// Handle app commands
async fn handle_app_command(
    app: &mut App,
    command: AppCommand,
    approval_queue: &mut ApprovalQueue,
    active_agent_event_rx: &mut Option<mpsc::Receiver<AgentEvent>>,
) -> Result<bool> {
    debug!(target: "handle_app_command", "Received command: {:?}", command);

    match command {
        AppCommand::ProcessUserInput(message) => {
            if message.starts_with('/') {
                // Clear previous receiver if any before running command
                if active_agent_event_rx.is_some() {
                    warn!(target: "handle_app_command", "Clearing previous active agent event receiver due to new command input.");
                    *active_agent_event_rx = None;
                }
                match AppCommandType::parse(&message) {
                    Ok(cmd) => {
                        handle_slash_command(app, cmd).await;
                    }
                    Err(e) => {
                        app.emit_event(AppEvent::Error {
                            message: format!("Error parsing command: {e:?}"),
                        });
                    }
                }
            } else {
                // Regular user message, start a standard operation
                if active_agent_event_rx.is_some() {
                    warn!(target: "handle_app_command", "Clearing previous active agent event receiver due to new user input.");
                    *active_agent_event_rx = None;
                }
                match app.process_user_message(message).await {
                    Ok(maybe_receiver) => {
                        *active_agent_event_rx = maybe_receiver;
                    }
                    Err(e) => {
                        error!(target: "handle_app_command", "Error starting standard operation: {}", e);
                    }
                }
            }
            Ok(false)
        }
        AppCommand::EditMessage {
            message_id,
            new_content,
        } => {
            debug!(target: "handle_app_command", "Editing message {} with new content", message_id);

            // Cancel any existing operations first
            app.cancel_current_processing().await;
            if active_agent_event_rx.is_some() {
                warn!(target: "handle_app_command", "Clearing previous active agent event receiver due to message edit.");
                *active_agent_event_rx = None;
            }

            // Edit the message in the conversation. This removes the old branch and adds the new one.
            let (new_message_id, edited_message_opt, active_id) = {
                let mut conversation = app.conversation.lock().await;
                let result = conversation.edit_message(
                    &message_id,
                    vec![UserContent::Text {
                        text: new_content.clone(),
                    }],
                );

                // Attempt to fetch the newly created edited message (it will be the latest User message)
                let edited_msg = if result.is_some() {
                    conversation
                        .messages
                        .iter()
                        .rev()
                        .find(|m| matches!(m.data, MessageData::User { .. }))
                        .cloned()
                } else {
                    None
                };

                (result, edited_msg, conversation.active_message_id.clone())
            };

            // Notify the UI about the newly edited user message so it can appear immediately
            if let Some(edited_message) = edited_message_opt {
                app.emit_event(AppEvent::MessageAdded {
                    message: edited_message,
                    model: app.current_model.clone(),
                });
            }

            if new_message_id.is_some() {
                debug!(target: "handle_app_command", "Successfully edited message and created new branch");

                // Emit active message ID change event
                app.emit_event(AppEvent::ActiveMessageIdChanged {
                    message_id: active_id,
                });

                // This message is now the latest in the conversation.
                // We can now start a new agent operation.
                // This logic is adapted from `process_user_message`, but without adding a new message.
                app.current_op_context = Some(OpContext::new());
                app.emit_event(AppEvent::ProcessingStarted);

                match app.spawn_agent_operation().await {
                    Ok(maybe_receiver) => {
                        *active_agent_event_rx = maybe_receiver;
                    }
                    Err(e) => {
                        error!(target: "handle_app_command", "Error processing edited message: {}", e);
                        app.current_op_context = None;
                        app.emit_event(AppEvent::ProcessingCompleted);
                    }
                }
            } else {
                error!(target: "handle_app_command", "Failed to edit message {}", message_id);
            }
            Ok(false)
        }
        AppCommand::RestoreConversation {
            messages,
            approved_tools,
            approved_bash_patterns,
            active_message_id,
        } => {
            // Atomically restore entire conversation state
            debug!(target:"handle_app_command", "Restoring conversation with {} messages, {} approved tools, and {} approved bash patterns",
                messages.len(), approved_tools.len(), approved_bash_patterns.len());

            // Restore messages and active_message_id
            let mut conversation_guard = app.conversation.lock().await;
            conversation_guard.messages = messages;
            conversation_guard.active_message_id = active_message_id;
            drop(conversation_guard);

            // Restore approved tools
            *app.approved_tools.write().await = approved_tools;

            // Restore approved bash patterns
            *app.approved_bash_patterns.write().await = approved_bash_patterns;

            debug!(target:"handle_app_command", "Conversation restoration complete");
            Ok(false)
        }

        AppCommand::HandleToolResponse { id, approval } => {
            if let Some((current_id, current_tool_call, responder)) = approval_queue.current.take()
            {
                debug!(target: "handle_app_command", "Handling tool response for ID '{}', approval: {:?}", id, approval);
                if current_id != id {
                    error!(target: "handle_app_command", "Mismatched tool ID. Expected '{}', got '{}'", current_id, id);
                    approval_queue
                        .queued
                        .push_front((current_id, current_tool_call, responder));
                } else {
                    let decision = match approval {
                        ApprovalType::Once => {
                            debug!(target: "handle_app_command", "Approving tool call with ID '{}' once.", id);
                            ApprovalDecision::Approved
                        }
                        ApprovalType::AlwaysTool => {
                            debug!(target: "handle_app_command", "Approving tool call with ID '{}' always.", id);
                            app.approved_tools
                                .write()
                                .await
                                .insert(current_tool_call.name.clone());
                            ApprovalDecision::Approved
                        }
                        ApprovalType::AlwaysBashPattern(pattern) => {
                            debug!(target: "handle_app_command", "Approving bash command '{}' always.", pattern);
                            app.approved_bash_patterns
                                .write()
                                .await
                                .insert(pattern.clone());
                            ApprovalDecision::Approved
                        }
                        ApprovalType::Denied => {
                            debug!(target: "handle_app_command", "Denying tool call with ID '{}'.", id);
                            ApprovalDecision::Denied
                        }
                    };

                    debug!(target: "handle_app_command", "Sending approval decision for tool ID '{}': {:?}", id, decision);
                    if responder.send(decision).is_err() {
                        error!(target: "handle_app_command", "Failed to send approval decision for tool ID '{}'", id);
                    }
                }
            } else {
                error!(target: "handle_app_command", "Received tool response for ID '{}' but no current approval request was active.", id);
            }

            process_next_approval_request(app, approval_queue).await;
            Ok(false)
        }

        AppCommand::CancelProcessing => {
            debug!(target: "handle_app_command", "Handling CancelProcessing command.");
            app.cancel_current_processing().await;
            approval_queue.cancel_all();

            if active_agent_event_rx.is_some() {
                debug!(target: "handle_app_command", "Clearing active agent event receiver due to cancellation.");
                *active_agent_event_rx = None;
            }
            app.emit_event(AppEvent::ProcessingCompleted);
            Ok(false)
        }

        AppCommand::ExecuteBashCommand { command } => {
            debug!(target: "handle_app_command", "Executing bash command: {}", command);

            // Cancel any existing operations first
            app.cancel_current_processing().await;

            // Create unique operation ID
            let op_id = uuid::Uuid::new_v4();
            let start_time = Instant::now();

            // Emit Started event
            app.emit_event(AppEvent::Started {
                id: op_id,
                op: Operation::Bash {
                    cmd: command.clone(),
                },
            });

            // Create OpContext for cancellable operation
            let mut op_context = OpContext::new_with_id(op_id);
            let token = op_context.cancel_token.clone();

            // Create a tool call for the bash command
            let tool_call = ToolCall {
                id: format!("bash_{}", uuid::Uuid::new_v4()),
                name: BASH_TOOL_NAME.to_string(),
                parameters: serde_json::to_value(BashParams {
                    command: command.clone(),
                    timeout: None,
                })
                .map_err(|e| Error::BashCommandError(e.to_string()))?,
            };

            // Clone necessary values for the spawned task
            let tool_executor = app.tool_executor.clone();
            let command_clone = command.clone();

            // Spawn the bash execution task
            op_context.tasks.spawn(async move {
                let result = tool_executor.execute_tool_direct(&tool_call, token).await;

                TaskOutcome::BashCommandComplete {
                    op_id,
                    command: command_clone,
                    start_time,
                    result,
                }
            });

            // Store the operation context
            app.current_op_context = Some(op_context);

            Ok(false)
        }
        AppCommand::Shutdown => {
            info!(target: "handle_app_command", "Received Shutdown command.");
            app.cancel_current_processing().await;
            approval_queue.cancel_all();
            *active_agent_event_rx = None;
            Ok(true)
        }
        AppCommand::GetCurrentConversation => {
            // This command is now handled synchronously via RPC
            // Should not be called directly anymore
            warn!(target:"handle_app_command", "GetCurrentConversation command received - this should use the sync RPC instead");
            Ok(false)
        }
        AppCommand::RequestToolApprovalInternal {
            tool_call,
            responder,
        } => {
            let tool_id = tool_call.id.clone();
            let tool_name = tool_call.name.clone();

            info!(target: "handle_app_command", "Received internal request for tool approval: '{}' (ID: {})", tool_name, tool_id);

            approval_queue.add_request(tool_id, tool_call, responder);
            process_next_approval_request(app, approval_queue).await;
            Ok(false)
        }

        AppCommand::ExecuteCommand(cmd) => {
            warn!(target: "handle_app_command", "Received ExecuteCommand: {}", cmd.as_command_str());
            if active_agent_event_rx.is_some() {
                warn!(target: "handle_app_command", "Clearing previous active agent event receiver due to ExecuteCommand.");
                *active_agent_event_rx = None;
            }
            handle_slash_command(app, cmd).await;
            Ok(false)
        }

        AppCommand::RequestWorkspaceFiles => {
            info!(target: "app.handle_app_command", "Received RequestWorkspaceFiles command");
            app.emit_workspace_files().await;
            Ok(false)
        }
    }
}

// Handle slash commands
async fn handle_slash_command(app: &mut App, command: AppCommandType) {
    let command_str = command.as_command_str();
    match app.handle_command(command.clone()).await {
        Ok(response_option) => {
            if let Some(response) = response_option {
                app.emit_event(AppEvent::CommandResponse {
                    command,
                    response,
                    id: format!("cmd_resp_{}", uuid::Uuid::new_v4()),
                });
            }
        }
        Err(e) => {
            error!(target: "handle_slash_command", "Error running command '{}': {}", command_str, e);
            app.emit_event(AppEvent::Error {
                message: format!("Command failed: {e}"),
            });
        }
    }
}
// Handle agent events
async fn handle_agent_event(app: &mut App, event: AgentEvent) {
    debug!(target: "handle_agent_event", "Handling event: {:?}", event);

    match event {
        AgentEvent::MessageFinal(message) => match message.data {
            MessageData::Tool {
                ref tool_use_id,
                ref result,
            } => {
                let conversation_guard = app.conversation.lock().await;
                let tool_name = conversation_guard
                    .find_tool_name_by_id(tool_use_id)
                    .unwrap_or_else(|| "unknown_tool".to_string());
                drop(conversation_guard);

                let is_error = matches!(result, ToolResult::Error(_));
                if is_error {
                    if let steer_tools::result::ToolResult::Error(e) = result {
                        // Extract concise error message from structured ToolError
                        let error_message = match e {
                            steer_tools::ToolError::Execution { message, .. } => message.clone(),
                            steer_tools::ToolError::Io { message, .. } => message.clone(),
                            steer_tools::ToolError::InvalidParams(_, msg) => msg.clone(),
                            _ => e.to_string(),
                        };

                        app.emit_event(AppEvent::ToolCallFailed {
                            id: tool_use_id.clone(),
                            name: tool_name.clone(),
                            error: error_message,
                            model: app.current_model.clone(),
                        });
                    }
                } else {
                    app.emit_event(AppEvent::ToolCallCompleted {
                        id: tool_use_id.clone(),
                        name: tool_name.clone(),
                        result: result.clone(),
                        model: app.current_model.clone(),
                    });

                    let mutating_tools =
                        ["edit", "replace", "bash", "write_file", "multi_edit_file"];
                    if mutating_tools.contains(&tool_name.as_str()) {
                        app.emit_event(AppEvent::WorkspaceChanged);
                        app.emit_workspace_files().await;
                    }
                }
                app.add_message(message.clone()).await;
            }
            MessageData::Assistant { .. } => {
                app.add_message(message).await;
            }
            MessageData::User { .. } => {
                warn!(target: "handle_agent_event", "Received MessageFinal for user message. This should not happen.");
            }
        },
        AgentEvent::ExecutingTool {
            tool_call_id,
            name,
            parameters,
        } => {
            app.emit_event(AppEvent::ToolCallStarted {
                id: tool_call_id,
                name,
                parameters,
                model: app.current_model.clone(),
            });
        }
    }
}

// Handle task outcomes
async fn handle_task_outcome(app: &mut App, task_outcome: TaskOutcome) {
    match task_outcome {
        TaskOutcome::AgentOperationComplete { result } => {
            info!(target: "handle_task_outcome", "Standard agent operation task completed processing.");

            match result {
                Ok(_) => {
                    info!(target: "handle_task_outcome", "Agent operation task reported success.");
                }
                Err(e) => {
                    error!(target: "handle_task_outcome", "Agent operation task reported failure: {}", e);
                    // Emit error event only if it wasn't a cancellation
                    if !matches!(e, AgentExecutorError::Cancelled) {
                        app.emit_event(AppEvent::Error {
                            message: e.to_string(),
                        });
                    }
                }
            }

            // Clear the context
            debug!(target: "handle_task_outcome", "Clearing OpContext for completed standard operation.");
            app.current_op_context = None;
        }
        TaskOutcome::DispatchAgentResult { result } => {
            info!(target: "handle_task_outcome", "Dispatch agent operation task completed.");

            match result {
                Ok(response_text) => {
                    info!(target: "handle_task_outcome", "Dispatch agent successful.");

                    app.add_message_from_data(MessageData::Assistant {
                        content: vec![AssistantContent::Text {
                            text: format!("Dispatch Agent Result:\n{response_text}"),
                        }],
                    })
                    .await;
                }
                Err(e) => {
                    error!(target: "handle_task_outcome", "Dispatch agent failed: {}", e);
                    app.emit_event(AppEvent::Error {
                        message: e.to_string(),
                    });
                }
            }

            // Clear context and stop thinking immediately for dispatch operations
            debug!(target: "handle_task_outcome", "Clearing OpContext and signaling ProcessingCompleted for dispatch operation.");
            app.current_op_context = None;
        }
        TaskOutcome::BashCommandComplete {
            op_id,
            command,
            start_time,
            result,
        } => {
            info!(target: "handle_task_outcome", "Bash command task completed.");

            let elapsed = start_time.elapsed();

            match result {
                Ok(output) => {
                    // Get the formatted output from the typed result
                    let output_str = output.llm_format();

                    // Parse the output to extract stdout/stderr/exit code
                    let (stdout, stderr, exit_code) = parse_bash_output(&output_str);

                    app.add_message_from_data(MessageData::User {
                        content: vec![UserContent::CommandExecution {
                            command: command.clone(),
                            stdout,
                            stderr,
                            exit_code,
                        }],
                    })
                    .await;

                    // Emit Finished event
                    app.emit_event(AppEvent::Finished {
                        id: op_id,
                        outcome: OperationOutcome::Bash {
                            elapsed,
                            result: Ok(()),
                        },
                    });

                    // A bash command can mutate the workspace; notify listeners.
                    app.emit_event(AppEvent::WorkspaceChanged);
                    app.emit_workspace_files().await;
                }
                Err(e) => {
                    error!(target: "handle_task_outcome", "Failed to execute bash command: {}", e);

                    // Handle cancellation specially - no error message
                    if matches!(e, steer_tools::ToolError::Cancelled(_)) {
                        // Emit Finished event with cancellation
                        app.emit_event(AppEvent::Finished {
                            id: op_id,
                            outcome: OperationOutcome::Bash {
                                elapsed,
                                result: Err(BashError {
                                    exit_code: -130, // Traditional exit code for SIGINT
                                    stderr: "Cancelled".to_string(),
                                }),
                            },
                        });
                    } else {
                        // Add error as a command execution with error output
                        let parent_id = app.get_active_message_id().await;
                        let error_message = format!("Error executing command: {e}");
                        let message = Message {
                            data: MessageData::User {
                                content: vec![UserContent::CommandExecution {
                                    command: command.clone(),
                                    stdout: String::new(),
                                    stderr: error_message.clone(),
                                    exit_code: -1,
                                }],
                            },
                            timestamp: Message::current_timestamp(),
                            id: Message::generate_id("user", Message::current_timestamp()),
                            parent_message_id: parent_id,
                        };
                        app.add_message(message).await;

                        // Emit Finished event with error
                        app.emit_event(AppEvent::Finished {
                            id: op_id,
                            outcome: OperationOutcome::Bash {
                                elapsed,
                                result: Err(BashError {
                                    exit_code: -1,
                                    stderr: error_message,
                                }),
                            },
                        });

                        // A bash command can mutate the workspace; notify listeners.
                        app.emit_event(AppEvent::WorkspaceChanged);
                        app.emit_workspace_files().await;
                    }
                }
            }

            debug!(target: "handle_task_outcome", "Clearing OpContext and signaling ProcessingCompleted for bash operation.");
            app.current_op_context = None;
        }
    }
}

async fn create_system_prompt_with_workspace(
    model: Option<ModelId>,
    workspace: &dyn crate::workspace::Workspace,
) -> Result<String> {
    let env_info = workspace.environment().await?;

    // Use model-specific prompt if available, otherwise use default
    let system_prompt_body = if let Some(model_id) = model {
        get_model_system_prompt(model_id)
    } else {
        crate::prompts::default_system_prompt()
    };

    let prompt = format!(
        r#"{}

{}"#,
        system_prompt_body,
        env_info.as_context()
    );
    Ok(prompt)
}

fn get_model_system_prompt(model_id: ModelId) -> String {
    use crate::config::model::builtin;

    // Map known model IDs to specific prompts
    if model_id == builtin::gpt_5_2025_08_07() {
        crate::prompts::gpt5_system_prompt()
    } else if model_id == builtin::o3_2025_04_16()
        || model_id == builtin::gpt_4_1_2025_04_14()
        || model_id == builtin::o4_mini_2025_04_16()
        || model_id == builtin::grok_4_0709()
    {
        crate::prompts::o3_system_prompt()
    } else if model_id.0 == crate::config::provider::google()
        && (model_id.1.starts_with("gemini-2.5") || model_id.1.starts_with("gemini-"))
    {
        crate::prompts::gemini_system_prompt()
    } else if model_id == builtin::claude_sonnet_4_20250514()
        || model_id == builtin::claude_opus_4_20250514()
        || model_id == builtin::claude_opus_4_1_20250805()
    {
        crate::prompts::claude_system_prompt()
    } else {
        crate::prompts::default_system_prompt()
    }
}

fn parse_bash_output(output: &str) -> (String, String, i32) {
    // Check if this is an error output from the bash tool
    if output.starts_with("Command failed with exit code") {
        // Parse the error format:
        // "Command failed with exit code {}\n--- STDOUT ---\n{}\n--- STDERR ---\n{}"
        let mut stdout = String::new();
        let mut stderr = String::new();
        let mut exit_code = -1;

        let lines: Vec<&str> = output.lines().collect();
        let mut i = 0;

        // Extract exit code from first line
        if let Some(first_line) = lines.first() {
            if let Some(code_str) = first_line.strip_prefix("Command failed with exit code ") {
                exit_code = code_str.parse().unwrap_or(-1);
            }
        }

        // Find stdout section
        while i < lines.len() {
            if lines[i] == "--- STDOUT ---" {
                i += 1;
                while i < lines.len() && lines[i] != "--- STDERR ---" {
                    if !stdout.is_empty() {
                        stdout.push('\n');
                    }
                    stdout.push_str(lines[i]);
                    i += 1;
                }
            } else if lines[i] == "--- STDERR ---" {
                i += 1;
                while i < lines.len() {
                    if !stderr.is_empty() {
                        stderr.push('\n');
                    }
                    stderr.push_str(lines[i]);
                    i += 1;
                }
            } else {
                i += 1;
            }
        }

        (stdout, stderr, exit_code)
    } else {
        // Success case - output is just stdout
        (output.to_string(), String::new(), 0)
    }
}

#[cfg(test)]
mod pattern_tests {
    use super::*;

    #[test]
    fn test_matches_any_pattern_exact_match() {
        let patterns = vec!["git status".to_string(), "git log".to_string()];

        assert!(matches_any_pattern("git status", &patterns));
        assert!(matches_any_pattern("git log", &patterns));
        assert!(!matches_any_pattern("git push", &patterns));
    }

    #[test]
    fn test_matches_any_pattern_glob_patterns() {
        let patterns = vec![
            "git *".to_string(),
            "npm run*".to_string(),
            "cargo test*".to_string(),
        ];

        // Test glob matching
        assert!(matches_any_pattern("git status", &patterns));
        assert!(matches_any_pattern("git log -10", &patterns));
        assert!(matches_any_pattern("npm run test", &patterns));
        assert!(matches_any_pattern("npm run build", &patterns));
        assert!(matches_any_pattern("cargo test", &patterns));
        assert!(matches_any_pattern("cargo test --all", &patterns));

        // Test non-matches
        assert!(!matches_any_pattern("npm install", &patterns));
        assert!(!matches_any_pattern("cargo build", &patterns));
        assert!(!matches_any_pattern("ls -la", &patterns));
    }

    #[test]
    fn test_matches_any_pattern_complex_patterns() {
        let patterns = vec![
            "docker run*".to_string(),
            "kubectl apply -f*".to_string(),
            "terraform *".to_string(),
        ];

        // Test glob matches
        assert!(matches_any_pattern("docker run nginx", &patterns));
        assert!(matches_any_pattern("docker run -it ubuntu bash", &patterns));
        assert!(matches_any_pattern(
            "kubectl apply -f deployment.yaml",
            &patterns
        ));
        assert!(matches_any_pattern("terraform plan", &patterns));
        assert!(matches_any_pattern("terraform apply", &patterns));

        // Test non-matches
        assert!(!matches_any_pattern("docker ps", &patterns));
        assert!(!matches_any_pattern("kubectl get pods", &patterns));
        assert!(!matches_any_pattern("git status", &patterns));
    }

    #[test]
    fn test_matches_any_pattern_empty_patterns() {
        let patterns: Vec<String> = vec![];
        assert!(!matches_any_pattern("git status", &patterns));
    }

    #[test]
    fn test_matches_any_pattern_special_chars() {
        let patterns = vec![
            "echo \"hello world\"".to_string(),
            "python -c 'print(\"test\")'".to_string(),
            "ls | grep .txt".to_string(),
        ];

        // Test exact matches with special characters
        assert!(matches_any_pattern("echo \"hello world\"", &patterns));
        assert!(matches_any_pattern(
            "python -c 'print(\"test\")'",
            &patterns
        ));
        assert!(matches_any_pattern("ls | grep .txt", &patterns));

        // Test non-matches
        assert!(!matches_any_pattern("echo hello world", &patterns));
    }
}