Make delegate an LLM tool, not a slash command.

Diff

3 files changed, +198 -158

//! `modifiers` so control chords do not fall through to plain character input.

use crate::acp;
use crate::acp_harness::{AcpEvent, AcpHarness};
use crate::runtime::{CoderRuntimeSession, Control};
use crate::tui::{CoderUi, Entry, Role};
use std::sync::mpsc;
use std::path::PathBuf;
use crossterm::{
    event::{
        self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers,

use std::io::{stderr, stdout};
use std::time::Duration;

#[derive(Debug, Clone)]
pub enum DelegateControl {
    Tool { agent: String, title: String },
    Text(String),
    Done,
    Error(String),
}

pub async fn run_tui() -> Result<(), Box<dyn std::error::Error>> {
    if !atty_is_terminal() {
        println!("Non-interactive terminal detected. Run coder-lite from a TTY.");

    terminal.show_cursor()?;

    let (tx, rx) = mpsc::channel::<Control>();
    let (delegate_tx, delegate_rx) = mpsc::channel::<DelegateControl>();
    let mut ui = CoderUi::new();

    match acp::find_agents().await {

        while let Ok(control) = rx.try_recv() {
            match control {
                Control::Chunk(chunk) => {
                    if let Some(last) = ui.entries.last_mut() {
                    // Append text to the current assistant entry.
                    if let Some(last) = ui
                        .entries
                        .iter_mut()
                        .rfind(|e| e.role == Role::Assistant)
                    {
                        last.text.push_str(&chunk);
                        ui.scroll_override = None;
                    }
                }
                Control::Done => ui.loading = false,
            }
        }

        while let Ok(delegate) = delegate_rx.try_recv() {
            match delegate {
                DelegateControl::Tool { agent, title } => {
                    ui.entries.push(Entry {
                        role: Role::Tool,
                        text: format!("delegate {}: {}", agent, title),
                        output: Some(Vec::new()),
                    });
                Control::Tool { agent, title } => {
                    if let Some(last) = ui.entries.last_mut() {
                        if last.role == Role::Tool {
                            last.text = format!("delegate {}: {}", agent, title);
                            last.output = Some(Vec::new());
                        } else {
                            ui.entries.push(Entry {
                                role: Role::Tool,
                                text: format!("delegate {}: {}", agent, title),
                                output: Some(Vec::new()),
                            });
                        }
                    } else {
                        ui.entries.push(Entry {
                            role: Role::Tool,
                            text: format!("delegate {}: {}", agent, title),
                            output: Some(Vec::new()),
                        });
                    }
                    ui.scroll_override = None;
                }
                DelegateControl::Text(chunk) => {
                Control::ToolText(chunk) => {
                    if let Some(last) = ui.entries.last_mut() {
                        if last.role == Role::Tool {
                            last.output.get_or_insert_with(Vec::new).push(chunk);

                    }
                    ui.scroll_override = None;
                }
                DelegateControl::Done => {}
                DelegateControl::Error(message) => {
                    ui.entries.push(Entry {
                        role: Role::Notice,
                        text: format!("delegate error: {}", message),
                        output: None,
                    });
                    ui.scroll_override = None;
                }
                Control::ToolDone => {}
            }
        }


                            ui.composer.push('\n');
                        } else if !ui.composer.trim().is_empty() {
                            let prompt = ui.composer.clone();
                            ui.entries.push(Entry {
                                role: Role::You,
                                text: prompt.clone(),
                                output: None,
                            });
                            ui.entries.push(Entry {
                                role: Role::Assistant,
                                text: String::new(),
                                output: None,
                            });
                            ui.composer.clear();
                            ui.scroll_override = None;

                            if let Some(rest) = prompt.strip_prefix("/delegate") {
                                let rest = rest.trim_start();
                                if let Some((agent_id, task)) = rest.split_once(' ') {
                                    let agent_id = agent_id.to_string();
                                    let task = task.trim().to_string();
                                    let agent = ui.agents.iter().find(|a| a.id == agent_id).cloned();
                                    ui.entries.push(Entry {
                                        role: Role::You,
                                        text: prompt,
                                        output: None,
                                    });
                                    match agent {
                                        Some(agent) => {
                                            ui.entries.push(Entry {
                                                role: Role::Tool,
                                                text: format!("delegate {}: starting", agent_id),
                                                output: Some(Vec::new()),
                                            });
                                            let cwd =
                                                std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
                                            let delegate_tx = delegate_tx.clone();
                                            tokio::spawn(async move {
                                                let harness = AcpHarness {
                                                    command: agent.command,
                                                    args: agent.args,
                                                };
                                                let result = harness
                                                    .run(&task, &cwd, |event| match event {
                                                        AcpEvent::Tool { kind: _, title } => {
                                                            let _ = delegate_tx.send(
                                                                DelegateControl::Tool {
                                                                    agent: agent_id.clone(),
                                                                    title,
                                                                },
                                                            );
                                                        }
                                                        AcpEvent::Text { chunk } => {
                                                            let _ = delegate_tx
                                                                .send(DelegateControl::Text(chunk));
                                                        }
                                                        _ => {}
                                                    })
                                                    .await;
                                                if let Err(e) = result {
                                                    let _ = delegate_tx
                                                        .send(DelegateControl::Error(e.to_string()));
                                                } else {
                                                    let _ = delegate_tx.send(DelegateControl::Done);
                                                }
                                            });
                                        }
                                        None => {
                                            ui.entries.push(Entry {
                                                role: Role::Notice,
                                                text: format!("unknown ACP agent: {}", agent_id),
                                                output: None,
                                            });
                                        }
                                    }
                                } else {
                                    ui.entries.push(Entry {
                                        role: Role::Notice,
                                        text: "usage: /delegate <agent> <prompt>".to_string(),
                                        output: None,
                                    });
                                }
                            } else {
                                ui.entries.push(Entry {
                                    role: Role::You,
                                    text: prompt.clone(),
                                    output: None,
                                });
                                ui.entries.push(Entry {
                                    role: Role::Assistant,
                                    text: String::new(),
                                    output: None,
                                });
                                ui.loading = true;

                                let mut session = CoderRuntimeSession::new();
                                let tx = tx.clone();
                                tokio::spawn(async move {
                                    let _ = session.execute_turn(&prompt, tx).await;
                                });
                            }
                            ui.loading = true;

                            let mut session = CoderRuntimeSession::new();
                            session.agents = ui.agents.clone();
                            let tx = tx.clone();
                            tokio::spawn(async move {
                                let _ = session.execute_turn(&prompt, tx).await;
                            });
                        }
                    }
                    KeyEvent {

//! Open Responses streaming client for coder-lite.

use futures::StreamExt;
use openresponses_rust::{CreateResponseBody, Input, Item, StreamingClient, StreamingEvent};
use openresponses_rust::{
    CreateResponseBody, FunctionOutput, Input, Item, StreamingClient, StreamingEvent, Tool,
};
use std::env;
use std::path::PathBuf;
use std::sync::mpsc::Sender;

use crate::acp::Agent;
use crate::acp_harness::{AcpEvent, AcpHarness};

const SYSTEM_INSTRUCTIONS: &str = "You are OpenAgents Coder. Do not say you are from Google, Anthropic, OpenAI, or any other company. Do not mention your model, training, or architecture. Respond as a neutral, terse terminal: no greetings, no \"As an AI\", no explanations of your role, and no unnecessary padding. Use short sentences and dense, factual output. Answer questions directly. Output only code and minimal context when asked for code.";

pub enum Control {
    Chunk(String),
    Done,
    Tool { agent: String, title: String },
    ToolText(String),
    ToolDone,
}

pub struct CoderRuntimeSession {
    pub api_key: String,
    pub base_url: String,
    pub history: Vec<Item>,
    pub agents: Vec<Agent>,
}

impl CoderRuntimeSession {

            base_url: env::var("OPENAGENTS_BASE_URL")
                .unwrap_or_else(|_| "https://openagents.com/api/v1".to_string()),
            history: vec![Item::system_message(SYSTEM_INSTRUCTIONS)],
            agents: Vec::new(),
        }
    }


        self.history.push(Item::user_message(prompt));

        let client = StreamingClient::with_base_url(&self.api_key, &self.base_url);
        let tools = self.delegate_tool();

        let request = CreateResponseBody {
            model: env::var("OPENAGENTS_MODEL").ok(),
            input: Some(Input::Items(self.history.clone())),
            stream: Some(true),
            ..Default::default()
        };

        let mut stream = match client.stream_response(request).await {
            Ok(s) => s,
            Err(e) => {
                let _ = tx.send(Control::Chunk(format!("[error: {}]", e)));
                let _ = tx.send(Control::Done);
                return Err(e.into());
            }
        };

        let mut collected = String::new();
        loop {
            let request = CreateResponseBody {
                model: env::var("OPENAGENTS_MODEL").ok(),
                input: Some(Input::Items(self.history.clone())),
                tools: tools.clone(),
                stream: Some(true),
                ..Default::default()
            };

        while let Some(event) = stream.next().await {
            match event {
                Ok(StreamingEvent::OutputTextDelta { delta, .. }) => {
                    collected.push_str(&delta);
                    let _ = tx.send(Control::Chunk(delta));
                }
                Ok(StreamingEvent::ReasoningDelta { delta, .. }) => {
                    collected.push_str(&delta);
                    let _ = tx.send(Control::Chunk(delta));
                }
                Ok(StreamingEvent::RefusalDelta { delta, .. }) => {
                    let _ = tx.send(Control::Chunk(delta));
                }
                Ok(StreamingEvent::Error { error, .. }) => {
                    let msg = format!("[error: {:?}]", error);
                    let _ = tx.send(Control::Chunk(msg));
                }
                Ok(_) => {}
            let mut stream = match client.stream_response(request).await {
                Ok(s) => s,
                Err(e) => {
                    let _ = tx.send(Control::Chunk(format!("[error: {}]", e)));
                    let _ = tx.send(Control::Done);
                    return Err(e.into());
                }
            };

            let mut collected = String::new();
            let mut pending_tool: Option<(String, String, String)> = None;

            while let Some(event) = stream.next().await {
                match event {
                    Ok(StreamingEvent::OutputTextDelta { delta, .. }) => {
                        collected.push_str(&delta);
                        let _ = tx.send(Control::Chunk(delta));
                    }
                    Ok(StreamingEvent::ReasoningDelta { delta, .. }) => {
                        let _ = tx.send(Control::Chunk(delta));
                    }
                    Ok(StreamingEvent::OutputItemDone {
                        item: Some(Item::FunctionCall {
                            call_id,
                            name,
                            arguments,
                            ..
                        }),
                        ..
                    }) if name == "delegate" => {
                        let args = serde_json::from_str::<serde_json::Value>(&arguments)
                            .unwrap_or(serde_json::json!({}));
                        let agent = args
                            .get("agent")
                            .and_then(|v| v.as_str())
                            .unwrap_or("")
                            .to_string();
                        let task = args
                            .get("prompt")
                            .and_then(|v| v.as_str())
                            .unwrap_or("")
                            .to_string();
                        pending_tool = Some((call_id, agent, task));
                    }
                    Ok(StreamingEvent::Error { error, .. }) => {
                        let msg = format!("[error: {:?}]", error);
                        let _ = tx.send(Control::Chunk(msg));
                    }
                    Ok(_) => {}
                    Err(e) => {
                        let _ = tx.send(Control::Chunk(format!("[error: {}]", e)));
                        let _ = tx.send(Control::Done);
                        return Err(e.into());
                    }
                }
            }

            if let Some((call_id, agent_id, task)) = pending_tool.take() {
                if let Some(agent) = self.agents.iter().find(|a| a.id == agent_id).cloned() {
                    let title = task.chars().take(80).collect::<String>();
                    let _ = tx.send(Control::Tool {
                        agent: agent_id.clone(),
                        title: title.clone(),
                    });

                    let cwd = env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
                    let result = {
                        let tx = tx.clone();
                        AcpHarness {
                            command: agent.command,
                            args: agent.args,
                        }
                        .run(&task, &cwd, move |event| match event {
                            AcpEvent::Tool { title, .. } => {
                                let _ = tx.send(Control::Tool {
                                    agent: agent_id.clone(),
                                    title,
                                });
                            }
                            AcpEvent::Text { chunk } => {
                                let _ = tx.send(Control::ToolText(chunk));
                            }
                            _ => {}
                        })
                        .await
                    };

                    let _ = tx.send(Control::ToolDone);
                    let output = result.unwrap_or_else(|e| e.to_string());
                    self.history.push(Item::FunctionCallOutput {
                        id: None,
                        call_id,
                        output: FunctionOutput::Text(output),
                        status: None,
                    });
                    continue;
                } else {
                    let msg = format!("unknown ACP agent: {}", agent_id);
                    let _ = tx.send(Control::Chunk(msg.clone()));
                    self.history.push(Item::FunctionCallOutput {
                        id: None,
                        call_id,
                        output: FunctionOutput::Text(msg),
                        status: None,
                    });
                    continue;
                }
            }
        }

        if !collected.is_empty() {
            self.history.push(Item::assistant_message(collected));
            if !collected.is_empty() {
                self.history.push(Item::assistant_message(collected));
            }
            break;
        }

        let _ = tx.send(Control::Done);
        Ok(())
    }

    fn delegate_tool(&self) -> Option<Vec<Tool>> {
        if self.agents.is_empty() {
            return None;
        }
        let ids: Vec<String> = self.agents.iter().map(|a| a.id.clone()).collect();
        let tool = Tool::function("delegate")
            .with_description("Delegate a coding task to an ACP agent on this machine.")
            .with_parameters(serde_json::json!({
                "type": "object",
                "properties": {
                    "agent": {
                        "type": "string",
                        "enum": ids,
                        "description": "the ACP agent to delegate to"
                    },
                    "prompt": {
                        "type": "string",
                        "description": "the task for the child agent"
                    }
                },
                "required": ["agent", "prompt"]
            }));
        Some(vec![tool])
    }
}

                collected.push_str(&c);
            }
            Ok(Control::Done) => done = true,
            Ok(_) => {}
            Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,
        }
    }

5	5		//! `modifiers` so control chords do not fall through to plain character input.
6	6
7	7		`use crate::acp;`
8		-	`use crate::acp_harness::{AcpEvent, AcpHarness};`
9	8		`use crate::runtime::{CoderRuntimeSession, Control};`
10	9		`use crate::tui::{CoderUi, Entry, Role};`
11	10		`use std::sync::mpsc;`
12		-	`use std::path::PathBuf;`
13	11		`use crossterm::{`
14	12		`event::{`
15	13		`self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers,`

23	21		`use std::io::{stderr, stdout};`
24	22		`use std::time::Duration;`
25	23
26		-	`#[derive(Debug, Clone)]`
27		-	`pub enum DelegateControl {`
28		-	`Tool { agent: String, title: String },`
29		-	`Text(String),`
30		-	`Done,`
31		-	`Error(String),`
32		-	`}`
33		-
34	24		`pub async fn run_tui() -> Result<(), Box<dyn std::error::Error>> {`
35	25		`if !atty_is_terminal() {`
36	26		`println!("Non-interactive terminal detected. Run coder-lite from a TTY.");`

52	42		`terminal.show_cursor()?;`
53	43
54	44		`let (tx, rx) = mpsc::channel::<Control>();`
55		-	`let (delegate_tx, delegate_rx) = mpsc::channel::<DelegateControl>();`
56	45		`let mut ui = CoderUi::new();`
57	46
58	47		`match acp::find_agents().await {`

82	71		`while let Ok(control) = rx.try_recv() {`
83	72		`match control {`
84	73		`Control::Chunk(chunk) => {`
85		-	`if let Some(last) = ui.entries.last_mut() {`
	74	+	`// Append text to the current assistant entry.`
	75	+	`if let Some(last) = ui`
	76	+	`.entries`
	77	+	`.iter_mut()`
	78	+	`.rfind(\|e\| e.role == Role::Assistant)`
	79	+	`{`
86	80		`last.text.push_str(&chunk);`
87	81		`ui.scroll_override = None;`
88	82		`}`
89	83		`}`
90	84		`Control::Done => ui.loading = false,`
91		-	`}`
92		-	`}`
93		-
94		-	`while let Ok(delegate) = delegate_rx.try_recv() {`
95		-	`match delegate {`
96		-	`DelegateControl::Tool { agent, title } => {`
97		-	`ui.entries.push(Entry {`
98		-	`role: Role::Tool,`
99		-	`text: format!("delegate {}: {}", agent, title),`
100		-	`output: Some(Vec::new()),`
101		-	`});`
	85	+	`Control::Tool { agent, title } => {`
	86	+	`if let Some(last) = ui.entries.last_mut() {`
	87	+	`if last.role == Role::Tool {`
	88	+	`last.text = format!("delegate {}: {}", agent, title);`
	89	+	`last.output = Some(Vec::new());`
	90	+	`} else {`
	91	+	`ui.entries.push(Entry {`
	92	+	`role: Role::Tool,`
	93	+	`text: format!("delegate {}: {}", agent, title),`
	94	+	`output: Some(Vec::new()),`
	95	+	`});`
	96	+	`}`
	97	+	`} else {`
	98	+	`ui.entries.push(Entry {`
	99	+	`role: Role::Tool,`
	100	+	`text: format!("delegate {}: {}", agent, title),`
	101	+	`output: Some(Vec::new()),`
	102	+	`});`
	103	+	`}`
102	104		`ui.scroll_override = None;`
103	105		`}`
104		-	`DelegateControl::Text(chunk) => {`
	106	+	`Control::ToolText(chunk) => {`
105	107		`if let Some(last) = ui.entries.last_mut() {`
106	108		`if last.role == Role::Tool {`
107	109		`last.output.get_or_insert_with(Vec::new).push(chunk);`

109	111		`}`
110	112		`ui.scroll_override = None;`
111	113		`}`
112		-	`DelegateControl::Done => {}`
113		-	`DelegateControl::Error(message) => {`
114		-	`ui.entries.push(Entry {`
115		-	`role: Role::Notice,`
116		-	`text: format!("delegate error: {}", message),`
117		-	`output: None,`
118		-	`});`
119		-	`ui.scroll_override = None;`
120		-	`}`
	114	+	`Control::ToolDone => {}`
121	115		`}`
122	116		`}`
123	117

Commit

Make delegate an LLM tool, not a slash command.

Deploy story

Not deployed through the forge lane

Changed files

Diff

150	144		`ui.composer.push('\n');`
151	145		`} else if !ui.composer.trim().is_empty() {`
152	146		`let prompt = ui.composer.clone();`
	147	+	`ui.entries.push(Entry {`
	148	+	`role: Role::You,`
	149	+	`text: prompt.clone(),`
	150	+	`output: None,`
	151	+	`});`
	152	+	`ui.entries.push(Entry {`
	153	+	`role: Role::Assistant,`
	154	+	`text: String::new(),`
	155	+	`output: None,`
	156	+	`});`
153	157		`ui.composer.clear();`
154	158		`ui.scroll_override = None;`
155		-
156		-	`if let Some(rest) = prompt.strip_prefix("/delegate") {`
157		-	`let rest = rest.trim_start();`
158		-	`if let Some((agent_id, task)) = rest.split_once(' ') {`
159		-	`let agent_id = agent_id.to_string();`
160		-	`let task = task.trim().to_string();`
161		-	`let agent = ui.agents.iter().find(\|a\| a.id == agent_id).cloned();`
162		-	`ui.entries.push(Entry {`
163		-	`role: Role::You,`
164		-	`text: prompt,`
165		-	`output: None,`
166		-	`});`
167		-	`match agent {`
168		-	`Some(agent) => {`
169		-	`ui.entries.push(Entry {`
170		-	`role: Role::Tool,`
171		-	`text: format!("delegate {}: starting", agent_id),`
172		-	`output: Some(Vec::new()),`
173		-	`});`
174		-	`let cwd =`
175		-	`std::env::current_dir().unwrap_or_else(\|_\| PathBuf::from("."));`
176		-	`let delegate_tx = delegate_tx.clone();`
177		-	`tokio::spawn(async move {`
178		-	`let harness = AcpHarness {`
179		-	`command: agent.command,`
180		-	`args: agent.args,`
181		-	`};`
182		-	`let result = harness`
183		-	`.run(&task, &cwd, \|event\| match event {`
184		-	`AcpEvent::Tool { kind: _, title } => {`
185		-	`let _ = delegate_tx.send(`
186		-	`DelegateControl::Tool {`
187		-	`agent: agent_id.clone(),`
188		-	`title,`
189		-	`},`
190		-	`);`
191		-	`}`
192		-	`AcpEvent::Text { chunk } => {`
193		-	`let _ = delegate_tx`
194		-	`.send(DelegateControl::Text(chunk));`
195		-	`}`
196		-	`_ => {}`
197		-	`})`
198		-	`.await;`
199		-	`if let Err(e) = result {`
200		-	`let _ = delegate_tx`
201		-	`.send(DelegateControl::Error(e.to_string()));`
202		-	`} else {`
203		-	`let _ = delegate_tx.send(DelegateControl::Done);`
204		-	`}`
205		-	`});`
206		-	`}`
207		-	`None => {`
208		-	`ui.entries.push(Entry {`
209		-	`role: Role::Notice,`
210		-	`text: format!("unknown ACP agent: {}", agent_id),`
211		-	`output: None,`
212		-	`});`
213		-	`}`
214		-	`}`
215		-	`} else {`
216		-	`ui.entries.push(Entry {`
217		-	`role: Role::Notice,`
218		-	`text: "usage: /delegate <agent> <prompt>".to_string(),`
219		-	`output: None,`
220		-	`});`
221		-	`}`
222		-	`} else {`
223		-	`ui.entries.push(Entry {`
224		-	`role: Role::You,`
225		-	`text: prompt.clone(),`
226		-	`output: None,`
227		-	`});`
228		-	`ui.entries.push(Entry {`
229		-	`role: Role::Assistant,`
230		-	`text: String::new(),`
231		-	`output: None,`
232		-	`});`
233		-	`ui.loading = true;`
234		-
235		-	`let mut session = CoderRuntimeSession::new();`
236		-	`let tx = tx.clone();`
237		-	`tokio::spawn(async move {`
238		-	`let _ = session.execute_turn(&prompt, tx).await;`
239		-	`});`
240		-	`}`
	159	+	`ui.loading = true;`
	160	+
	161	+	`let mut session = CoderRuntimeSession::new();`
	162	+	`session.agents = ui.agents.clone();`
	163	+	`let tx = tx.clone();`
	164	+	`tokio::spawn(async move {`
	165	+	`let _ = session.execute_turn(&prompt, tx).await;`
	166	+	`});`
241	167		`}`
242	168		`}`
243	169		`KeyEvent {`

1	1		`//! Open Responses streaming client for coder-lite.`
2	2
3	3		`use futures::StreamExt;`
4		-	`use openresponses_rust::{CreateResponseBody, Input, Item, StreamingClient, StreamingEvent};`
	4	+	`use openresponses_rust::{`
	5	+	`CreateResponseBody, FunctionOutput, Input, Item, StreamingClient, StreamingEvent, Tool,`
	6	+	`};`
5	7		`use std::env;`
	8	+	`use std::path::PathBuf;`
6	9		`use std::sync::mpsc::Sender;`
7	10
	11	+	`use crate::acp::Agent;`
	12	+	`use crate::acp_harness::{AcpEvent, AcpHarness};`
	13	+
8	14		`const SYSTEM_INSTRUCTIONS: &str = "You are OpenAgents Coder. Do not say you are from Google, Anthropic, OpenAI, or any other company. Do not mention your model, training, or architecture. Respond as a neutral, terse terminal: no greetings, no \"As an AI\", no explanations of your role, and no unnecessary padding. Use short sentences and dense, factual output. Answer questions directly. Output only code and minimal context when asked for code.";`
9	15
10	16		`pub enum Control {`
11	17		`Chunk(String),`
12	18		`Done,`
	19	+	`Tool { agent: String, title: String },`
	20	+	`ToolText(String),`
	21	+	`ToolDone,`
13	22		`}`
14	23
15	24		`pub struct CoderRuntimeSession {`
16	25		`pub api_key: String,`
17	26		`pub base_url: String,`
18	27		`pub history: Vec<Item>,`
	28	+	`pub agents: Vec<Agent>,`
19	29		`}`
20	30
21	31		`impl CoderRuntimeSession {`

25	35		`base_url: env::var("OPENAGENTS_BASE_URL")`
26	36		`.unwrap_or_else(\|_\| "https://openagents.com/api/v1".to_string()),`
27	37		`history: vec![Item::system_message(SYSTEM_INSTRUCTIONS)],`
	38	+	`agents: Vec::new(),`
28	39		`}`
29	40		`}`
30	41

44	55		`self.history.push(Item::user_message(prompt));`
45	56
46	57		`let client = StreamingClient::with_base_url(&self.api_key, &self.base_url);`
	58	+	`let tools = self.delegate_tool();`
47	59
48		-	`let request = CreateResponseBody {`
49		-	`model: env::var("OPENAGENTS_MODEL").ok(),`
50		-	`input: Some(Input::Items(self.history.clone())),`
51		-	`stream: Some(true),`
52		-	`..Default::default()`
53		-	`};`
54		-
55		-	`let mut stream = match client.stream_response(request).await {`
56		-	`Ok(s) => s,`
57		-	`Err(e) => {`
58		-	`let _ = tx.send(Control::Chunk(format!("[error: {}]", e)));`
59		-	`let _ = tx.send(Control::Done);`
60		-	`return Err(e.into());`
61		-	`}`
62		-	`};`
63		-
64		-	`let mut collected = String::new();`
	60	+	`loop {`
	61	+	`let request = CreateResponseBody {`
	62	+	`model: env::var("OPENAGENTS_MODEL").ok(),`
	63	+	`input: Some(Input::Items(self.history.clone())),`
	64	+	`tools: tools.clone(),`
	65	+	`stream: Some(true),`
	66	+	`..Default::default()`
	67	+	`};`
65	68
66		-	`while let Some(event) = stream.next().await {`
67		-	`match event {`
68		-	`Ok(StreamingEvent::OutputTextDelta { delta, .. }) => {`
69		-	`collected.push_str(&delta);`
70		-	`let _ = tx.send(Control::Chunk(delta));`
71		-	`}`
72		-	`Ok(StreamingEvent::ReasoningDelta { delta, .. }) => {`
73		-	`collected.push_str(&delta);`
74		-	`let _ = tx.send(Control::Chunk(delta));`
75		-	`}`
76		-	`Ok(StreamingEvent::RefusalDelta { delta, .. }) => {`
77		-	`let _ = tx.send(Control::Chunk(delta));`
78		-	`}`
79		-	`Ok(StreamingEvent::Error { error, .. }) => {`
80		-	`let msg = format!("[error: {:?}]", error);`
81		-	`let _ = tx.send(Control::Chunk(msg));`
82		-	`}`
83		-	`Ok(_) => {}`
	69	+	`let mut stream = match client.stream_response(request).await {`
	70	+	`Ok(s) => s,`
84	71		`Err(e) => {`
85	72		`let _ = tx.send(Control::Chunk(format!("[error: {}]", e)));`
86	73		`let _ = tx.send(Control::Done);`
87	74		`return Err(e.into());`
88	75		`}`
	76	+	`};`
	77	+
	78	+	`let mut collected = String::new();`
	79	+	`let mut pending_tool: Option<(String, String, String)> = None;`
	80	+
	81	+	`while let Some(event) = stream.next().await {`
	82	+	`match event {`
	83	+	`Ok(StreamingEvent::OutputTextDelta { delta, .. }) => {`
	84	+	`collected.push_str(&delta);`
	85	+	`let _ = tx.send(Control::Chunk(delta));`
	86	+	`}`
	87	+	`Ok(StreamingEvent::ReasoningDelta { delta, .. }) => {`
	88	+	`let _ = tx.send(Control::Chunk(delta));`
	89	+	`}`
	90	+	`Ok(StreamingEvent::OutputItemDone {`
	91	+	`item: Some(Item::FunctionCall {`
	92	+	`call_id,`
	93	+	`name,`
	94	+	`arguments,`
	95	+	`..`
	96	+	`}),`
	97	+	`..`
	98	+	`}) if name == "delegate" => {`
	99	+	`let args = serde_json::from_str::<serde_json::Value>(&arguments)`
	100	+	`.unwrap_or(serde_json::json!({}));`
	101	+	`let agent = args`
	102	+	`.get("agent")`
	103	+	`.and_then(\|v\| v.as_str())`
	104	+	`.unwrap_or("")`
	105	+	`.to_string();`
	106	+	`let task = args`
	107	+	`.get("prompt")`
	108	+	`.and_then(\|v\| v.as_str())`
	109	+	`.unwrap_or("")`
	110	+	`.to_string();`
	111	+	`pending_tool = Some((call_id, agent, task));`
	112	+	`}`
	113	+	`Ok(StreamingEvent::Error { error, .. }) => {`
	114	+	`let msg = format!("[error: {:?}]", error);`
	115	+	`let _ = tx.send(Control::Chunk(msg));`
	116	+	`}`
	117	+	`Ok(_) => {}`
	118	+	`Err(e) => {`
	119	+	`let _ = tx.send(Control::Chunk(format!("[error: {}]", e)));`
	120	+	`let _ = tx.send(Control::Done);`
	121	+	`return Err(e.into());`
	122	+	`}`
	123	+	`}`
	124	+	`}`
	125	+
	126	+	`if let Some((call_id, agent_id, task)) = pending_tool.take() {`
	127	+	`if let Some(agent) = self.agents.iter().find(\|a\| a.id == agent_id).cloned() {`
	128	+	`let title = task.chars().take(80).collect::<String>();`
	129	+	`let _ = tx.send(Control::Tool {`
	130	+	`agent: agent_id.clone(),`
	131	+	`title: title.clone(),`
	132	+	`});`
	133	+
	134	+	`let cwd = env::current_dir().unwrap_or_else(\|_\| PathBuf::from("."));`
	135	+	`let result = {`
	136	+	`let tx = tx.clone();`
	137	+	`AcpHarness {`
	138	+	`command: agent.command,`
	139	+	`args: agent.args,`
	140	+	`}`
	141	+	`.run(&task, &cwd, move \|event\| match event {`
	142	+	`AcpEvent::Tool { title, .. } => {`
	143	+	`let _ = tx.send(Control::Tool {`
	144	+	`agent: agent_id.clone(),`
	145	+	`title,`
	146	+	`});`
	147	+	`}`
	148	+	`AcpEvent::Text { chunk } => {`
	149	+	`let _ = tx.send(Control::ToolText(chunk));`
	150	+	`}`
	151	+	`_ => {}`
	152	+	`})`
	153	+	`.await`
	154	+	`};`
	155	+
	156	+	`let _ = tx.send(Control::ToolDone);`
	157	+	`let output = result.unwrap_or_else(\|e\| e.to_string());`
	158	+	`self.history.push(Item::FunctionCallOutput {`
	159	+	`id: None,`
	160	+	`call_id,`
	161	+	`output: FunctionOutput::Text(output),`
	162	+	`status: None,`
	163	+	`});`
	164	+	`continue;`
	165	+	`} else {`
	166	+	`let msg = format!("unknown ACP agent: {}", agent_id);`
	167	+	`let _ = tx.send(Control::Chunk(msg.clone()));`
	168	+	`self.history.push(Item::FunctionCallOutput {`
	169	+	`id: None,`
	170	+	`call_id,`
	171	+	`output: FunctionOutput::Text(msg),`
	172	+	`status: None,`
	173	+	`});`
	174	+	`continue;`
	175	+	`}`
89	176		`}`
90		-	`}`
91	177
92		-	`if !collected.is_empty() {`
93		-	`self.history.push(Item::assistant_message(collected));`
	178	+	`if !collected.is_empty() {`
	179	+	`self.history.push(Item::assistant_message(collected));`
	180	+	`}`
	181	+	`break;`
94	182		`}`
95	183
96	184		`let _ = tx.send(Control::Done);`
97	185		`Ok(())`
98	186		`}`
	187	+
	188	+	`fn delegate_tool(&self) -> Option<Vec<Tool>> {`
	189	+	`if self.agents.is_empty() {`
	190	+	`return None;`
	191	+	`}`
	192	+	`let ids: Vec<String> = self.agents.iter().map(\|a\| a.id.clone()).collect();`
	193	+	`let tool = Tool::function("delegate")`
	194	+	`.with_description("Delegate a coding task to an ACP agent on this machine.")`
	195	+	`.with_parameters(serde_json::json!({`
	196	+	`"type": "object",`
	197	+	`"properties": {`
	198	+	`"agent": {`
	199	+	`"type": "string",`
	200	+	`"enum": ids,`
	201	+	`"description": "the ACP agent to delegate to"`
	202	+	`},`
	203	+	`"prompt": {`
	204	+	`"type": "string",`
	205	+	`"description": "the task for the child agent"`
	206	+	`}`
	207	+	`},`
	208	+	`"required": ["agent", "prompt"]`
	209	+	`}));`
	210	+	`Some(vec![tool])`
	211	+	`}`
99	212		`}`

29	29		`collected.push_str(&c);`
30	30		`}`
31	31		`Ok(Control::Done) => done = true,`
	32	+	`Ok(_) => {}`
32	33		`Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,`
33	34		`}`
34	35		`}`