agent/codex
2
0
Fork 0
mirror of https://github.com/pchuan98/codex.git synced 2026-07-01 00:31:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: change multi-agent to use path-like system instead of uuids (#15313)

Browse Source 
This PR add an URI-based system to reference agents within a tree. This
comes from a sync between research and engineering.

The main agent (the one manually spawned by a user) is always called
`/root`. Any sub-agent spawned by it will be `/root/agent_1` for example
where `agent_1` is chosen by the model.

Any agent can contact any agents using the path.

Paths can be used either in absolute or relative to the calling agents

Resume is not supported for now on this new path
This commit is contained in:
jif-oai
2026-03-20 18:23:48 +00:00
committed by GitHub
parent 4ddde54c19
commit 79ad7b247b
57 changed files with 1707 additions and 299 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codex-rs/core/src/tools/handlers/multi_agents.rs
+21 -14
View File
@@ -6,6 +6,8 @@
//! then optionally layer role-specific config on top.
use crate::agent::AgentStatus;
use crate::agent::agent_resolver::resolve_agent_target;
use crate::agent::agent_resolver::resolve_agent_targets;
use crate::agent::exceeds_thread_spawn_depth_limit;
use crate::codex::Session;
use crate::codex::TurnContext;
@@ -22,6 +24,7 @@ use crate::tools::registry::ToolHandler;
use crate::tools::registry::ToolKind;
use async_trait::async_trait;
use codex_features::Feature;
use codex_protocol::AgentPath;
use codex_protocol::ThreadId;
use codex_protocol::models::BaseInstructions;
use codex_protocol::models::ResponseInputItem;
@@ -59,11 +62,6 @@ pub(crate) const MIN_WAIT_TIMEOUT_MS: i64 = 10_000;
pub(crate) const DEFAULT_WAIT_TIMEOUT_MS: i64 = 30_000;
pub(crate) const MAX_WAIT_TIMEOUT_MS: i64 = 3600 * 1000;
#[derive(Debug, Deserialize)]
struct CloseAgentArgs {
id: String,
}
fn function_arguments(payload: ToolPayload) -> Result<String, FunctionCallError> {
match payload {
ToolPayload::Function { arguments } => Ok(arguments),
@@ -111,11 +109,6 @@ mod send_input;
mod spawn;
pub(crate) mod wait;
fn agent_id(id: &str) -> Result<ThreadId, FunctionCallError> {
ThreadId::from_string(id)
.map_err(|e| FunctionCallError::RespondToModel(format!("invalid agent id {id}: {e:?}")))
}
fn build_wait_agent_statuses(
statuses: &HashMap<ThreadId, AgentStatus>,
receiver_agents: &[CollabAgentRef],
@@ -155,9 +148,10 @@ fn build_wait_agent_statuses(
fn collab_spawn_error(err: CodexErr) -> FunctionCallError {
match err {
CodexErr::UnsupportedOperation(_) => {
CodexErr::UnsupportedOperation(message) if message == "thread manager dropped" => {
FunctionCallError::RespondToModel("collab manager unavailable".to_string())
}
CodexErr::UnsupportedOperation(message) => FunctionCallError::RespondToModel(message),
err => FunctionCallError::RespondToModel(format!("collab spawn failed: {err}")),
}
}
@@ -179,15 +173,28 @@ fn collab_agent_error(agent_id: ThreadId, err: CodexErr) -> FunctionCallError {
fn thread_spawn_source(
parent_thread_id: ThreadId,
parent_session_source: &SessionSource,
depth: i32,
agent_role: Option<&str>,
) -> SessionSource {
SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
task_name: Option<String>,
) -> Result<SessionSource, FunctionCallError> {
let agent_path = task_name
.as_deref()
.map(|task_name| {
parent_session_source
.get_agent_path()
.unwrap_or_else(AgentPath::root)
.join(task_name)
.map_err(FunctionCallError::RespondToModel)
})
.transpose()?;
Ok(SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
parent_thread_id,
depth,
agent_path,
agent_nickname: None,
agent_role: agent_role.map(str::to_string),
})
}))
}
fn parse_collab_input(
codex-rs/core/src/tools/handlers/multi_agents/close_agent.rs
+13 -9
View File
@@ -24,13 +24,12 @@ impl ToolHandler for Handler {
} = invocation;
let arguments = function_arguments(payload)?;
let args: CloseAgentArgs = parse_arguments(&arguments)?;
let agent_id = agent_id(&args.id)?;
let (receiver_agent_nickname, receiver_agent_role) = session
let agent_id = resolve_agent_target(&session, &turn, &args.target).await?;
let receiver_agent = session
.services
.agent_control
.get_agent_nickname_and_role(agent_id)
.await
.unwrap_or((None, None));
.get_agent_metadata(agent_id)
.unwrap_or_default();
session
.send_event(
&turn,
@@ -58,8 +57,8 @@ impl ToolHandler for Handler {
call_id: call_id.clone(),
sender_thread_id: session.conversation_id,
receiver_thread_id: agent_id,
receiver_agent_nickname: receiver_agent_nickname.clone(),
receiver_agent_role: receiver_agent_role.clone(),
receiver_agent_nickname: receiver_agent.agent_nickname.clone(),
receiver_agent_role: receiver_agent.agent_role.clone(),
status,
}
.into(),
@@ -82,8 +81,8 @@ impl ToolHandler for Handler {
call_id,
sender_thread_id: session.conversation_id,
receiver_thread_id: agent_id,
receiver_agent_nickname,
receiver_agent_role,
receiver_agent_nickname: receiver_agent.agent_nickname,
receiver_agent_role: receiver_agent.agent_role,
status: status.clone(),
}
.into(),
@@ -119,3 +118,8 @@ impl ToolOutput for CloseAgentResult {
tool_output_code_mode_result(self, "close_agent")
}
}
#[derive(Debug, Deserialize)]
struct CloseAgentArgs {
target: String,
}
codex-rs/core/src/tools/handlers/multi_agents/resume_agent.rs
+34 -32
View File
@@ -25,13 +25,14 @@ impl ToolHandler for Handler {
} = invocation;
let arguments = function_arguments(payload)?;
let args: ResumeAgentArgs = parse_arguments(&arguments)?;
let receiver_thread_id = agent_id(&args.id)?;
let (receiver_agent_nickname, receiver_agent_role) = session
let receiver_thread_id = ThreadId::from_string(&args.id).map_err(|err| {
FunctionCallError::RespondToModel(format!("invalid agent id {}: {err:?}", args.id))
})?;
let receiver_agent = session
.services
.agent_control
.get_agent_nickname_and_role(receiver_thread_id)
.await
.unwrap_or((None, None));
.get_agent_metadata(receiver_thread_id)
.unwrap_or_default();
let child_depth = next_thread_spawn_depth(&turn.session_source);
let max_depth = turn.config.agent_max_depth;
if exceeds_thread_spawn_depth_limit(child_depth, max_depth) {
@@ -47,8 +48,8 @@ impl ToolHandler for Handler {
call_id: call_id.clone(),
sender_thread_id: session.conversation_id,
receiver_thread_id,
receiver_agent_nickname: receiver_agent_nickname.clone(),
receiver_agent_role: receiver_agent_role.clone(),
receiver_agent_nickname: receiver_agent.agent_nickname.clone(),
receiver_agent_role: receiver_agent.agent_role.clone(),
}
.into(),
)
@@ -59,11 +60,22 @@ impl ToolHandler for Handler {
.agent_control
.get_status(receiver_thread_id)
.await;
let error = if matches!(status, AgentStatus::NotFound) {
let (receiver_agent, error) = if matches!(status, AgentStatus::NotFound) {
match try_resume_closed_agent(&session, &turn, receiver_thread_id, child_depth).await {
Ok(resumed_status) => {
status = resumed_status;
None
Ok(()) => {
status = session
.services
.agent_control
.get_status(receiver_thread_id)
.await;
(
session
.services
.agent_control
.get_agent_metadata(receiver_thread_id)
.unwrap_or(receiver_agent),
None,
)
}
Err(err) => {
status = session
@@ -71,19 +83,12 @@ impl ToolHandler for Handler {
.agent_control
.get_status(receiver_thread_id)
.await;
Some(err)
(receiver_agent, Some(err))
}
}
} else {
None
(receiver_agent, None)
};
let (receiver_agent_nickname, receiver_agent_role) = session
.services
.agent_control
.get_agent_nickname_and_role(receiver_thread_id)
.await
.unwrap_or((receiver_agent_nickname, receiver_agent_role));
session
.send_event(
&turn,
@@ -91,8 +96,8 @@ impl ToolHandler for Handler {
call_id,
sender_thread_id: session.conversation_id,
receiver_thread_id,
receiver_agent_nickname,
receiver_agent_role,
receiver_agent_nickname: receiver_agent.agent_nickname,
receiver_agent_role: receiver_agent.agent_role,
status: status.clone(),
}
.into(),
@@ -142,9 +147,9 @@ async fn try_resume_closed_agent(
turn: &Arc<TurnContext>,
receiver_thread_id: ThreadId,
child_depth: i32,
) -> Result<AgentStatus, FunctionCallError> {
) -> Result<(), FunctionCallError> {
let config = build_agent_resume_config(turn.as_ref(), child_depth)?;
let resumed_thread_id = session
session
.services
.agent_control
.resume_agent_from_rollout(
@@ -152,16 +157,13 @@ async fn try_resume_closed_agent(
receiver_thread_id,
thread_spawn_source(
session.conversation_id,
&turn.session_source,
child_depth,
/*agent_role*/ None,
),
/*task_name*/ None,
)?,
)
.await
.map_err(|err| collab_agent_error(receiver_thread_id, err))?;
Ok(session
.services
.agent_control
.get_status(resumed_thread_id)
.await)
.map(|_| ())
.map_err(|err| collab_agent_error(receiver_thread_id, err))
}
codex-rs/core/src/tools/handlers/multi_agents/send_input.rs
+7 -8
View File
@@ -24,15 +24,14 @@ impl ToolHandler for Handler {
} = invocation;
let arguments = function_arguments(payload)?;
let args: SendInputArgs = parse_arguments(&arguments)?;
let receiver_thread_id = agent_id(&args.id)?;
let receiver_thread_id = resolve_agent_target(&session, &turn, &args.target).await?;
let input_items = parse_collab_input(args.message, args.items)?;
let prompt = input_preview(&input_items);
let (receiver_agent_nickname, receiver_agent_role) = session
let receiver_agent = session
.services
.agent_control
.get_agent_nickname_and_role(receiver_thread_id)
.await
.unwrap_or((None, None));
.get_agent_metadata(receiver_thread_id)
.unwrap_or_default();
if args.interrupt {
session
.services
@@ -71,8 +70,8 @@ impl ToolHandler for Handler {
call_id,
sender_thread_id: session.conversation_id,
receiver_thread_id,
receiver_agent_nickname,
receiver_agent_role,
receiver_agent_nickname: receiver_agent.agent_nickname,
receiver_agent_role: receiver_agent.agent_role,
prompt,
status,
}
@@ -87,7 +86,7 @@ impl ToolHandler for Handler {
#[derive(Debug, Deserialize)]
struct SendInputArgs {
id: String,
target: String,
message: Option<String>,
items: Option<Vec<UserInput>>,
#[serde(default)]
codex-rs/core/src/tools/handlers/multi_agents/spawn.rs
+31 -23
View File
@@ -77,26 +77,29 @@ impl ToolHandler for Handler {
let result = session
.services
.agent_control
.spawn_agent_with_options(
.spawn_agent_with_metadata(
config,
input_items,
Some(thread_spawn_source(
session.conversation_id,
&turn.session_source,
child_depth,
role_name,
)),
args.task_name.clone(),
)?),
SpawnAgentOptions {
fork_parent_spawn_call_id: args.fork_context.then(|| call_id.clone()),
},
)
.await
.map_err(collab_spawn_error);
let (new_thread_id, status) = match &result {
Ok(thread_id) => (
Some(*thread_id),
session.services.agent_control.get_status(*thread_id).await,
let (new_thread_id, new_agent_metadata, status) = match &result {
Ok(spawned_agent) => (
Some(spawned_agent.thread_id),
Some(spawned_agent.metadata.clone()),
spawned_agent.status.clone(),
),
Err(_) => (None, AgentStatus::NotFound),
Err(_) => (None, None, AgentStatus::NotFound),
};
let agent_snapshot = match new_thread_id {
Some(thread_id) => {
@@ -108,19 +111,20 @@ impl ToolHandler for Handler {
}
None => None,
};
let (new_agent_nickname, new_agent_role) = match (&agent_snapshot, new_thread_id) {
(Some(snapshot), _) => (
snapshot.session_source.get_nickname(),
snapshot.session_source.get_agent_role(),
),
(None, Some(thread_id)) => session
.services
.agent_control
.get_agent_nickname_and_role(thread_id)
.await
.unwrap_or((None, None)),
(None, None) => (None, None),
};
let (new_agent_path, new_agent_nickname, new_agent_role) =
match (&agent_snapshot, new_agent_metadata) {
(Some(snapshot), _) => (
snapshot.session_source.get_agent_path().map(String::from),
snapshot.session_source.get_nickname(),
snapshot.session_source.get_agent_role(),
),
(None, Some(metadata)) => (
metadata.agent_path.map(String::from),
metadata.agent_nickname,
metadata.agent_role,
),
(None, None) => (None, None, None),
};
let effective_model = agent_snapshot
.as_ref()
.map(|snapshot| snapshot.model.clone())
@@ -130,6 +134,7 @@ impl ToolHandler for Handler {
.and_then(|snapshot| snapshot.reasoning_effort)
.unwrap_or(args.reasoning_effort.unwrap_or_default());
let nickname = new_agent_nickname.clone();
let task_name = new_agent_path.clone();
session
.send_event(
&turn,
@@ -147,7 +152,7 @@ impl ToolHandler for Handler {
.into(),
)
.await;
let new_thread_id = result?;
let new_thread_id = result?.thread_id;
let role_tag = role_name.unwrap_or(DEFAULT_ROLE_NAME);
turn.session_telemetry.counter(
"codex.multi_agent.spawn",
@@ -156,7 +161,8 @@ impl ToolHandler for Handler {
);
Ok(SpawnAgentResult {
agent_id: new_thread_id.to_string(),
agent_id: task_name.is_none().then(|| new_thread_id.to_string()),
task_name,
nickname,
})
}
@@ -166,6 +172,7 @@ impl ToolHandler for Handler {
struct SpawnAgentArgs {
message: Option<String>,
items: Option<Vec<UserInput>>,
task_name: Option<String>,
agent_type: Option<String>,
model: Option<String>,
reasoning_effort: Option<ReasoningEffort>,
@@ -175,7 +182,8 @@ struct SpawnAgentArgs {
#[derive(Debug, Serialize)]
pub(crate) struct SpawnAgentResult {
agent_id: String,
agent_id: Option<String>,
task_name: Option<String>,
nickname: Option<String>,
}
codex-rs/core/src/tools/handlers/multi_agents/wait.rs
+32 -23
View File
@@ -34,28 +34,27 @@ impl ToolHandler for Handler {
} = invocation;
let arguments = function_arguments(payload)?;
let args: WaitArgs = parse_arguments(&arguments)?;
if args.ids.is_empty() {
return Err(FunctionCallError::RespondToModel(
"ids must be non-empty".to_owned(),
));
}
let receiver_thread_ids = args
.ids
.iter()
.map(|id| agent_id(id))
.collect::<Result<Vec<_>, _>>()?;
let receiver_thread_ids = resolve_agent_targets(&session, &turn, args.targets).await?;
let mut receiver_agents = Vec::with_capacity(receiver_thread_ids.len());
let mut target_by_thread_id = HashMap::with_capacity(receiver_thread_ids.len());
for receiver_thread_id in &receiver_thread_ids {
let (agent_nickname, agent_role) = session
let agent_metadata = session
.services
.agent_control
.get_agent_nickname_and_role(*receiver_thread_id)
.await
.unwrap_or((None, None));
.get_agent_metadata(*receiver_thread_id)
.unwrap_or_default();
target_by_thread_id.insert(
*receiver_thread_id,
agent_metadata
.agent_path
.as_ref()
.map(ToString::to_string)
.unwrap_or_else(|| receiver_thread_id.to_string()),
);
receiver_agents.push(CollabAgentRef {
thread_id: *receiver_thread_id,
agent_nickname,
agent_role,
agent_nickname: agent_metadata.agent_nickname,
agent_role: agent_metadata.agent_role,
});
}
@@ -151,11 +150,20 @@ impl ToolHandler for Handler {
results
};
let statuses_map = statuses.clone().into_iter().collect::<HashMap<_, _>>();
let agent_statuses = build_wait_agent_statuses(&statuses_map, &receiver_agents);
let timed_out = statuses.is_empty();
let statuses_by_id = statuses.clone().into_iter().collect::<HashMap<_, _>>();
let agent_statuses = build_wait_agent_statuses(&statuses_by_id, &receiver_agents);
let result = WaitAgentResult {
status: statuses_map.clone(),
timed_out: statuses.is_empty(),
status: statuses
.into_iter()
.filter_map(|(thread_id, status)| {
target_by_thread_id
.get(&thread_id)
.cloned()
.map(|target| (target, status))
})
.collect(),
timed_out,
};
session
@@ -165,7 +173,7 @@ impl ToolHandler for Handler {
sender_thread_id: session.conversation_id,
call_id,
agent_statuses,
statuses: statuses_map,
statuses: statuses_by_id,
}
.into(),
)
@@ -177,13 +185,14 @@ impl ToolHandler for Handler {
#[derive(Debug, Deserialize)]
struct WaitArgs {
ids: Vec<String>,
#[serde(default)]
targets: Vec<String>,
timeout_ms: Option<i64>,
}
#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
pub(crate) struct WaitAgentResult {
pub(crate) status: HashMap<ThreadId, AgentStatus>,
pub(crate) status: HashMap<String, AgentStatus>,
pub(crate) timed_out: bool,
}
codex-rs/core/src/tools/handlers/multi_agents_tests.rs
+352 -32
View File
@@ -57,6 +57,10 @@ fn function_payload(args: serde_json::Value) -> ToolPayload {
}
}
fn parse_agent_id(id: &str) -> ThreadId {
ThreadId::from_string(id).expect("agent id should be valid")
}
fn thread_manager() -> ThreadManager {
ThreadManager::with_models_provider_for_tests(
CodexAuth::from_api_key("dummy"),
@@ -195,7 +199,7 @@ async fn spawn_agent_uses_explorer_role_and_preserves_approval_policy() {
let (content, _) = expect_text_output(output);
let result: SpawnAgentResult =
serde_json::from_str(&content).expect("spawn_agent result should be json");
let agent_id = agent_id(&result.agent_id).expect("agent_id should be valid");
let agent_id = parse_agent_id(&result.agent_id);
assert!(
result
.nickname
@@ -212,6 +216,33 @@ async fn spawn_agent_uses_explorer_role_and_preserves_approval_policy() {
assert_eq!(snapshot.model_provider_id, "ollama");
}
#[tokio::test]
async fn spawn_agent_includes_task_name_key_when_not_named() {
let (mut session, turn) = make_session_and_context().await;
let manager = thread_manager();
session.services.agent_control = manager.agent_control();
let output = SpawnAgentHandler
.handle(invocation(
Arc::new(session),
Arc::new(turn),
"spawn_agent",
function_payload(json!({
"message": "inspect this repo"
})),
))
.await
.expect("spawn_agent should succeed");
let (content, success) = expect_text_output(output);
let result: serde_json::Value =
serde_json::from_str(&content).expect("spawn_agent result should be json");
assert!(result["agent_id"].is_string());
assert_eq!(result["task_name"], serde_json::Value::Null);
assert!(result.get("nickname").is_some());
assert_eq!(success, Some(true));
}
#[tokio::test]
async fn spawn_agent_errors_when_manager_dropped() {
let (session, turn) = make_session_and_context().await;
@@ -230,6 +261,160 @@ async fn spawn_agent_errors_when_manager_dropped() {
);
}
#[tokio::test]
async fn multi_agent_v2_spawn_returns_path_and_send_input_accepts_relative_path() {
#[derive(Debug, Deserialize)]
struct SpawnAgentResult {
task_name: String,
nickname: Option<String>,
}
let (mut session, mut turn) = make_session_and_context().await;
let manager = thread_manager();
let root = manager
.start_thread((*turn.config).clone())
.await
.expect("root thread should start");
session.services.agent_control = manager.agent_control();
session.conversation_id = root.thread_id;
let mut config = (*turn.config).clone();
config
.features
.enable(Feature::MultiAgentV2)
.expect("test config should allow feature update");
turn.config = Arc::new(config);
let session = Arc::new(session);
let turn = Arc::new(turn);
let spawn_output = SpawnAgentHandler
.handle(invocation(
session.clone(),
turn.clone(),
"spawn_agent",
function_payload(json!({
"message": "inspect this repo",
"task_name": "test_process"
})),
))
.await
.expect("spawn_agent should succeed");
let (content, _) = expect_text_output(spawn_output);
let spawn_result: SpawnAgentResult =
serde_json::from_str(&content).expect("spawn result should parse");
assert_eq!(spawn_result.task_name, "/root/test_process");
assert!(spawn_result.nickname.is_some());
let child_thread_id = session
.services
.agent_control
.resolve_agent_reference(
session.conversation_id,
&turn.session_source,
"test_process",
)
.await
.expect("relative path should resolve");
let child_snapshot = manager
.get_thread(child_thread_id)
.await
.expect("child thread should exist")
.config_snapshot()
.await;
assert_eq!(
child_snapshot.session_source.get_agent_path().as_deref(),
Some("/root/test_process")
);
SendInputHandler
.handle(invocation(
session.clone(),
turn.clone(),
"send_input",
function_payload(json!({
"target": "test_process",
"message": "continue"
})),
))
.await
.expect("send_input should accept v2 path");
}
#[tokio::test]
async fn multi_agent_v2_spawn_includes_agent_id_key_when_named() {
let (mut session, mut turn) = make_session_and_context().await;
let manager = thread_manager();
let root = manager
.start_thread((*turn.config).clone())
.await
.expect("root thread should start");
session.services.agent_control = manager.agent_control();
session.conversation_id = root.thread_id;
let mut config = (*turn.config).clone();
config
.features
.enable(Feature::MultiAgentV2)
.expect("test config should allow feature update");
turn.config = Arc::new(config);
let output = SpawnAgentHandler
.handle(invocation(
Arc::new(session),
Arc::new(turn),
"spawn_agent",
function_payload(json!({
"message": "inspect this repo",
"task_name": "test_process"
})),
))
.await
.expect("spawn_agent should succeed");
let (content, success) = expect_text_output(output);
let result: serde_json::Value =
serde_json::from_str(&content).expect("spawn_agent result should be json");
assert_eq!(result["agent_id"], serde_json::Value::Null);
assert_eq!(result["task_name"], "/root/test_process");
assert!(result.get("nickname").is_some());
assert_eq!(success, Some(true));
}
#[tokio::test]
async fn multi_agent_v2_spawn_surfaces_task_name_validation_errors() {
let (mut session, mut turn) = make_session_and_context().await;
let manager = thread_manager();
let root = manager
.start_thread((*turn.config).clone())
.await
.expect("root thread should start");
session.services.agent_control = manager.agent_control();
session.conversation_id = root.thread_id;
let mut config = (*turn.config).clone();
config
.features
.enable(Feature::MultiAgentV2)
.expect("test config should allow feature update");
turn.config = Arc::new(config);
let invocation = invocation(
Arc::new(session),
Arc::new(turn),
"spawn_agent",
function_payload(json!({
"message": "inspect this repo",
"task_name": "BadName"
})),
);
let Err(err) = SpawnAgentHandler.handle(invocation).await else {
panic!("invalid agent name should be rejected");
};
assert_eq!(
err,
FunctionCallError::RespondToModel(
"agent_name must use only lowercase letters, digits, and underscores".to_string()
)
);
}
#[tokio::test]
async fn spawn_agent_reapplies_runtime_sandbox_after_role_config() {
fn pick_allowed_sandbox_policy(
@@ -293,7 +478,7 @@ async fn spawn_agent_reapplies_runtime_sandbox_after_role_config() {
let (content, _) = expect_text_output(output);
let result: SpawnAgentResult =
serde_json::from_str(&content).expect("spawn_agent result should be json");
let agent_id = agent_id(&result.agent_id).expect("agent_id should be valid");
let agent_id = parse_agent_id(&result.agent_id);
assert!(
result
.nickname
@@ -334,6 +519,7 @@ async fn spawn_agent_rejects_when_depth_limit_exceeded() {
turn.session_source = SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
parent_thread_id: session.conversation_id,
depth: max_depth,
agent_path: None,
agent_nickname: None,
agent_role: None,
});
@@ -373,6 +559,7 @@ async fn spawn_agent_allows_depth_up_to_configured_max_depth() {
turn.session_source = SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
parent_thread_id: session.conversation_id,
depth: DEFAULT_AGENT_MAX_DEPTH,
agent_path: None,
agent_nickname: None,
agent_role: None,
});
@@ -407,7 +594,7 @@ async fn send_input_rejects_empty_message() {
Arc::new(session),
Arc::new(turn),
"send_input",
function_payload(json!({"id": ThreadId::new().to_string(), "message": ""})),
function_payload(json!({"target": ThreadId::new().to_string(), "message": ""})),
);
let Err(err) = SendInputHandler.handle(invocation).await else {
panic!("empty message should be rejected");
@@ -426,7 +613,7 @@ async fn send_input_rejects_when_message_and_items_are_both_set() {
Arc::new(turn),
"send_input",
function_payload(json!({
"id": ThreadId::new().to_string(),
"target": ThreadId::new().to_string(),
"message": "hello",
"items": [{"type": "mention", "name": "drive", "path": "app://drive"}]
})),
@@ -449,7 +636,7 @@ async fn send_input_rejects_invalid_id() {
Arc::new(session),
Arc::new(turn),
"send_input",
function_payload(json!({"id": "not-a-uuid", "message": "hi"})),
function_payload(json!({"target": "not-a-uuid", "message": "hi"})),
);
let Err(err) = SendInputHandler.handle(invocation).await else {
panic!("invalid id should be rejected");
@@ -457,7 +644,10 @@ async fn send_input_rejects_invalid_id() {
let FunctionCallError::RespondToModel(msg) = err else {
panic!("expected respond-to-model error");
};
assert!(msg.starts_with("invalid agent id not-a-uuid:"));
assert_eq!(
msg,
"agent_name must use only lowercase letters, digits, and underscores"
);
}
#[tokio::test]
@@ -470,7 +660,7 @@ async fn send_input_reports_missing_agent() {
Arc::new(session),
Arc::new(turn),
"send_input",
function_payload(json!({"id": agent_id.to_string(), "message": "hi"})),
function_payload(json!({"target": agent_id.to_string(), "message": "hi"})),
);
let Err(err) = SendInputHandler.handle(invocation).await else {
panic!("missing agent should be reported");
@@ -494,7 +684,7 @@ async fn send_input_interrupts_before_prompt() {
Arc::new(turn),
"send_input",
function_payload(json!({
"id": agent_id.to_string(),
"target": agent_id.to_string(),
"message": "hi",
"interrupt": true
})),
@@ -533,7 +723,7 @@ async fn send_input_accepts_structured_items() {
Arc::new(turn),
"send_input",
function_payload(json!({
"id": agent_id.to_string(),
"target": agent_id.to_string(),
"items": [
{"type": "mention", "name": "drive", "path": "app://google_drive"},
{"type": "text", "text": "read the folder"}
@@ -703,7 +893,7 @@ async fn resume_agent_restores_closed_agent_and_accepts_send_input() {
session,
turn,
"send_input",
function_payload(json!({"id": agent_id.to_string(), "message": "hello"})),
function_payload(json!({"target": agent_id.to_string(), "message": "hello"})),
);
let output = SendInputHandler
.handle(send_invocation)
@@ -736,6 +926,7 @@ async fn resume_agent_rejects_when_depth_limit_exceeded() {
turn.session_source = SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
parent_thread_id: session.conversation_id,
depth: max_depth,
agent_path: None,
agent_nickname: None,
agent_role: None,
});
@@ -765,7 +956,7 @@ async fn wait_agent_rejects_non_positive_timeout() {
Arc::new(turn),
"wait_agent",
function_payload(json!({
"ids": [ThreadId::new().to_string()],
"targets": [ThreadId::new().to_string()],
"timeout_ms": 0
})),
);
@@ -779,13 +970,13 @@ async fn wait_agent_rejects_non_positive_timeout() {
}
#[tokio::test]
async fn wait_agent_rejects_invalid_id() {
async fn wait_agent_rejects_invalid_target() {
let (session, turn) = make_session_and_context().await;
let invocation = invocation(
Arc::new(session),
Arc::new(turn),
"wait_agent",
function_payload(json!({"ids": ["invalid"]})),
function_payload(json!({"targets": ["invalid"]})),
);
let Err(err) = WaitAgentHandler.handle(invocation).await else {
panic!("invalid id should be rejected");
@@ -793,27 +984,62 @@ async fn wait_agent_rejects_invalid_id() {
let FunctionCallError::RespondToModel(msg) = err else {
panic!("expected respond-to-model error");
};
assert!(msg.starts_with("invalid agent id invalid:"));
assert_eq!(msg, "live agent path `/root/invalid` not found");
}
#[tokio::test]
async fn wait_agent_rejects_empty_ids() {
async fn wait_agent_rejects_empty_targets() {
let (session, turn) = make_session_and_context().await;
let invocation = invocation(
Arc::new(session),
Arc::new(turn),
"wait_agent",
function_payload(json!({"ids": []})),
function_payload(json!({"targets": []})),
);
let Err(err) = WaitAgentHandler.handle(invocation).await else {
panic!("empty ids should be rejected");
};
assert_eq!(
err,
FunctionCallError::RespondToModel("ids must be non-empty".to_string())
FunctionCallError::RespondToModel("agent targets must be non-empty".to_string())
);
}
#[tokio::test]
async fn multi_agent_v2_wait_agent_accepts_targets_argument() {
let (mut session, mut turn) = make_session_and_context().await;
let target = ThreadId::new().to_string();
let manager = thread_manager();
session.services.agent_control = manager.agent_control();
let mut config = (*turn.config).clone();
config
.features
.enable(Feature::MultiAgentV2)
.expect("test config should allow feature update");
turn.config = Arc::new(config);
let invocation = invocation(
Arc::new(session),
Arc::new(turn),
"wait_agent",
function_payload(json!({"targets": [target.clone()]})),
);
let output = WaitAgentHandler
.handle(invocation)
.await
.expect("targets should be accepted in v2 mode");
let (content, success) = expect_text_output(output);
let result: wait::WaitAgentResult =
serde_json::from_str(&content).expect("wait_agent result should be json");
assert_eq!(
result,
wait::WaitAgentResult {
status: HashMap::from([(target, AgentStatus::NotFound)]),
timed_out: false,
}
);
assert_eq!(success, None);
}
#[tokio::test]
async fn wait_agent_returns_not_found_for_missing_agents() {
let (mut session, turn) = make_session_and_context().await;
@@ -826,7 +1052,7 @@ async fn wait_agent_returns_not_found_for_missing_agents() {
Arc::new(turn),
"wait_agent",
function_payload(json!({
"ids": [id_a.to_string(), id_b.to_string()],
"targets": [id_a.to_string(), id_b.to_string()],
"timeout_ms": 1000
})),
);
@@ -840,7 +1066,10 @@ async fn wait_agent_returns_not_found_for_missing_agents() {
assert_eq!(
result,
wait::WaitAgentResult {
status: HashMap::from([(id_a, AgentStatus::NotFound), (id_b, AgentStatus::NotFound),]),
status: HashMap::from([
(id_a.to_string(), AgentStatus::NotFound),
(id_b.to_string(), AgentStatus::NotFound),
]),
timed_out: false
}
);
@@ -860,7 +1089,7 @@ async fn wait_agent_times_out_when_status_is_not_final() {
Arc::new(turn),
"wait_agent",
function_payload(json!({
"ids": [agent_id.to_string()],
"targets": [agent_id.to_string()],
"timeout_ms": MIN_WAIT_TIMEOUT_MS
})),
);
@@ -900,7 +1129,7 @@ async fn wait_agent_clamps_short_timeouts_to_minimum() {
Arc::new(turn),
"wait_agent",
function_payload(json!({
"ids": [agent_id.to_string()],
"targets": [agent_id.to_string()],
"timeout_ms": 10
})),
);
@@ -950,7 +1179,7 @@ async fn wait_agent_returns_final_status_without_timeout() {
Arc::new(turn),
"wait_agent",
function_payload(json!({
"ids": [agent_id.to_string()],
"targets": [agent_id.to_string()],
"timeout_ms": 1000
})),
);
@@ -964,13 +1193,106 @@ async fn wait_agent_returns_final_status_without_timeout() {
assert_eq!(
result,
wait::WaitAgentResult {
status: HashMap::from([(agent_id, AgentStatus::Shutdown)]),
status: HashMap::from([(agent_id.to_string(), AgentStatus::Shutdown)]),
timed_out: false
}
);
assert_eq!(success, None);
}
#[tokio::test]
async fn multi_agent_v2_wait_agent_returns_statuses_keyed_by_path() {
#[derive(Debug, Deserialize)]
struct SpawnAgentResult {
task_name: String,
}
let (mut session, mut turn) = make_session_and_context().await;
let manager = thread_manager();
let root = manager
.start_thread((*turn.config).clone())
.await
.expect("root thread should start");
session.services.agent_control = manager.agent_control();
session.conversation_id = root.thread_id;
let mut config = (*turn.config).clone();
config
.features
.enable(Feature::MultiAgentV2)
.expect("test config should allow feature update");
turn.config = Arc::new(config);
let session = Arc::new(session);
let turn = Arc::new(turn);
let spawn_output = SpawnAgentHandler
.handle(invocation(
session.clone(),
turn.clone(),
"spawn_agent",
function_payload(json!({
"message": "inspect this repo",
"task_name": "test_process"
})),
))
.await
.expect("spawn_agent should succeed");
let (content, _) = expect_text_output(spawn_output);
let spawn_result: SpawnAgentResult =
serde_json::from_str(&content).expect("spawn result should parse");
let agent_id = session
.services
.agent_control
.resolve_agent_reference(
session.conversation_id,
&turn.session_source,
"test_process",
)
.await
.expect("relative path should resolve");
let mut status_rx = manager
.agent_control()
.subscribe_status(agent_id)
.await
.expect("subscribe should succeed");
let child_thread = manager
.get_thread(agent_id)
.await
.expect("child should exist");
let _ = child_thread
.submit(Op::Shutdown {})
.await
.expect("shutdown should submit");
let _ = timeout(Duration::from_secs(1), status_rx.changed())
.await
.expect("shutdown status should arrive");
let wait_output = WaitAgentHandler
.handle(invocation(
session,
turn,
"wait_agent",
function_payload(json!({
"targets": ["test_process"],
"timeout_ms": 1000
})),
))
.await
.expect("wait_agent should succeed");
let (content, success) = expect_text_output(wait_output);
let result: wait::WaitAgentResult =
serde_json::from_str(&content).expect("wait_agent result should be json");
assert_eq!(
result,
wait::WaitAgentResult {
status: HashMap::from([(spawn_result.task_name, AgentStatus::Shutdown)]),
timed_out: false,
}
);
assert_eq!(success, None);
}
#[tokio::test]
async fn close_agent_submits_shutdown_and_returns_previous_status() {
let (mut session, turn) = make_session_and_context().await;
@@ -985,7 +1307,7 @@ async fn close_agent_submits_shutdown_and_returns_previous_status() {
Arc::new(session),
Arc::new(turn),
"close_agent",
function_payload(json!({"id": agent_id.to_string()})),
function_payload(json!({"target": agent_id.to_string()})),
);
let output = CloseAgentHandler
.handle(invocation)
@@ -1037,13 +1359,12 @@ async fn tool_handlers_cascade_close_and_resume_and_keep_explicitly_closed_subtr
let (child_content, child_success) = expect_text_output(child_spawn_output);
let child_result: serde_json::Value =
serde_json::from_str(&child_content).expect("child spawn result should be json");
let child_thread_id = agent_id(
let child_thread_id = parse_agent_id(
child_result
.get("agent_id")
.and_then(serde_json::Value::as_str)
.expect("child spawn result should include agent_id"),
)
.expect("child agent_id should be valid");
);
assert_eq!(child_success, Some(true));
let child_thread = manager
@@ -1063,13 +1384,12 @@ async fn tool_handlers_cascade_close_and_resume_and_keep_explicitly_closed_subtr
let (grandchild_content, grandchild_success) = expect_text_output(grandchild_spawn_output);
let grandchild_result: serde_json::Value =
serde_json::from_str(&grandchild_content).expect("grandchild spawn result should be json");
let grandchild_thread_id = agent_id(
let grandchild_thread_id = parse_agent_id(
grandchild_result
.get("agent_id")
.and_then(serde_json::Value::as_str)
.expect("grandchild spawn result should include agent_id"),
)
.expect("grandchild agent_id should be valid");
);
assert_eq!(grandchild_success, Some(true));
let close_output = CloseAgentHandler
@@ -1077,7 +1397,7 @@ async fn tool_handlers_cascade_close_and_resume_and_keep_explicitly_closed_subtr
parent_session.clone(),
parent_session.new_default_turn().await,
"close_agent",
function_payload(json!({"id": child_thread_id.to_string()})),
function_payload(json!({"target": child_thread_id.to_string()})),
))
.await
.expect("close_agent should close the child subtree");
@@ -1129,7 +1449,7 @@ async fn tool_handlers_cascade_close_and_resume_and_keep_explicitly_closed_subtr
parent_session.clone(),
parent_session.new_default_turn().await,
"close_agent",
function_payload(json!({"id": child_thread_id.to_string()})),
function_payload(json!({"target": child_thread_id.to_string()})),
))
.await
.expect("close_agent should be repeatable for the child subtree");
codex-rs/core/src/tools/spec.rs
+52 -24
View File
@@ -129,20 +129,29 @@ fn agent_status_output_schema() -> JsonValue {
})
}
fn spawn_agent_output_schema() -> JsonValue {
fn spawn_agent_output_schema(multi_agent_v2: bool) -> JsonValue {
let task_name_description = if multi_agent_v2 {
"Canonical task name for the spawned agent."
} else {
"Canonical task name for the spawned agent when one was assigned."
};
json!({
"type": "object",
"properties": {
"agent_id": {
"type": "string",
"description": "Thread identifier for the spawned agent."
"type": ["string", "null"],
"description": "Thread identifier for the spawned agent when no task name was assigned."
},
"task_name": {
"type": ["string", "null"],
"description": task_name_description
},
"nickname": {
"type": ["string", "null"],
"description": "User-facing nickname for the spawned agent when available."
}
},
"required": ["agent_id", "nickname"],
"required": ["agent_id", "task_name", "nickname"],
"additionalProperties": false
})
}
@@ -178,7 +187,7 @@ fn wait_output_schema() -> JsonValue {
"properties": {
"status": {
"type": "object",
"description": "Final statuses keyed by agent id for agents that finished before the timeout.",
"description": "Final statuses keyed by canonical task name when available, otherwise by agent id.",
"additionalProperties": agent_status_output_schema()
},
"timed_out": {
@@ -276,6 +285,7 @@ pub(crate) struct ToolsConfig {
pub js_repl_tools_only: bool,
pub can_request_original_image_detail: bool,
pub collab_tools: bool,
pub multi_agent_v2: bool,
pub artifact_tools: bool,
pub request_user_input: bool,
pub default_mode_request_user_input: bool,
@@ -325,6 +335,7 @@ impl ToolsConfig {
let include_js_repl_tools_only =
include_js_repl && features.enabled(Feature::JsReplToolsOnly);
let include_collab_tools = features.enabled(Feature::Collab);
let include_multi_agent_v2 = features.enabled(Feature::MultiAgentV2);
let include_agent_jobs = features.enabled(Feature::SpawnCsv);
let include_request_user_input = !matches!(session_source, SessionSource::SubAgent(_));
let include_default_mode_request_user_input =
@@ -408,6 +419,7 @@ impl ToolsConfig {
js_repl_tools_only: include_js_repl_tools_only,
can_request_original_image_detail: include_original_image_detail,
collab_tools: include_collab_tools,
multi_agent_v2: include_multi_agent_v2,
artifact_tools: include_artifact_tools,
request_user_input: include_request_user_input,
default_mode_request_user_input: include_default_mode_request_user_input,
@@ -1076,7 +1088,8 @@ fn create_collab_input_items_schema() -> JsonSchema {
fn create_spawn_agent_tool(config: &ToolsConfig) -> ToolSpec {
let available_models_description = spawn_agent_models_description(&config.available_models);
let properties = BTreeMap::from([
let return_value_description = "Returns the canonical task name when the spawned agent was named, otherwise the agent id, plus the user-facing nickname when available.";
let mut properties = BTreeMap::from([
(
"message".to_string(),
JsonSchema::String {
@@ -1123,6 +1136,15 @@ fn create_spawn_agent_tool(config: &ToolsConfig) -> ToolSpec {
},
),
]);
properties.insert(
"task_name".to_string(),
JsonSchema::String {
description: Some(
"Optional task name for the new agent. Use lowercase letters, digits, and underscores."
.to_string(),
),
},
);
ToolSpec::Function(ResponsesApiTool {
name: "spawn_agent".to_string(),
@@ -1131,7 +1153,7 @@ fn create_spawn_agent_tool(config: &ToolsConfig) -> ToolSpec {
Only use `spawn_agent` if and only if the user explicitly asks for sub-agents, delegation, or parallel agent work.
Requests for depth, thoroughness, research, investigation, or detailed codebase analysis do not count as permission to spawn.
Agent-role guidance below only helps choose which agent to use after spawning is already authorized; it never authorizes spawning by itself.
Spawn a sub-agent for a well-scoped task. Returns the agent id (and user-facing nickname when available) to use to communicate with this agent. This spawn_agent tool provides you access to smaller but more efficient sub-agents. A mini model can solve many tasks faster than the main model. You should follow the rules and guidelines below to use this tool.
Spawn a sub-agent for a well-scoped task. {return_value_description} This spawn_agent tool provides you access to smaller but more efficient sub-agents. A mini model can solve many tasks faster than the main model. You should follow the rules and guidelines below to use this tool.
{available_models_description}
### When to delegate vs. do the subtask yourself
@@ -1170,7 +1192,7 @@ fn create_spawn_agent_tool(config: &ToolsConfig) -> ToolSpec {
required: None,
additional_properties: Some(false.into()),
},
output_schema: Some(spawn_agent_output_schema()),
output_schema: Some(spawn_agent_output_schema(config.multi_agent_v2)),
})
}
@@ -1335,9 +1357,11 @@ fn create_report_agent_job_result_tool() -> ToolSpec {
fn create_send_input_tool() -> ToolSpec {
let properties = BTreeMap::from([
(
"id".to_string(),
"target".to_string(),
JsonSchema::String {
description: Some("Agent id to message (from spawn_agent).".to_string()),
description: Some(
"Agent id or canonical task name to message (from spawn_agent).".to_string(),
),
},
),
(
@@ -1369,7 +1393,7 @@ fn create_send_input_tool() -> ToolSpec {
defer_loading: None,
parameters: JsonSchema::Object {
properties,
required: Some(vec!["id".to_string()]),
required: Some(vec!["target".to_string()]),
additional_properties: Some(false.into()),
},
output_schema: Some(send_input_output_schema()),
@@ -1404,11 +1428,11 @@ fn create_resume_agent_tool() -> ToolSpec {
fn create_wait_agent_tool() -> ToolSpec {
let mut properties = BTreeMap::new();
properties.insert(
"ids".to_string(),
"targets".to_string(),
JsonSchema::Array {
items: Box::new(JsonSchema::String { description: None }),
description: Some(
"Agent ids to wait on. Pass multiple ids to wait for whichever finishes first."
"Agent ids or canonical task names to wait on. Pass multiple targets to wait for whichever finishes first."
.to_string(),
),
},
@@ -1430,7 +1454,7 @@ fn create_wait_agent_tool() -> ToolSpec {
defer_loading: None,
parameters: JsonSchema::Object {
properties,
required: Some(vec!["ids".to_string()]),
required: Some(vec!["targets".to_string()]),
additional_properties: Some(false.into()),
},
output_schema: Some(wait_output_schema()),
@@ -1556,9 +1580,11 @@ fn create_request_permissions_tool() -> ToolSpec {
fn create_close_agent_tool() -> ToolSpec {
let mut properties = BTreeMap::new();
properties.insert(
"id".to_string(),
"target".to_string(),
JsonSchema::String {
description: Some("Agent id to close (from spawn_agent).".to_string()),
description: Some(
"Agent id or canonical task name to close (from spawn_agent).".to_string(),
),
},
);
@@ -1569,7 +1595,7 @@ fn create_close_agent_tool() -> ToolSpec {
defer_loading: None,
parameters: JsonSchema::Object {
properties,
required: Some(vec!["id".to_string()]),
required: Some(vec!["target".to_string()]),
additional_properties: Some(false.into()),
},
output_schema: Some(close_agent_output_schema()),
@@ -2966,12 +2992,15 @@ pub(crate) fn build_specs_with_discoverable_tools(
/*supports_parallel_tool_calls*/ false,
config.code_mode_enabled,
);
push_tool_spec(
&mut builder,
create_resume_agent_tool(),
/*supports_parallel_tool_calls*/ false,
config.code_mode_enabled,
);
if !config.multi_agent_v2 {
push_tool_spec(
&mut builder,
create_resume_agent_tool(),
/*supports_parallel_tool_calls*/ false,
config.code_mode_enabled,
);
builder.register_handler("resume_agent", Arc::new(ResumeAgentHandler));
}
push_tool_spec(
&mut builder,
create_wait_agent_tool(),
@@ -2986,7 +3015,6 @@ pub(crate) fn build_specs_with_discoverable_tools(
);
builder.register_handler("spawn_agent", Arc::new(SpawnAgentHandler));
builder.register_handler("send_input", Arc::new(SendInputHandler));
builder.register_handler("resume_agent", Arc::new(ResumeAgentHandler));
builder.register_handler("wait_agent", Arc::new(WaitAgentHandler));
builder.register_handler("close_agent", Arc::new(CloseAgentHandler));
}
codex-rs/core/src/tools/spec_tests.rs
+94 -1
View File
@@ -469,12 +469,15 @@ fn test_full_toolset_specs_for_gpt5_codex_unified_exec_web_search() {
create_view_image_tool(config.can_request_original_image_detail),
create_spawn_agent_tool(&config),
create_send_input_tool(),
create_resume_agent_tool(),
create_wait_agent_tool(),
create_close_agent_tool(),
] {
expected.insert(tool_name(&spec).to_string(), spec);
}
if !config.multi_agent_v2 {
let spec = create_resume_agent_tool();
expected.insert(tool_name(&spec).to_string(), spec);
}
if config.exec_permission_approvals_enabled {
let spec = create_request_permissions_tool();
@@ -520,6 +523,96 @@ fn test_build_specs_collab_tools_enabled() {
assert_lacks_tool_name(&tools, "spawn_agents_on_csv");
}
#[test]
fn test_build_specs_multi_agent_v2_uses_task_names_and_hides_resume() {
let config = test_config();
let model_info = ModelsManager::construct_model_info_offline_for_tests("gpt-5-codex", &config);
let mut features = Features::with_defaults();
features.enable(Feature::Collab);
features.enable(Feature::MultiAgentV2);
let available_models = Vec::new();
let tools_config = ToolsConfig::new(&ToolsConfigParams {
model_info: &model_info,
available_models: &available_models,
features: &features,
web_search_mode: Some(WebSearchMode::Cached),
session_source: SessionSource::Cli,
sandbox_policy: &SandboxPolicy::DangerFullAccess,
windows_sandbox_level: WindowsSandboxLevel::Disabled,
});
let (tools, _) = build_specs(&tools_config, None, None, &[]).build();
let spawn_agent = find_tool(&tools, "spawn_agent");
let ToolSpec::Function(ResponsesApiTool {
parameters,
output_schema,
..
}) = &spawn_agent.spec
else {
panic!("spawn_agent should be a function tool");
};
let JsonSchema::Object {
properties,
required,
..
} = parameters
else {
panic!("spawn_agent should use object params");
};
assert!(properties.contains_key("task_name"));
assert_eq!(required.as_ref(), None);
let output_schema = output_schema
.as_ref()
.expect("spawn_agent should define output schema");
assert_eq!(
output_schema["required"],
json!(["agent_id", "task_name", "nickname"])
);
let send_input = find_tool(&tools, "send_input");
let ToolSpec::Function(ResponsesApiTool { parameters, .. }) = &send_input.spec else {
panic!("send_input should be a function tool");
};
let JsonSchema::Object {
properties,
required,
..
} = parameters
else {
panic!("send_input should use object params");
};
assert!(properties.contains_key("target"));
assert_eq!(required.as_ref(), Some(&vec!["target".to_string()]));
let wait_agent = find_tool(&tools, "wait_agent");
let ToolSpec::Function(ResponsesApiTool {
parameters,
output_schema,
..
}) = &wait_agent.spec
else {
panic!("wait_agent should be a function tool");
};
let JsonSchema::Object {
properties,
required,
..
} = parameters
else {
panic!("wait_agent should use object params");
};
assert!(properties.contains_key("targets"));
assert_eq!(required.as_ref(), Some(&vec!["targets".to_string()]));
let output_schema = output_schema
.as_ref()
.expect("wait_agent should define output schema");
assert_eq!(
output_schema["properties"]["status"]["description"],
json!("Final statuses keyed by canonical task name when available, otherwise by agent id.")
);
assert_lacks_tool_name(&tools, "resume_agent");
}
#[test]
fn test_build_specs_enable_fanout_enables_agent_jobs_and_collab_tools() {
let config = test_config();