Unify message pathways for subagents and main agent

Author: Snehal-Reddy

src/agent.rs

@@ -1,6 +1,7 @@
 //! Agent loop: context builder, session load/save/summarize, LLM + tool_calls loop, subagent runner.
 
 use std::path::Path;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
 use tokio::sync::mpsc;
@@ -133,6 +134,7 @@ pub async fn run_agent_loop(
                                 .clone()
                                 .unwrap_or_else(|| "telegram".to_string()),
                         });
+                        tool_ctx.delivered.store(true, Ordering::Relaxed);
                     }
                 }
             }
@@ -302,6 +304,7 @@ pub(crate) async fn run_subagent(
         chat_id: Some(chat_id),
         channel: Some(channel),
         outbound_tx: Some(outbound_tx),
+        delivered: Default::default(),
     };
 
     match run_agent_loop(

src/main.rs

@@ -4,7 +4,7 @@
 
 use std::path::PathBuf;
 use std::sync::Arc;
-use std::sync::atomic::{AtomicI64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
 
 use tokio::sync::mpsc;
 
@@ -177,12 +177,14 @@ async fn main() {
             last_chat_id.store(msg.chat_id, Ordering::Relaxed);
         }
 
+        let delivered = Arc::new(AtomicBool::new(false));
         let tool_ctx = tools::ToolCtx {
             workspace: workspace.clone(),
             restrict_to_workspace: restrict,
             chat_id: Some(msg.chat_id),
             channel: Some(msg.channel.clone()),
             outbound_tx: Some(Arc::new(outbound_tx.clone())),
+            delivered: Arc::clone(&delivered),
         };
         let chat_id_str = msg.chat_id.to_string();
 
@@ -240,12 +242,16 @@ async fn main() {
             continue;
         }
 
-        let _ = outbound_tx
-            .send(OutboundMsg {
-                chat_id: msg.chat_id,
-                text: reply,
-                channel: msg.channel,
-            })
-            .await;
+        // Skip if a tool (message tool or for_user result) already sent content to the user
+        // during the agent loop, to avoid delivering the same response twice.
+        if !delivered.load(Ordering::Relaxed) {
+            let _ = outbound_tx
+                .send(OutboundMsg {
+                    chat_id: msg.chat_id,
+                    text: reply,
+                    channel: msg.channel,
+                })
+                .await;
+        }
     }
 }

src/tools/context.rs

@@ -1,6 +1,7 @@
 //! Execution context for tools: workspace, chat, outbound channel.
 
 use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 
 use tokio::sync::mpsc;
@@ -20,4 +21,8 @@ pub struct ToolCtx {
     pub channel: Option<String>,
     /// Send outbound messages (e.g. to Telegram). Used by message tool.
     pub outbound_tx: Option<Arc<mpsc::Sender<OutboundMsg>>>,
+    /// Set to true when any user-visible message has been sent during this request.
+    /// Shared via Arc so clones (e.g. sub-ctx) observe the same flag.
+    /// main.rs reads this after the agent loop to skip redundant delivery.
+    pub delivered: Arc<AtomicBool>,
 }

src/tools/cron.rs

@@ -1011,6 +1011,7 @@ mod tool_tests {
             chat_id,
             channel: None,
             outbound_tx: None,
+            delivered: Default::default(),
         }
     }
 

src/tools/file.rs

@@ -347,6 +347,7 @@ mod tests {
             chat_id: None,
             channel: None,
             outbound_tx: None,
+            delivered: Default::default(),
         };
         let rel = f.strip_prefix(&dir).unwrap().to_str().unwrap();
         let args = serde_json::json!({ "path": rel });

src/tools/git.rs

@@ -178,6 +178,7 @@ mod tests {
             chat_id: None,
             channel: None,
             outbound_tx: None,
+            delivered: Default::default(),
         }
     }
 

src/tools/grep_dir.rs

@@ -234,6 +234,7 @@ mod tests {
             chat_id: None,
             channel: None,
             outbound_tx: None,
+            delivered: Default::default(),
         }
     }
 

src/tools/message.rs

@@ -1,5 +1,7 @@
 //! Send text to user via outbound queue (Telegram); used by main agent and subagent.
 
+use std::sync::atomic::Ordering;
+
 use serde_json::Value;
 
 use crate::telegram::OutboundMsg;
@@ -61,7 +63,10 @@ impl Tool for MessageTool {
                 channel,
             };
             match tx.try_send(msg) {
-                Ok(()) => ToolResult::silent("sent"),
+                Ok(()) => {
+                    ctx.delivered.store(true, Ordering::Relaxed);
+                    ToolResult::silent("sent")
+                }
                 Err(e) => ToolResult::error(e.to_string()),
             }
         })

src/tools/registry.rs

@@ -175,6 +175,7 @@ mod tests {
             chat_id: None,
             channel: None,
             outbound_tx: None,
+            delivered: Default::default(),
         };
         let args = serde_json::json!({ "path": "." });
         let res = reg.execute(&ctx, "read_file", &args).await;

src/tools/search.rs

@@ -205,6 +205,7 @@ mod tests {
             chat_id: None,
             channel: None,
             outbound_tx: None,
+            delivered: Default::default(),
         }
     }