Files
codex/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs
T
Liang-Ting JiangandCodex 509a743501 Keep remote browsing on atlas command path
Only auto-inject the hidden atlas bridge when remote browsing is configured,
include thread ids in browser session notifications, and persist Atlas browser
state plus image artifacts so replay items can be rebuilt from history.

Co-authored-by: Codex <noreply@openai.com>
2026-03-25 01:53:56 +00:00

1884 lines
63 KiB
Rust

use anyhow::Context;
use anyhow::Result;
use app_test_support::McpProcess;
use app_test_support::create_final_assistant_message_sse_response;
use app_test_support::create_mock_responses_server_repeating_assistant;
use app_test_support::create_mock_responses_server_sequence_unchecked;
use app_test_support::to_response;
use codex_app_server_protocol::BrowserReplayRenderMode;
use codex_app_server_protocol::BrowserReplayTextSnapshotFormat;
use codex_app_server_protocol::BrowserSessionArtifacts;
use codex_app_server_protocol::BrowserSessionUpdatedNotification;
use codex_app_server_protocol::DynamicToolCallOutputContentItem;
use codex_app_server_protocol::DynamicToolCallParams;
use codex_app_server_protocol::DynamicToolCallResponse;
use codex_app_server_protocol::DynamicToolCallStatus;
use codex_app_server_protocol::DynamicToolSpec;
use codex_app_server_protocol::ItemCompletedNotification;
use codex_app_server_protocol::ItemStartedNotification;
use codex_app_server_protocol::JSONRPCNotification;
use codex_app_server_protocol::JSONRPCResponse;
use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::ServerRequest;
use codex_app_server_protocol::ThreadItem;
use codex_app_server_protocol::ThreadReadParams;
use codex_app_server_protocol::ThreadReadResponse;
use codex_app_server_protocol::ThreadStartParams;
use codex_app_server_protocol::ThreadStartResponse;
use codex_app_server_protocol::TurnStartParams;
use codex_app_server_protocol::TurnStartResponse;
use codex_app_server_protocol::UserInput as V2UserInput;
use codex_protocol::models::FunctionCallOutputBody;
use codex_protocol::models::FunctionCallOutputContentItem;
use codex_protocol::models::FunctionCallOutputPayload;
use core_test_support::responses;
use pretty_assertions::assert_eq;
use serde_json::Value;
use serde_json::json;
use std::path::Path;
use std::time::Duration;
use tempfile::TempDir;
use tokio::time::timeout;
use wiremock::Mock;
use wiremock::MockServer;
use wiremock::ResponseTemplate;
use wiremock::matchers::body_json;
use wiremock::matchers::method;
use wiremock::matchers::path;
const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(10);
/// Ensures dynamic tool specs are serialized into the model request payload.
#[tokio::test]
async fn thread_start_injects_dynamic_tools_into_model_requests() -> Result<()> {
let responses = vec![create_final_assistant_message_sse_response("Done")?];
let server = create_mock_responses_server_sequence_unchecked(responses).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??;
// Use a minimal JSON schema so we can assert the tool payload round-trips.
let input_schema = json!({
"type": "object",
"properties": {
"city": { "type": "string" }
},
"required": ["city"],
"additionalProperties": false,
});
let dynamic_tool = DynamicToolSpec {
name: "demo_tool".to_string(),
description: "Demo dynamic tool".to_string(),
input_schema: input_schema.clone(),
defer_loading: false,
};
// Thread start injects dynamic tools into the thread's tool registry.
let thread_req = mcp
.send_thread_start_request(ThreadStartParams {
dynamic_tools: Some(vec![dynamic_tool.clone()]),
..Default::default()
})
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
// Start a turn so a model request is issued.
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread.id.clone(),
input: vec![V2UserInput::Text {
text: "Hello".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let _turn: TurnStartResponse = to_response::<TurnStartResponse>(turn_resp)?;
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
// Inspect the captured model request to assert the tool spec made it through.
let bodies = responses_bodies(&server).await?;
let body = bodies
.first()
.context("expected at least one responses request")?;
let tool = find_tool(body, &dynamic_tool.name)
.context("expected dynamic tool to be injected into request")?;
assert_eq!(
tool.get("description"),
Some(&Value::String(dynamic_tool.description.clone()))
);
assert_eq!(tool.get("parameters"), Some(&input_schema));
Ok(())
}
#[tokio::test]
async fn thread_start_keeps_hidden_dynamic_tools_out_of_model_requests() -> Result<()> {
let responses = vec![create_final_assistant_message_sse_response("Done")?];
let server = create_mock_responses_server_sequence_unchecked(responses).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 {
name: "hidden_tool".to_string(),
description: "Hidden dynamic tool".to_string(),
input_schema: json!({
"type": "object",
"properties": {
"city": { "type": "string" }
},
"required": ["city"],
"additionalProperties": false,
}),
defer_loading: true,
};
let thread_req = mcp
.send_thread_start_request(ThreadStartParams {
dynamic_tools: Some(vec![dynamic_tool.clone()]),
..Default::default()
})
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread.id,
input: vec![V2UserInput::Text {
text: "Hello".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let _turn: TurnStartResponse = to_response::<TurnStartResponse>(turn_resp)?;
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
assert!(
bodies
.iter()
.all(|body| find_tool(body, &dynamic_tool.name).is_none()),
"hidden dynamic tool should not be sent to the model"
);
Ok(())
}
#[tokio::test]
async fn thread_start_auto_injects_only_atlas_command_bridge_when_endpoint_is_configured(
) -> Result<()>
{
let server = create_mock_responses_server_repeating_assistant("Done").await;
let remote_browser_server = MockServer::start().await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread.id,
input: vec![V2UserInput::Text {
text: "Hello".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let _turn: TurnStartResponse = to_response::<TurnStartResponse>(turn_resp)?;
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
let body = bodies
.first()
.context("expected at least one responses request")?;
assert!(find_tool(body, "create_tab").is_none());
assert!(find_tool(body, "tabs_content").is_none());
assert!(find_tool(body, "playwright_screenshot").is_none());
assert!(find_tool(body, "atlas_command").is_none());
Ok(())
}
#[tokio::test]
async fn atlas_command_dynamic_tool_calls_are_handled_internally() -> Result<()> {
let call_id = "dyn-atlas-1";
let tool_name = "atlas_command";
let tool_args = json!({
"payload": {
"type": "create_tab"
}
});
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).await;
let remote_browser_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.and(body_json(json!({
"browserSessionId": null,
"command": "create_tab",
"arguments": {
"select": true
}
})))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_atlas_123",
"result": {
"tab_id": "tab_123",
"selected_tab_id": "tab_123"
},
"browserState": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "New Tab",
"url": "about:blank",
"selected": true
}]
}
})))
.expect(1)
.mount(&remote_browser_server)
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let thread_id = thread.id.clone();
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread_id.clone(),
input: vec![V2UserInput::Text {
text: "use atlas".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let TurnStartResponse { turn } = to_response::<TurnStartResponse>(turn_resp)?;
let turn_id = turn.id.clone();
let started = wait_for_dynamic_tool_started(&mut mcp, call_id).await?;
assert_eq!(started.thread_id, thread_id);
assert_eq!(started.turn_id, turn_id.clone());
assert!(
timeout(
Duration::from_millis(500),
mcp.read_stream_until_request_message()
)
.await
.is_err(),
"atlas_command tool call should not be forwarded back to the client"
);
let browser_update = wait_for_browser_session_updated(&mut mcp).await?;
assert_eq!(browser_update.thread_id.as_deref(), Some(thread_id.as_str()));
assert_eq!(browser_update.browser_session_id, "sess_atlas_123");
assert_eq!(browser_update.browser_state.selected_tab_id, "tab_123");
assert_eq!(browser_update.browser_state.tabs.len(), 1);
assert_eq!(browser_update.browser_state.tabs[0].title, "New Tab");
assert_eq!(browser_update.artifacts, None);
let completed = wait_for_dynamic_tool_completed(&mut mcp, call_id).await?;
let ThreadItem::DynamicToolCall {
status,
content_items,
success,
..
} = completed.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(status, DynamicToolCallStatus::Completed);
assert_eq!(success, Some(true));
assert_eq!(
content_items,
Some(vec![DynamicToolCallOutputContentItem::InputText {
text: serde_json::to_string(&json!({
"type": "codex_repl",
"command_output": {
"id": "tab_123"
}
}))?,
}])
);
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
let payload = bodies
.iter()
.find_map(|body| function_call_output_payload(body, call_id))
.context("expected function_call_output in follow-up request")?;
assert_eq!(
payload.body,
FunctionCallOutputBody::Text(serde_json::to_string(&json!({
"type": "codex_repl",
"command_output": {
"id": "tab_123"
}
}))?)
);
assert_eq!(payload.success, None);
Ok(())
}
#[tokio::test]
async fn atlas_command_tabs_content_uses_background_tabs() -> Result<()> {
let call_id = "dyn-atlas-tabs-1";
let tool_name = "atlas_command";
let tool_args = json!({
"payload": {
"type": "tabs_content",
"urls": ["https://news.ycombinator.com/"],
"content_type": "text"
}
});
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).await;
let remote_browser_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.and(body_json(json!({
"browserSessionId": null,
"command": "create_tab",
"arguments": {
"url": "https://news.ycombinator.com/",
"select": false
}
})))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_atlas_tabs_123",
"result": {
"tab_id": "tab_bg_123"
},
"browserState": {
"selectedTabId": "tab_main",
"tabs": [
{
"id": "tab_main",
"title": "Workspace",
"url": "http://localhost:3000/",
"selected": true
},
{
"id": "tab_bg_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": false
}
]
}
})))
.expect(1)
.mount(&remote_browser_server)
.await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.and(body_json(json!({
"browserSessionId": "sess_atlas_tabs_123",
"command": "tabs_content",
"arguments": {
"tab_ids": ["tab_bg_123"]
}
})))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_atlas_tabs_123",
"result": {
"tabs": [{
"url": "https://news.ycombinator.com/",
"title": "Hacker News",
"content": "Top stories"
}]
},
"browserState": {
"selectedTabId": "tab_main",
"tabs": [
{
"id": "tab_main",
"title": "Workspace",
"url": "http://localhost:3000/",
"selected": true
},
{
"id": "tab_bg_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": false
}
]
}
})))
.expect(1)
.mount(&remote_browser_server)
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread.id,
input: vec![V2UserInput::Text {
text: "read the page".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let _turn: TurnStartResponse = to_response::<TurnStartResponse>(turn_resp)?;
let _started = wait_for_dynamic_tool_started(&mut mcp, call_id).await?;
let browser_update = wait_for_browser_session_updated(&mut mcp).await?;
assert_eq!(browser_update.thread_id.as_deref(), Some(thread.id.as_str()));
assert_eq!(browser_update.browser_session_id, "sess_atlas_tabs_123");
assert_eq!(browser_update.browser_state.selected_tab_id, "tab_main");
let completed = wait_for_dynamic_tool_completed(&mut mcp, call_id).await?;
let ThreadItem::DynamicToolCall {
content_items,
success,
..
} = completed.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(success, Some(true));
assert_eq!(
content_items,
Some(vec![DynamicToolCallOutputContentItem::InputText {
text: serde_json::to_string(&json!({
"type": "codex_repl",
"command_output": {
"results": [{
"url": "https://news.ycombinator.com/",
"title": "Hacker News",
"content": "Top stories"
}]
}
}))?,
}])
);
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
Ok(())
}
#[tokio::test]
async fn atlas_command_locator_count_passes_through_to_remote_browser() -> Result<()> {
let call_id = "dyn-atlas-locator-count-1";
let tool_name = "atlas_command";
let tool_args = json!({
"payload": {
"type": "playwright_locator_count",
"tab_id": "tab_123",
"selector": "span.titleline > a"
}
});
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).await;
let remote_browser_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.and(body_json(json!({
"browserSessionId": null,
"command": "playwright_locator_count",
"arguments": {
"tab_id": "tab_123",
"selector": "span.titleline > a"
}
})))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_atlas_count_123",
"result": {
"count": 5
},
"browserState": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": true
}]
}
})))
.expect(1)
.mount(&remote_browser_server)
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let thread_id = thread.id.clone();
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread_id.clone(),
input: vec![V2UserInput::Text {
text: "count links".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let TurnStartResponse { turn } = to_response::<TurnStartResponse>(turn_resp)?;
let turn_id = turn.id.clone();
let started = wait_for_dynamic_tool_started(&mut mcp, call_id).await?;
assert_eq!(started.thread_id, thread_id);
assert_eq!(started.turn_id, turn_id.clone());
let browser_update = wait_for_browser_session_updated(&mut mcp).await?;
assert_eq!(browser_update.thread_id.as_deref(), Some(thread_id.as_str()));
assert_eq!(browser_update.browser_session_id, "sess_atlas_count_123");
assert_eq!(browser_update.browser_state.selected_tab_id, "tab_123");
let completed = wait_for_dynamic_tool_completed(&mut mcp, call_id).await?;
let ThreadItem::DynamicToolCall {
content_items,
success,
..
} = completed.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(success, Some(true));
assert_eq!(
content_items,
Some(vec![DynamicToolCallOutputContentItem::InputText {
text: serde_json::to_string(&json!({
"type": "codex_repl",
"command_output": {
"count": 5
}
}))?,
}])
);
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
let payload = bodies
.iter()
.find_map(|body| function_call_output_payload(body, call_id))
.context("expected function_call_output in follow-up request")?;
assert_eq!(
payload.body,
FunctionCallOutputBody::Text(serde_json::to_string(&json!({
"type": "codex_repl",
"command_output": {
"count": 5
}
}))?)
);
assert_eq!(payload.success, None);
Ok(())
}
#[tokio::test]
async fn atlas_command_locator_click_passes_through_to_remote_browser() -> Result<()> {
let call_id = "dyn-atlas-locator-click-1";
let tool_name = "atlas_command";
let tool_args = json!({
"payload": {
"type": "playwright_locator_click",
"tab_id": "tab_123",
"selector": "[data-square=\"e2\"]",
"button": "left",
"timeout_ms": 1500
}
});
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Clicked")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).await;
let remote_browser_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.and(body_json(json!({
"browserSessionId": null,
"command": "playwright_locator_click",
"arguments": {
"tab_id": "tab_123",
"selector": "[data-square=\"e2\"]",
"button": "left",
"timeout_ms": 1500
}
})))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_atlas_click_123",
"result": {},
"browserState": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "3D Chess",
"url": "http://127.0.0.1:8123/",
"selected": true
}]
},
"artifacts": {
"screenshotBase64": "AAA",
"replayGifBase64": "R0lGODlh",
"replayFrameCount": 3,
"replayFrameDurationMs": 700
}
})))
.expect(1)
.mount(&remote_browser_server)
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let thread_id = thread.id.clone();
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread_id.clone(),
input: vec![V2UserInput::Text {
text: "click e2".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let TurnStartResponse { turn } = to_response::<TurnStartResponse>(turn_resp)?;
let turn_id = turn.id.clone();
let started = wait_for_dynamic_tool_started(&mut mcp, call_id).await?;
assert_eq!(started.thread_id, thread_id);
assert_eq!(started.turn_id, turn_id.clone());
let browser_update = wait_for_browser_session_updated(&mut mcp).await?;
assert_eq!(browser_update.thread_id.as_deref(), Some(thread_id.as_str()));
assert_eq!(browser_update.browser_session_id, "sess_atlas_click_123");
assert_eq!(browser_update.browser_state.selected_tab_id, "tab_123");
assert_eq!(
browser_update.artifacts,
Some(BrowserSessionArtifacts {
screenshot_image_url: Some("data:image/png;base64,AAA".to_string()),
replay_gif_image_url: Some("data:image/gif;base64,R0lGODlh".to_string()),
replay_frame_count: Some(3),
replay_frame_duration_ms: Some(700),
})
);
let completed = wait_for_dynamic_tool_completed(&mut mcp, call_id).await?;
let ThreadItem::DynamicToolCall {
content_items,
success,
..
} = completed.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(success, Some(true));
assert_eq!(
content_items,
Some(vec![DynamicToolCallOutputContentItem::InputText {
text: serde_json::to_string(&json!({
"type": "codex_repl",
"command_output": {}
}))?,
}])
);
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
let payload = bodies
.iter()
.find_map(|body| function_call_output_payload(body, call_id))
.context("expected function_call_output in follow-up request")?;
assert_eq!(
payload.body,
FunctionCallOutputBody::Text(serde_json::to_string(&json!({
"type": "codex_repl",
"command_output": {}
}))?)
);
assert_eq!(payload.success, None);
Ok(())
}
#[tokio::test]
async fn remote_browser_dynamic_tool_calls_are_handled_internally() -> Result<()> {
let call_id = "dyn-browser-1";
let tool_name = "create_tab";
let tool_args = json!({ "url": "https://news.ycombinator.com/" });
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).await;
let remote_browser_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_123",
"result": {
"tab_id": "tab_123",
"selected_tab_id": "tab_123"
},
"browserState": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": true
}]
},
"artifacts": {
"screenshotBase64": "AAA",
"replayGifBase64": "R0lGODlh",
"replayFrameCount": 2,
"replayFrameDurationMs": 700
}
})))
.mount(&remote_browser_server)
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let thread_id = thread.id.clone();
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread_id.clone(),
input: vec![V2UserInput::Text {
text: "open Hacker News".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let TurnStartResponse { turn } = to_response::<TurnStartResponse>(turn_resp)?;
let turn_id = turn.id.clone();
let started = wait_for_dynamic_tool_started(&mut mcp, call_id).await?;
assert_eq!(started.thread_id, thread_id);
assert_eq!(started.turn_id, turn_id.clone());
assert!(
timeout(
Duration::from_millis(500),
mcp.read_stream_until_request_message()
)
.await
.is_err(),
"remote browser tool call should not be forwarded back to the client"
);
let browser_update = wait_for_browser_session_updated(&mut mcp).await?;
assert_eq!(browser_update.thread_id.as_deref(), Some(thread_id.as_str()));
assert_eq!(browser_update.browser_session_id, "sess_123");
assert_eq!(browser_update.browser_state.selected_tab_id, "tab_123");
assert_eq!(browser_update.browser_state.tabs.len(), 1);
assert_eq!(browser_update.browser_state.tabs[0].title, "Hacker News");
assert_eq!(
browser_update.artifacts,
Some(BrowserSessionArtifacts {
screenshot_image_url: Some("data:image/png;base64,AAA".to_string()),
replay_gif_image_url: Some("data:image/gif;base64,R0lGODlh".to_string()),
replay_frame_count: Some(2),
replay_frame_duration_ms: Some(700),
})
);
let completed = wait_for_dynamic_tool_completed(&mut mcp, call_id).await?;
let ThreadItem::DynamicToolCall {
status,
content_items,
success,
..
} = completed.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(status, DynamicToolCallStatus::Completed);
assert_eq!(success, Some(true));
assert_eq!(
content_items,
Some(vec![
DynamicToolCallOutputContentItem::InputText {
text: serde_json::to_string_pretty(&json!({
"result": {
"tab_id": "tab_123",
"selected_tab_id": "tab_123"
},
"browser_state": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": true
}]
}
}))?
},
DynamicToolCallOutputContentItem::InputImage {
image_url: "data:image/png;base64,AAA".to_string(),
},
DynamicToolCallOutputContentItem::InputImage {
image_url: "data:image/gif;base64,R0lGODlh".to_string(),
},
])
);
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
let payload = bodies
.iter()
.find_map(|body| function_call_output_payload(body, call_id))
.context("expected function_call_output in follow-up request")?;
let FunctionCallOutputBody::ContentItems(content_items) = payload.body else {
panic!("expected content items payload");
};
assert_eq!(
content_items,
vec![
FunctionCallOutputContentItem::InputText {
text: serde_json::to_string_pretty(&json!({
"result": {
"tab_id": "tab_123",
"selected_tab_id": "tab_123"
},
"browser_state": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": true
}]
}
}))?,
},
FunctionCallOutputContentItem::InputImage {
image_url: "data:image/png;base64,AAA".to_string(),
detail: None,
},
FunctionCallOutputContentItem::InputImage {
image_url: "data:image/gif;base64,R0lGODlh".to_string(),
detail: None,
},
]
);
let remote_browser_requests = remote_browser_server
.received_requests()
.await
.context("failed to fetch remote browser requests")?;
assert_eq!(remote_browser_requests.len(), 1);
assert_eq!(
remote_browser_requests[0].body_json::<Value>()?,
json!({
"browserSessionId": null,
"command": "create_tab",
"arguments": {
"url": "https://news.ycombinator.com/"
}
})
);
Ok(())
}
#[tokio::test]
async fn thread_read_derives_browser_replay_from_remote_browser_tool_history() -> Result<()> {
let call_id = "dyn-browser-read-1";
let tool_name = "create_tab";
let tool_args = json!({ "url": "https://news.ycombinator.com/" });
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).await;
let remote_browser_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_123",
"result": {
"tab_id": "tab_123",
"selected_tab_id": "tab_123"
},
"browserState": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": true
}]
},
"artifacts": {
"screenshotBase64": "AAA",
"replayGifBase64": "R0lGODlh",
"replayFrameCount": 2,
"replayFrameDurationMs": 700
}
})))
.mount(&remote_browser_server)
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread.id.clone(),
input: vec![V2UserInput::Text {
text: "open Hacker News".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let _turn: TurnStartResponse = to_response::<TurnStartResponse>(turn_resp)?;
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let read_req = mcp
.send_thread_read_request(ThreadReadParams {
thread_id: thread.id.clone(),
include_turns: true,
})
.await?;
let read_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(read_req)),
)
.await??;
let ThreadReadResponse { thread } = to_response::<ThreadReadResponse>(read_resp)?;
let turn = thread.turns.last().context("expected replay turn")?;
let replay = turn
.items
.iter()
.find_map(|item| match item {
ThreadItem::BrowserReplay {
frames,
animation_image_url,
frame_duration_ms,
..
} => Some((frames, animation_image_url, frame_duration_ms)),
_ => None,
})
.context("expected derived browser replay item")?;
assert_eq!(replay.0.len(), 1);
assert_eq!(replay.0[0].source_item_id, call_id);
assert_eq!(replay.0[0].tool, tool_name);
assert_eq!(
replay.0[0].image_url.as_deref(),
Some("data:image/png;base64,AAA")
);
assert_eq!(replay.1.as_deref(), Some("data:image/gif;base64,R0lGODlh"));
assert_eq!(*replay.2, Some(700));
Ok(())
}
#[tokio::test]
async fn thread_read_derives_text_only_browser_replay_from_remote_browser_tool_history()
-> Result<()> {
let call_id = "dyn-browser-read-text-1";
let tool_name = "tabs_content";
let tool_args = json!({ "tabId": "tab_123" });
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).await;
let remote_browser_server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/remote_browser"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"browserSessionId": "sess_123",
"result": {
"tree": {
"role": "document",
"name": "Hacker News"
}
},
"browserState": {
"selectedTabId": "tab_123",
"tabs": [{
"id": "tab_123",
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"selected": true
}]
}
})))
.mount(&remote_browser_server)
.await;
let codex_home = TempDir::new()?;
create_config_toml(codex_home.path(), &server.uri())?;
let remote_browser_endpoint = format!("{}/remote_browser", remote_browser_server.uri());
let mut mcp = McpProcess::new_with_args(
codex_home.path(),
&["--remote-browser-endpoint", &remote_browser_endpoint],
)
.await?;
timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
let thread_req = mcp
.send_thread_start_request(ThreadStartParams::default())
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread.id.clone(),
input: vec![V2UserInput::Text {
text: "inspect the current page".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let _turn: TurnStartResponse = to_response::<TurnStartResponse>(turn_resp)?;
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let read_req = mcp
.send_thread_read_request(ThreadReadParams {
thread_id: thread.id.clone(),
include_turns: true,
})
.await?;
let read_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(read_req)),
)
.await??;
let ThreadReadResponse { thread } = to_response::<ThreadReadResponse>(read_resp)?;
let turn = thread.turns.last().context("expected replay turn")?;
let replay = turn
.items
.iter()
.find_map(|item| match item {
ThreadItem::BrowserReplay {
frames,
render_mode,
animation_image_url,
frame_duration_ms,
..
} => Some((frames, render_mode, animation_image_url, frame_duration_ms)),
_ => None,
})
.context("expected derived browser replay item")?;
assert_eq!(replay.0.len(), 1);
assert_eq!(replay.0[0].source_item_id, call_id);
assert_eq!(replay.0[0].tool, tool_name);
assert_eq!(replay.1, &BrowserReplayRenderMode::TextOnly);
assert_eq!(replay.2, &None);
assert_eq!(replay.3, &None);
let text_snapshot = replay.0[0]
.text_snapshot
.as_deref()
.context("expected text snapshot")?;
assert!(text_snapshot.contains("\"role\": \"document\""));
assert!(text_snapshot.contains("\"name\": \"Hacker News\""));
assert_eq!(
replay.0[0].text_snapshot_format,
Some(BrowserReplayTextSnapshotFormat::Json)
);
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_name = "demo_tool";
let tool_args = json!({ "city": "Paris" });
let tool_call_arguments = serde_json::to_string(&tool_args)?;
// First response triggers a dynamic tool call, second closes the turn.
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).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 {
name: tool_name.to_string(),
description: "Demo dynamic tool".to_string(),
input_schema: json!({
"type": "object",
"properties": {
"city": { "type": "string" }
},
"required": ["city"],
"additionalProperties": false,
}),
defer_loading: false,
};
let thread_req = mcp
.send_thread_start_request(ThreadStartParams {
dynamic_tools: Some(vec![dynamic_tool]),
..Default::default()
})
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let thread_id = thread.id.clone();
// Start a turn so the tool call is emitted.
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread_id.clone(),
input: vec![V2UserInput::Text {
text: "Run the tool".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let TurnStartResponse { turn } = to_response::<TurnStartResponse>(turn_resp)?;
let turn_id = turn.id.clone();
let started = wait_for_dynamic_tool_started(&mut mcp, call_id).await?;
assert_eq!(started.thread_id, thread_id);
assert_eq!(started.turn_id, turn_id.clone());
let ThreadItem::DynamicToolCall {
id,
tool,
arguments,
status,
content_items,
success,
duration_ms,
} = started.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(id, call_id);
assert_eq!(tool, tool_name);
assert_eq!(arguments, tool_args);
assert_eq!(status, DynamicToolCallStatus::InProgress);
assert_eq!(content_items, None);
assert_eq!(success, None);
assert_eq!(duration_ms, None);
// Read the tool call request from the app server.
let request = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_request_message(),
)
.await??;
let (request_id, params) = match request {
ServerRequest::DynamicToolCall { request_id, params } => (request_id, params),
other => panic!("expected DynamicToolCall request, got {other:?}"),
};
let expected = DynamicToolCallParams {
thread_id: thread_id.clone(),
turn_id: turn_id.clone(),
call_id: call_id.to_string(),
tool: tool_name.to_string(),
arguments: tool_args.clone(),
};
assert_eq!(params, expected);
// Respond to the tool call so the model receives a function_call_output.
let response = DynamicToolCallResponse {
content_items: vec![DynamicToolCallOutputContentItem::InputText {
text: "dynamic-ok".to_string(),
}],
success: true,
};
mcp.send_response(request_id, serde_json::to_value(response)?)
.await?;
let completed = wait_for_dynamic_tool_completed(&mut mcp, call_id).await?;
assert_eq!(completed.thread_id, thread_id);
assert_eq!(completed.turn_id, turn_id);
let ThreadItem::DynamicToolCall {
id,
tool,
arguments,
status,
content_items,
success,
duration_ms,
} = completed.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(id, call_id);
assert_eq!(tool, tool_name);
assert_eq!(arguments, tool_args);
assert_eq!(status, DynamicToolCallStatus::Completed);
assert_eq!(
content_items,
Some(vec![DynamicToolCallOutputContentItem::InputText {
text: "dynamic-ok".to_string(),
}])
);
assert_eq!(success, Some(true));
assert!(duration_ms.is_some());
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
let payload = bodies
.iter()
.find_map(|body| function_call_output_payload(body, call_id))
.context("expected function_call_output in follow-up request")?;
let expected_payload = FunctionCallOutputPayload::from_text("dynamic-ok".to_string());
assert_eq!(payload, expected_payload);
Ok(())
}
/// Ensures dynamic tool call responses can include structured content items.
#[tokio::test]
async fn dynamic_tool_call_round_trip_sends_content_items_to_model() -> Result<()> {
let call_id = "dyn-call-items-1";
let tool_name = "demo_tool";
let tool_args = json!({ "city": "Paris" });
let tool_call_arguments = serde_json::to_string(&tool_args)?;
let responses = vec![
responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_function_call(call_id, tool_name, &tool_call_arguments),
responses::ev_completed("resp-1"),
]),
create_final_assistant_message_sse_response("Done")?,
];
let server = create_mock_responses_server_sequence_unchecked(responses).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 {
name: tool_name.to_string(),
description: "Demo dynamic tool".to_string(),
input_schema: json!({
"type": "object",
"properties": {
"city": { "type": "string" }
},
"required": ["city"],
"additionalProperties": false,
}),
defer_loading: false,
};
let thread_req = mcp
.send_thread_start_request(ThreadStartParams {
dynamic_tools: Some(vec![dynamic_tool]),
..Default::default()
})
.await?;
let thread_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(thread_req)),
)
.await??;
let ThreadStartResponse { thread, .. } = to_response::<ThreadStartResponse>(thread_resp)?;
let thread_id = thread.id.clone();
let turn_req = mcp
.send_turn_start_request(TurnStartParams {
thread_id: thread_id.clone(),
input: vec![V2UserInput::Text {
text: "Run the tool".to_string(),
text_elements: Vec::new(),
}],
..Default::default()
})
.await?;
let turn_resp: JSONRPCResponse = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_response_message(RequestId::Integer(turn_req)),
)
.await??;
let TurnStartResponse { turn } = to_response::<TurnStartResponse>(turn_resp)?;
let turn_id = turn.id.clone();
let started = wait_for_dynamic_tool_started(&mut mcp, call_id).await?;
assert_eq!(started.thread_id, thread_id.clone());
assert_eq!(started.turn_id, turn_id.clone());
let request = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_request_message(),
)
.await??;
let (request_id, params) = match request {
ServerRequest::DynamicToolCall { request_id, params } => (request_id, params),
other => panic!("expected DynamicToolCall request, got {other:?}"),
};
let expected = DynamicToolCallParams {
thread_id,
turn_id: turn_id.clone(),
call_id: call_id.to_string(),
tool: tool_name.to_string(),
arguments: tool_args,
};
assert_eq!(params, expected);
let response_content_items = vec![
DynamicToolCallOutputContentItem::InputText {
text: "dynamic-ok".to_string(),
},
DynamicToolCallOutputContentItem::InputImage {
image_url: "data:image/png;base64,AAA".to_string(),
},
];
let content_items = response_content_items
.clone()
.into_iter()
.map(|item| match item {
DynamicToolCallOutputContentItem::InputText { text } => {
FunctionCallOutputContentItem::InputText { text }
}
DynamicToolCallOutputContentItem::InputImage { image_url } => {
FunctionCallOutputContentItem::InputImage {
image_url,
detail: None,
}
}
})
.collect::<Vec<FunctionCallOutputContentItem>>();
let response = DynamicToolCallResponse {
content_items: response_content_items,
success: true,
};
mcp.send_response(request_id, serde_json::to_value(response)?)
.await?;
let completed = wait_for_dynamic_tool_completed(&mut mcp, call_id).await?;
assert_eq!(completed.thread_id, expected.thread_id.clone());
assert_eq!(completed.turn_id, turn_id);
let ThreadItem::DynamicToolCall {
status,
content_items: completed_content_items,
success,
..
} = completed.item
else {
panic!("expected dynamic tool call item");
};
assert_eq!(status, DynamicToolCallStatus::Completed);
assert_eq!(
completed_content_items,
Some(vec![
DynamicToolCallOutputContentItem::InputText {
text: "dynamic-ok".to_string(),
},
DynamicToolCallOutputContentItem::InputImage {
image_url: "data:image/png;base64,AAA".to_string(),
},
])
);
assert_eq!(success, Some(true));
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let bodies = responses_bodies(&server).await?;
let output_value = bodies
.iter()
.find_map(|body| function_call_output_raw_output(body, call_id))
.context("expected function_call_output output in follow-up request")?;
assert_eq!(
output_value,
json!([
{
"type": "input_text",
"text": "dynamic-ok"
},
{
"type": "input_image",
"image_url": "data:image/png;base64,AAA"
}
])
);
let payload = bodies
.iter()
.find_map(|body| function_call_output_payload(body, call_id))
.context("expected function_call_output in follow-up request")?;
assert_eq!(
payload.body,
FunctionCallOutputBody::ContentItems(content_items.clone())
);
assert_eq!(payload.success, None);
assert_eq!(
serde_json::to_string(&payload)?,
serde_json::to_string(&content_items)?
);
Ok(())
}
async fn responses_bodies(server: &MockServer) -> Result<Vec<Value>> {
let requests = server
.received_requests()
.await
.context("failed to fetch received requests")?;
requests
.into_iter()
.filter(|req| req.url.path().ends_with("/responses"))
.map(|req| {
req.body_json::<Value>()
.context("request body should be JSON")
})
.collect()
}
fn find_tool<'a>(body: &'a Value, name: &str) -> Option<&'a Value> {
body.get("tools")
.and_then(Value::as_array)
.and_then(|tools| {
tools
.iter()
.find(|tool| tool.get("name").and_then(Value::as_str) == Some(name))
})
}
fn function_call_output_payload(body: &Value, call_id: &str) -> Option<FunctionCallOutputPayload> {
function_call_output_raw_output(body, call_id)
.and_then(|output| serde_json::from_value(output).ok())
}
fn function_call_output_raw_output(body: &Value, call_id: &str) -> Option<Value> {
body.get("input")
.and_then(Value::as_array)
.and_then(|items| {
items.iter().find(|item| {
item.get("type").and_then(Value::as_str) == Some("function_call_output")
&& item.get("call_id").and_then(Value::as_str) == Some(call_id)
})
})
.and_then(|item| item.get("output"))
.cloned()
}
async fn wait_for_dynamic_tool_started(
mcp: &mut McpProcess,
call_id: &str,
) -> Result<ItemStartedNotification> {
loop {
let notification: JSONRPCNotification = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("item/started"),
)
.await??;
let Some(params) = notification.params else {
continue;
};
let started: ItemStartedNotification = serde_json::from_value(params)?;
if matches!(&started.item, ThreadItem::DynamicToolCall { id, .. } if id == call_id) {
return Ok(started);
}
}
}
async fn wait_for_dynamic_tool_completed(
mcp: &mut McpProcess,
call_id: &str,
) -> Result<ItemCompletedNotification> {
loop {
let notification: JSONRPCNotification = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("item/completed"),
)
.await??;
let Some(params) = notification.params else {
continue;
};
let completed: ItemCompletedNotification = serde_json::from_value(params)?;
if matches!(&completed.item, ThreadItem::DynamicToolCall { id, .. } if id == call_id) {
return Ok(completed);
}
}
}
async fn wait_for_browser_session_updated(
mcp: &mut McpProcess,
) -> Result<BrowserSessionUpdatedNotification> {
let notification: JSONRPCNotification = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("browserSession/updated"),
)
.await??;
let params = notification
.params
.context("browserSession/updated should include params")?;
Ok(serde_json::from_value(params)?)
}
fn create_config_toml(codex_home: &Path, server_uri: &str) -> std::io::Result<()> {
let config_toml = codex_home.join("config.toml");
std::fs::write(
config_toml,
format!(
r#"
model = "mock-model"
approval_policy = "never"
sandbox_mode = "read-only"
model_provider = "mock_provider"
[model_providers.mock_provider]
name = "Mock provider for test"
base_url = "{server_uri}/v1"
wire_api = "responses"
request_max_retries = 0
stream_max_retries = 0
"#
),
)
}