From ad02b1298e6b2b6454ffe52941f2097e911344a6 Mon Sep 17 00:00:00 2001 From: Sayan Sisodiya Date: Mon, 20 Apr 2026 15:40:40 -0700 Subject: [PATCH] allow namespaces in code_mode + improvements to tests --- .../app-server/src/codex_message_processor.rs | 93 ++++++++++++------- .../tests/suite/v2/dynamic_tools.rs | 60 +++++++++++- codex-rs/core/src/tools/js_repl/mod_tests.rs | 2 +- codex-rs/core/src/tools/tool_search_entry.rs | 2 +- codex-rs/core/tests/suite/code_mode.rs | 8 +- codex-rs/tools/src/code_mode.rs | 14 ++- 6 files changed, 129 insertions(+), 50 deletions(-) diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index 17354da068..51942311a6 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -9206,9 +9206,6 @@ fn validate_dynamic_tools(tools: &[ApiDynamicToolSpec]) -> Result<(), String> { if name == "mcp" || name.starts_with("mcp__") { return Err(format!("dynamic tool name is reserved: {name}")); } - if !seen.insert(name.to_string()) { - return Err(format!("duplicate dynamic tool name: {name}")); - } let namespace = tool.namespace.as_deref().map(str::trim); if let Some(namespace) = namespace { if namespace.is_empty() { @@ -9227,6 +9224,14 @@ fn validate_dynamic_tools(tools: &[ApiDynamicToolSpec]) -> Result<(), String> { )); } } + if !seen.insert((namespace, name)) { + if let Some(namespace) = namespace { + return Err(format!( + "duplicate dynamic tool name in namespace {namespace}: {name}" + )); + } + return Err(format!("duplicate dynamic tool name: {name}")); + } if tool.defer_loading && namespace.is_none() { return Err(format!( "deferred dynamic tool must include a namespace: {name}" @@ -10227,37 +10232,63 @@ mod tests { } #[test] - fn validate_dynamic_tools_requires_namespace_for_deferred_tools() { - let tools = vec![ApiDynamicToolSpec { - namespace: None, - name: "my_tool".to_string(), - description: "test".to_string(), - input_schema: json!({ - "type": "object", - "properties": {}, - "additionalProperties": false - }), - defer_loading: true, - }]; - let err = validate_dynamic_tools(&tools).expect_err("missing namespace"); - assert!(err.contains("my_tool"), "unexpected error: {err}"); - assert!(err.contains("namespace"), "unexpected error: {err}"); + fn validate_dynamic_tools_accepts_same_name_in_different_namespaces() { + let tools = vec![ + ApiDynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ApiDynamicToolSpec { + namespace: Some("other_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ]; + validate_dynamic_tools(&tools).expect("valid schema"); } #[test] - fn validate_dynamic_tools_accepts_namespace_for_deferred_tools() { - let tools = vec![ApiDynamicToolSpec { - namespace: Some("codex_app".to_string()), - name: "my_tool".to_string(), - description: "test".to_string(), - input_schema: json!({ - "type": "object", - "properties": {}, - "additionalProperties": false - }), - defer_loading: true, - }]; - validate_dynamic_tools(&tools).expect("valid schema"); + fn validate_dynamic_tools_rejects_duplicate_name_in_same_namespace() { + let tools = vec![ + ApiDynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ApiDynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ]; + let err = validate_dynamic_tools(&tools).expect_err("duplicate name"); + assert!(err.contains("codex_app"), "unexpected error: {err}"); + assert!(err.contains("my_tool"), "unexpected error: {err}"); } #[test] diff --git a/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs b/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs index bd0a32357c..b8cd5c9ca4 100644 --- a/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs +++ b/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs @@ -198,10 +198,51 @@ async fn thread_start_keeps_hidden_dynamic_tools_out_of_model_requests() -> Resu Ok(()) } +#[tokio::test] +async fn thread_start_rejects_hidden_dynamic_tools_without_namespace() -> Result<()> { + let server = MockServer::start().await; + + let codex_home = TempDir::new()?; + create_config_toml(codex_home.path(), &server.uri())?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let dynamic_tool = DynamicToolSpec { + namespace: None, + name: "hidden_tool".to_string(), + description: "Hidden dynamic tool".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false, + }), + defer_loading: true, + }; + + let thread_req = mcp + .send_thread_start_request(ThreadStartParams { + dynamic_tools: Some(vec![dynamic_tool]), + ..Default::default() + }) + .await?; + let error = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_error_message(RequestId::Integer(thread_req)), + ) + .await??; + assert_eq!(error.error.code, -32600); + assert!(error.error.message.contains("hidden_tool")); + assert!(error.error.message.contains("namespace")); + + Ok(()) +} + /// Exercises the full dynamic tool call path (server request, client response, model output). #[tokio::test] async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Result<()> { let call_id = "dyn-call-1"; + let tool_namespace = "codex_app"; let tool_name = "demo_tool"; let tool_args = json!({ "city": "Paris" }); let tool_call_arguments = serde_json::to_string(&tool_args)?; @@ -210,7 +251,16 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res let responses = vec![ responses::sse(vec![ responses::ev_response_created("resp-1"), - responses::ev_function_call(call_id, tool_name, &tool_call_arguments), + json!({ + "type": "response.output_item.done", + "item": { + "type": "function_call", + "call_id": call_id, + "namespace": tool_namespace, + "name": tool_name, + "arguments": tool_call_arguments, + } + }), responses::ev_completed("resp-1"), ]), create_final_assistant_message_sse_response("Done")?, @@ -224,7 +274,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; let dynamic_tool = DynamicToolSpec { - namespace: None, + namespace: Some(tool_namespace.to_string()), name: tool_name.to_string(), description: "Demo dynamic tool".to_string(), input_schema: json!({ @@ -288,7 +338,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res panic!("expected dynamic tool call item"); }; assert_eq!(id, call_id); - assert_eq!(namespace, None); + assert_eq!(namespace.as_deref(), Some(tool_namespace)); assert_eq!(tool, tool_name); assert_eq!(arguments, tool_args); assert_eq!(status, DynamicToolCallStatus::InProgress); @@ -311,7 +361,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res thread_id: thread_id.clone(), turn_id: turn_id.clone(), call_id: call_id.to_string(), - namespace: None, + namespace: Some(tool_namespace.to_string()), tool: tool_name.to_string(), arguments: tool_args.clone(), }; @@ -344,7 +394,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res panic!("expected dynamic tool call item"); }; assert_eq!(id, call_id); - assert_eq!(namespace, None); + assert_eq!(namespace.as_deref(), Some(tool_namespace)); assert_eq!(tool, tool_name); assert_eq!(arguments, tool_args); assert_eq!(status, DynamicToolCallStatus::Completed); diff --git a/codex-rs/core/src/tools/js_repl/mod_tests.rs b/codex-rs/core/src/tools/js_repl/mod_tests.rs index bf5c5de475..c73e35f9e5 100644 --- a/codex-rs/core/src/tools/js_repl/mod_tests.rs +++ b/codex-rs/core/src/tools/js_repl/mod_tests.rs @@ -2017,7 +2017,7 @@ async fn js_repl_can_call_hidden_dynamic_tools() -> anyhow::Result<()> { let tracker = Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::default())); let manager = turn.js_repl.manager().await?; let code = r#" -const out = await codex.tool("hidden_dynamic_tool", { city: "Paris" }); +const out = await codex.tool("codex_app_hidden_dynamic_tool", { city: "Paris" }); console.log(JSON.stringify(out)); "#; diff --git a/codex-rs/core/src/tools/tool_search_entry.rs b/codex-rs/core/src/tools/tool_search_entry.rs index a113ffe374..54854e5f85 100644 --- a/codex-rs/core/src/tools/tool_search_entry.rs +++ b/codex-rs/core/src/tools/tool_search_entry.rs @@ -38,7 +38,7 @@ pub(crate) fn build_tool_search_entries( } let mut dynamic_tools = dynamic_tools.iter().collect::>(); - dynamic_tools.sort_by(|a, b| a.name.cmp(&b.name)); + dynamic_tools.sort_by(|a, b| a.namespace.cmp(&b.namespace).then(a.name.cmp(&b.name))); for tool in dynamic_tools { match dynamic_tool_search_entry(tool) { Ok(entry) => entries.push(entry), diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rs index 7d8027de7d..66ff4b2ff0 100644 --- a/codex-rs/core/tests/suite/code_mode.rs +++ b/codex-rs/core/tests/suite/code_mode.rs @@ -2576,8 +2576,8 @@ async fn code_mode_can_call_hidden_dynamic_tools() -> Result<()> { test.session_configured = new_thread.session_configured; let code = r#" -const tool = ALL_TOOLS.find(({ name }) => name === "hidden_dynamic_tool"); -const out = await tools.hidden_dynamic_tool({ city: "Paris" }); +const tool = ALL_TOOLS.find(({ name }) => name === "codex_app_hidden_dynamic_tool"); +const out = await tools.codex_app_hidden_dynamic_tool({ city: "Paris" }); text( JSON.stringify({ name: tool?.name ?? null, @@ -2670,7 +2670,7 @@ text( )?; assert_eq!( parsed.get("name"), - Some(&Value::String("hidden_dynamic_tool".to_string())) + Some(&Value::String("codex_app_hidden_dynamic_tool".to_string())) ); assert_eq!( parsed.get("out"), @@ -2683,7 +2683,7 @@ text( .is_some_and(|description| { description.contains("A hidden dynamic tool.") && description.contains("declare const tools:") - && description.contains("hidden_dynamic_tool(args:") + && description.contains("codex_app_hidden_dynamic_tool(args:") }) ); diff --git a/codex-rs/tools/src/code_mode.rs b/codex-rs/tools/src/code_mode.rs index 133ebb30b9..459eb7e460 100644 --- a/codex-rs/tools/src/code_mode.rs +++ b/codex-rs/tools/src/code_mode.rs @@ -226,14 +226,12 @@ fn code_mode_tool_definitions_for_spec(spec: &ToolSpec) -> Vec String { - if tool_name - .namespace - .as_deref() - .is_some_and(|namespace| namespace.starts_with("mcp__")) - { - tool_name.display() - } else { - tool_name.name.clone() + match tool_name.namespace.as_deref() { + Some(namespace) if namespace.ends_with('_') || tool_name.name.starts_with('_') => { + format!("{namespace}{}", tool_name.name) + } + Some(namespace) => format!("{namespace}_{}", tool_name.name), + None => tool_name.name.clone(), } }