fix: broken CLI formatting (#662)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: tusharmath

crates/forge_domain/src/chat_response.rs

@@ -7,7 +7,7 @@ use crate::{Event, ToolCallFull, ToolResult, Usage};
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub enum ChatResponse {
-    Text(String),
+    Text { text: String, is_complete: bool },
     ToolCallStart(ToolCallFull),
     ToolCallEnd(ToolResult),
     Usage(Usage),

crates/forge_domain/src/error.rs

@@ -39,6 +39,7 @@ pub enum Error {
 
     #[error("Missing description for agent: {0}")]
     MissingAgentDescription(AgentId),
+
     #[error("Missing model for agent: {0}")]
     MissingModel(AgentId),
 }

crates/forge_domain/src/lib.rs

@@ -25,6 +25,7 @@ mod template;
 mod text_utils;
 mod tool;
 mod tool_call;
+mod tool_call_context;
 mod tool_call_parser;
 mod tool_choice;
 mod tool_definition;
@@ -59,6 +60,7 @@ pub use template::*;
 pub use text_utils::*;
 pub use tool::*;
 pub use tool_call::*;
+pub use tool_call_context::*;
 pub use tool_call_parser::*;
 pub use tool_choice::*;
 pub use tool_definition::*;

crates/forge_domain/src/orch.rs

@@ -24,6 +24,12 @@ pub struct AgentMessage<T> {
     pub message: T,
 }
 
+impl<T> AgentMessage<T> {
+    pub fn new(agent: AgentId, message: T) -> Self {
+        Self { agent, message }
+    }
+}
+
 #[derive(Clone)]
 pub struct Orchestrator<App> {
     services: Arc<App>,
@@ -89,7 +95,7 @@ impl<A: Services> Orchestrator<A> {
         if let Some(sender) = &self.sender {
             // Send message if it's a Custom type or if hide_content is false
             let show_text = !agent.hide_content.unwrap_or_default();
-            let can_send = !matches!(&message, ChatResponse::Text(_)) || show_text;
+            let can_send = !matches!(&message, ChatResponse::Text { .. }) || show_text;
             if can_send {
                 sender
                     .send(Ok(AgentMessage { agent: agent.id.clone(), message }))
@@ -163,8 +169,11 @@ impl<A: Services> Orchestrator<A> {
             let message = message?;
             messages.push(message.clone());
             if let Some(content) = message.content {
-                self.send(agent, ChatResponse::Text(content.as_str().to_string()))
-                    .await?;
+                self.send(
+                    agent,
+                    ChatResponse::Text { text: content.as_str().to_string(), is_complete: false },
+                )
+                .await?;
             }
 
             if let Some(usage) = message.usage {
@@ -246,7 +255,16 @@ impl<A: Services> Orchestrator<A> {
             self.dispatch_spawned(event).await?;
             Ok(ToolResult::from(tool_call.clone()).success("Event Dispatched Successfully"))
         } else {
-            Ok(self.services.tool_service().call(tool_call.clone()).await)
+            Ok(self
+                .services
+                .tool_service()
+                .call(
+                    ToolCallContext::default()
+                        .sender(self.sender.clone())
+                        .agent_id(agent.id.clone()),
+                    tool_call.clone(),
+                )
+                .await)
         }
     }
 

crates/forge_domain/src/services.rs

@@ -5,7 +5,7 @@ use serde_json::Value;
 use crate::{
     Agent, Attachment, ChatCompletionMessage, Compact, Context, Conversation, ConversationId,
     Environment, Event, EventContext, Model, ModelId, ResultStream, SystemContext, Template,
-    ToolCallFull, ToolDefinition, ToolResult, Workflow,
+    ToolCallContext, ToolCallFull, ToolDefinition, ToolResult, Workflow,
 };
 
 #[async_trait::async_trait]
@@ -21,7 +21,7 @@ pub trait ProviderService: Send + Sync + 'static {
 #[async_trait::async_trait]
 pub trait ToolService: Send + Sync {
     // TODO: should take `call` by reference
-    async fn call(&self, call: ToolCallFull) -> ToolResult;
+    async fn call(&self, context: ToolCallContext, call: ToolCallFull) -> ToolResult;
     fn list(&self) -> Vec<ToolDefinition>;
     fn usage_prompt(&self) -> String;
 }

crates/forge_domain/src/tool.rs

@@ -1,7 +1,7 @@
 use schemars::JsonSchema;
 use serde_json::Value;
 
-use crate::{ExecutableTool, NamedTool, ToolDefinition, ToolDescription};
+use crate::{ExecutableTool, NamedTool, ToolCallContext, ToolDefinition, ToolDescription};
 
 struct JsonTool<T>(T);
 
@@ -18,9 +18,9 @@ where
 {
     type Input = Value;
 
-    async fn call(&self, input: Self::Input) -> anyhow::Result<String> {
+    async fn call(&self, context: ToolCallContext, input: Self::Input) -> anyhow::Result<String> {
         let input: T::Input = serde_json::from_value(input)?;
-        self.0.call(input).await
+        self.0.call(context, input).await
     }
 }
 

crates/forge_domain/src/tool_call_context.rs

@@ -0,0 +1,65 @@
+use std::sync::Arc;
+
+use derive_setters::Setters;
+use tokio::sync::mpsc::Sender;
+
+use crate::{AgentId, AgentMessage, ChatResponse};
+
+/// Type alias for Arc<Sender<Result<AgentMessage<ChatResponse>>>>
+type ArcSender = Arc<Sender<anyhow::Result<AgentMessage<ChatResponse>>>>;
+
+/// Provides additional context for tool calls.
+/// Currently empty but structured to allow for future extension.
+#[derive(Default, Clone, Debug, Setters)]
+pub struct ToolCallContext {
+    #[setters(strip_option)]
+    pub agent_id: Option<AgentId>,
+    pub sender: Option<ArcSender>,
+}
+
+impl ToolCallContext {
+    /// Send a message through the sender if available
+    pub async fn send(&self, agent_message: AgentMessage<ChatResponse>) -> anyhow::Result<()> {
+        if let Some(sender) = &self.sender {
+            sender.send(Ok(agent_message)).await?
+        }
+        Ok(())
+    }
+
+    pub async fn send_text(&self, content: String) -> anyhow::Result<()> {
+        if let Some(agent_id) = &self.agent_id {
+            self.send(AgentMessage::new(
+                agent_id.clone(),
+                ChatResponse::Text { text: content.as_str().to_string(), is_complete: true },
+            ))
+            .await
+        } else {
+            Ok(())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_context() {
+        let context = ToolCallContext::default();
+        assert!(context.sender.is_none());
+    }
+
+    #[test]
+    fn test_for_tests() {
+        let context = ToolCallContext::default();
+        assert!(context.sender.is_none());
+    }
+
+    #[test]
+    fn test_with_sender() {
+        // This is just a type check test - we don't actually create a sender
+        // as it's complex to set up in a unit test
+        let context = ToolCallContext::default();
+        assert!(context.sender.is_none());
+    }
+}

crates/forge_domain/src/tool_definition.rs

@@ -6,7 +6,7 @@ use schemars::JsonSchema;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
-use crate::{NamedTool, ToolName, UsageParameterPrompt, UsagePrompt};
+use crate::{NamedTool, ToolCallContext, ToolName, UsageParameterPrompt, UsagePrompt};
 
 ///
 /// Refer to the specification over here:
@@ -125,5 +125,5 @@ pub trait ToolDescription {
 pub trait ExecutableTool {
     type Input: DeserializeOwned;
 
-    async fn call(&self, input: Self::Input) -> anyhow::Result<String>;
+    async fn call(&self, context: ToolCallContext, input: Self::Input) -> anyhow::Result<String>;
 }

crates/forge_inte/tests/api_spec.rs

@@ -62,7 +62,7 @@ impl Fixture {
             .with_context(|| "Failed to initialize chat")
             .unwrap()
             .filter_map(|message| match message.unwrap() {
-                AgentMessage { message: ChatResponse::Text(text), .. } => Some(text),
+                AgentMessage { message: ChatResponse::Text { text, .. }, .. } => Some(text),
                 _ => None,
             })
             .collect::<Vec<_>>()

crates/forge_main/src/auto_update.rs

@@ -1,8 +1,11 @@
 use std::process::Stdio;
 
 use anyhow::Result;
+use forge_tracker::EventKind;
 use tokio::process::Command;
 
+use crate::TRACKER;
+
 /// Runs npm update in the background, failing silently
 pub async fn update_forge() {
     // Spawn a new task that won't block the main application
@@ -37,17 +40,9 @@ async fn perform_update() -> Result<()> {
 
 /// Sends an event to the tracker when an update fails
 async fn send_update_failure_event(error_msg: &str) -> anyhow::Result<()> {
-    use std::sync::OnceLock;
-
-    use forge_tracker::{EventKind, Tracker};
-
-    // Use a static tracker instance to solve the lifetime issue
-    static TRACKER: OnceLock<Tracker> = OnceLock::new();
-    let tracker = TRACKER.get_or_init(Tracker::default);
-
     // Ignore the result since we are failing silently
     // This is safe because we're using a static tracker with 'static lifetime
-    let _ = tracker
+    let _ = TRACKER
         .dispatch(EventKind::Error(error_msg.to_string()))
         .await;
 

crates/forge_main/src/input.rs

@@ -1,15 +1,15 @@
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use async_trait::async_trait;
 use forge_api::Environment;
 use forge_display::TitleFormat;
 use tokio::fs;
 
 use crate::console::CONSOLE;
 use crate::editor::{ForgeEditor, ReadResult};
-use crate::model::{Command, ForgeCommandManager, UserInput};
+use crate::model::{Command, ForgeCommandManager};
 use crate::prompt::ForgePrompt;
+use crate::TRACKER;
 
 /// Console implementation for handling user input via command line.
 #[derive(Debug)]
@@ -25,18 +25,16 @@ impl Console {
     }
 }
 
-#[async_trait]
-impl UserInput for Console {
-    type PromptInput = ForgePrompt;
-    async fn upload<P: Into<PathBuf> + Send>(&self, path: P) -> anyhow::Result<Command> {
+impl Console {
+    pub async fn upload<P: Into<PathBuf> + Send>(&self, path: P) -> anyhow::Result<Command> {
         let path = path.into();
         let content = fs::read_to_string(&path).await?.trim().to_string();
 
         CONSOLE.writeln(content.clone())?;
         Ok(Command::Message(content))
     }
 
-    async fn prompt(&self, prompt: Option<Self::PromptInput>) -> anyhow::Result<Command> {
+    pub async fn prompt(&self, prompt: Option<ForgePrompt>) -> anyhow::Result<Command> {
         CONSOLE.writeln("")?;
 
         let mut engine = ForgeEditor::new(self.env.clone(), self.command.clone());
@@ -49,9 +47,7 @@ impl UserInput for Console {
                 ReadResult::Exit => return Ok(Command::Exit),
                 ReadResult::Empty => continue,
                 ReadResult::Success(text) => {
-                    tokio::spawn(
-                        crate::ui::TRACKER.dispatch(forge_tracker::EventKind::Prompt(text.clone())),
-                    );
+                    tokio::spawn(TRACKER.dispatch(forge_tracker::EventKind::Prompt(text.clone())));
                     match self.command.parse(&text) {
                         Ok(command) => return Ok(command),
                         Err(e) => {

crates/forge_main/src/lib.rs

@@ -14,4 +14,8 @@ mod ui;
 
 pub use auto_update::update_forge;
 pub use cli::Cli;
+use lazy_static::lazy_static;
 pub use ui::UI;
+lazy_static! {
+    pub static ref TRACKER: forge_tracker::Tracker = forge_tracker::Tracker::default();
+}

crates/forge_main/src/model.rs

@@ -1,7 +1,5 @@
-use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 
-use async_trait::async_trait;
 use forge_api::{Model, Workflow};
 use strum::{EnumProperty, IntoEnumIterator};
 use strum_macros::{EnumIter, EnumProperty};
@@ -256,36 +254,6 @@ impl Command {
     }
 }
 
-/// A trait for handling user input in the application.
-///
-/// This trait defines the core functionality needed for processing
-/// user input, whether it comes from a command line interface,
-/// GUI, or file system.
-#[async_trait]
-pub trait UserInput {
-    type PromptInput;
-    /// Read content from a file and convert it to the input type.
-    ///
-    /// # Arguments
-    /// * `path` - The path to the file to read
-    ///
-    /// # Returns
-    /// * `Ok(Input)` - Successfully read and parsed file content
-    /// * `Err` - Failed to read or parse file
-    async fn upload<P: Into<PathBuf> + Send>(&self, path: P) -> anyhow::Result<Command>;
-
-    /// Prompts for user input with optional help text and initial value.
-    ///
-    /// # Arguments
-    /// * `help_text` - Optional help text to display with the prompt
-    /// * `initial_text` - Optional initial text to populate the input with
-    ///
-    /// # Returns
-    /// * `Ok(Input)` - Successfully processed input
-    /// * `Err` - An error occurred during input processing
-    async fn prompt(&self, input: Option<Self::PromptInput>) -> anyhow::Result<Command>;
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;