diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst index d7acc18289..5a275c040c 100644 Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differ diff --git a/codex-rs/app-server/tests/suite/v2/thread_inject_items.rs b/codex-rs/app-server/tests/suite/v2/thread_inject_items.rs index 6ddee6477a..5cb834e026 100644 --- a/codex-rs/app-server/tests/suite/v2/thread_inject_items.rs +++ b/codex-rs/app-server/tests/suite/v2/thread_inject_items.rs @@ -639,6 +639,7 @@ async fn thread_inject_items_adds_raw_response_items_after_a_turn() -> Result<() Some(serde_json::from_value(json!({ "history_sequence": 5, "sampled_through_sequence": 3, + "model_search_state": "unused", }))?) ); diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rs index c5a10b88df..83e519c2ce 100644 --- a/codex-rs/core/src/mcp_tool_call.rs +++ b/codex-rs/core/src/mcp_tool_call.rs @@ -508,15 +508,14 @@ async fn handle_approved_mcp_tool_call( } else { None }; - // Code Mode can retain this step past a later turn's first native call. - // A call rejected here never reaches the peer or acquires MCP attribution. - if matches!( - search.as_deref(), - Some(crate::model_search::ModelSearch::Hosted { .. }) - ) && !crate::model_search::SearchOwner::admit( - &sess.services.thread_extension_data, - codex_protocol::openai_models::WebSearchProvider::SearchMcp, - ) { + // Every Search MCP call can create provider-specific references. Claim Search MCP before the + // peer runs so a stale Code Mode call cannot mix them with native search references. + if is_search + && !crate::model_search::SearchOwner::admit( + &sess.services.thread_extension_data, + codex_protocol::openai_models::WebSearchProvider::SearchMcp, + ) + { let result = notify_mcp_tool_call_skip( sess, turn_context, diff --git a/codex-rs/core/src/model_search.rs b/codex-rs/core/src/model_search.rs index 54aef70137..c016e6725c 100644 --- a/codex-rs/core/src/model_search.rs +++ b/codex-rs/core/src/model_search.rs @@ -7,13 +7,14 @@ use std::sync::atomic::AtomicU8; use std::sync::atomic::Ordering; use codex_extension_api::ExtensionData; +use codex_history::CodexHarnessMetadata; use codex_history::InitialHistory; +use codex_history::ModelSearchState; use codex_history::ResponseItemEnvelope; use codex_history::RolloutItem; use codex_mcp::McpBinding; use codex_mcp::SearchDiscovery; use codex_protocol::config_types::WebSearchMode; -use codex_protocol::mcp::McpAttributionStatus; use codex_protocol::openai_models::WebSearchProvider; use codex_tools::ToolSpec; use serde_json::Map; @@ -145,26 +146,79 @@ impl SearchOwner { } pub(crate) fn restore(store: &ExtensionData, history: &InitialHistory) { - let used = |item: &ResponseItemEnvelope| { - item.metadata - .as_ref() - .is_some_and(|meta| meta.native_search_fallback_used) + let mut provider = None; + let mut legacy_native = false; + let mut legacy_search_mcp = false; + let mut has_checkpoint = false; + let mut inspect = |metadata: &CodexHarnessMetadata| { + match metadata.model_search_state { + Some(ModelSearchState::SearchMcp) => { + provider = Some(WebSearchProvider::SearchMcp); + } + Some(ModelSearchState::Standalone) + if provider != Some(WebSearchProvider::SearchMcp) => + { + provider = Some(WebSearchProvider::Standalone); + } + Some(ModelSearchState::Unused) | Some(ModelSearchState::Standalone) | None => {} + } + legacy_native |= metadata.native_search_fallback_used; + if let Some(attribution) = metadata.mcp_attribution.as_ref() { + legacy_search_mcp |= attribution.status + == codex_protocol::mcp::McpAttributionStatus::AttributionError + || attribution.sources.iter().any(|source| { + source.connector_id.as_deref() == Some(codex_mcp::SEARCH_CONNECTOR) + }); + } + has_checkpoint |= + metadata.model_search_state.is_some() || metadata.mcp_attribution.is_some(); }; - if history.scan_rollout_items(|item| match item { - RolloutItem::ResponseItem(item) => used(item), - RolloutItem::Compacted(item) => item.replacement_history.iter().flatten().any(used), - _ => false, - }) { - Self::admit(store, WebSearchProvider::Standalone); + for item in history.get_rollout_items() { + match item { + RolloutItem::ResponseItem(item) => { + if let Some(metadata) = item.metadata.as_ref() { + inspect(metadata); + } + } + RolloutItem::Compacted(item) => { + for metadata in item + .replacement_history + .iter() + .flatten() + .filter_map(|item| item.metadata.as_ref()) + { + inspect(metadata); + } + } + _ => {} + } + } + let provider = provider + .or_else(|| legacy_search_mcp.then_some(WebSearchProvider::SearchMcp)) + .or_else(|| legacy_native.then_some(WebSearchProvider::Standalone)) + .or_else(|| { + (!has_checkpoint + && !matches!(history, InitialHistory::New | InitialHistory::Cleared)) + .then_some(WebSearchProvider::SearchMcp) + }); + if let Some(provider) = provider { + Self::admit(store, provider); } } pub(crate) fn checkpoint(store: &ExtensionData, items: &mut [ResponseItemEnvelope]) { - if Self::current(store) == Some(WebSearchProvider::Standalone) { - for item in items { - item.metadata - .get_or_insert_default() - .native_search_fallback_used = true; + let provider = Self::current(store); + let state = match provider { + Some(WebSearchProvider::SearchMcp) => ModelSearchState::SearchMcp, + Some(WebSearchProvider::Standalone) => ModelSearchState::Standalone, + None => ModelSearchState::Unused, + }; + for item in items { + let metadata = item.metadata.get_or_insert_default(); + metadata.model_search_state = Some(state); + if provider == Some(WebSearchProvider::Standalone) { + // Keep older readers working while this field rolls out. + metadata.native_search_fallback_used = true; } } } @@ -418,15 +472,9 @@ pub(crate) async fn resolve( SearchDiscovery::Critical(reason) => *reason, SearchDiscovery::Unavailable => return finish(ModelSearch::Disabled, "unavailable"), }; - let attribution = services.executed_tool_calls.mcp_attribution_snapshot(); if let Some(mode) = native_mode && owner != Some(WebSearchProvider::SearchMcp) && usage.0.load(Ordering::Relaxed) & SearchTurnUsage::MCP == 0 - && attribution.status != McpAttributionStatus::AttributionError - && !attribution - .sources - .iter() - .any(|source| source.connector_id.as_deref() == Some(codex_mcp::SEARCH_CONNECTOR)) { finish( ModelSearch::Native { diff --git a/codex-rs/core/src/session/inject_tests.rs b/codex-rs/core/src/session/inject_tests.rs index af12838332..aa7305c2e8 100644 --- a/codex-rs/core/src/session/inject_tests.rs +++ b/codex-rs/core/src/session/inject_tests.rs @@ -36,6 +36,7 @@ async fn harness_authored_configuration_updates_preserve_metadata_and_resume() { let metadata = expected.metadata.as_mut().unwrap(); metadata.history_sequence = Some(1); metadata.sampled_through_sequence = Some(0); + metadata.model_search_state = Some(codex_history::ModelSearchState::Unused); metadata.mcp_attribution = Some( session .services diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs index c1c61c21dc..14a1905d1c 100644 --- a/codex-rs/core/src/session/tests.rs +++ b/codex-rs/core/src/session/tests.rs @@ -2823,6 +2823,7 @@ async fn annotated_history_uses_explicit_model_without_a_step( metadata.history_sequence = Some(index as u64 + 1); metadata.sampled_through_sequence = Some(0); metadata.history_truncation_token_limit = Some(expected_budget); + metadata.model_search_state = Some(codex_history::ModelSearchState::Unused); let (ResponseItem::FunctionCallOutput { output, .. } | ResponseItem::CustomToolCallOutput { output, .. }) = &mut envelope.item else { diff --git a/codex-rs/core/tests/suite/scenarios_web_search.rs b/codex-rs/core/tests/suite/scenarios_web_search.rs index 1cdf428ec2..80f90df46a 100644 --- a/codex-rs/core/tests/suite/scenarios_web_search.rs +++ b/codex-rs/core/tests/suite/scenarios_web_search.rs @@ -2,6 +2,8 @@ use super::*; use anyhow::Context; +use codex_history::CodexHarnessMetadata; +use codex_history::RolloutItem; use codex_protocol::config_types::WebSearchMode; use codex_protocol::openai_models::WebSearchProvider; use core_test_support::apps_test_server::AppsTestServer; @@ -124,11 +126,11 @@ async fn mount_model_search( "inputSchema": {"type":"object","properties":{"system2_search_query":{"type":"array"},"open":{"type":"array"}}}, "_meta": {"connector_id": codex_mcp::SEARCH_CONNECTOR,"connector_name":"search_service"} }); - let apps = - AppsTestServer::mount_with_tools(server, Arc::new(Mutex::new(vec![tool.clone()]))).await?; tool["inputSchema"]["properties"]["literature_search_query"] = json!({"type":"array"}); let pin = literature_search_pin(); tool["_meta"]["_codex_apps"] = json!({"invocation_context":pin}); + let apps = + AppsTestServer::mount_with_tools(server, Arc::new(Mutex::new(vec![tool.clone()]))).await?; // Host-owned Apps catalogs can exceed the generic MCP limit of 2,048 tools. let mut catalog: Vec<_> = (0..2_048) .map(|n| json!({"name":format!("other_{n}"),"inputSchema":{"type":"object"}})) @@ -203,6 +205,25 @@ fn model_search_builder(apps: &AppsTestServer, tool_mode: ToolMode) -> TestCodex }) } +fn rewrite_rollout_response_metadata( + path: &std::path::Path, + mut rewrite: impl FnMut(&mut CodexHarnessMetadata), +) -> Result<()> { + let mut rollout = Vec::new(); + for original in std::fs::read_to_string(path)?.lines() { + let mut line = codex_rollout::parse_rollout_line(original)?; + if let RolloutItem::ResponseItem(item) = &mut line.item + && let Some(metadata) = item.metadata.as_mut() + { + rewrite(metadata); + } + rollout.push(serde_json::to_string(&line)?); + } + let rollout = rollout.join("\n"); + std::fs::write(path, format!("{rollout}\n"))?; + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn model_selected_search_preserves_discovery_and_call_history() -> Result<()> { use codex_protocol::protocol::ThreadSettingsOverrides; @@ -304,10 +325,29 @@ async fn model_selected_search_preserves_discovery_and_call_history() -> Result< ], ) .await; - let test = model_search_builder(&apps, ToolMode::Direct) + let mut test = model_search_builder(&apps, ToolMode::Direct) + .with_model_info_override("hosted-paper", |model| { + model.web_search_provider = None; + }) .build_with_auto_env(&server) .await?; test.submit_turn("Find the FlashAttention-2 paper.").await?; + let rollout_path = test.codex.rollout_path().context("rollout path")?; + test.codex.shutdown_and_wait().await?; + let mut replaced_legacy_checkpoint = false; + rewrite_rollout_response_metadata(&rollout_path, |metadata| { + if let Some(attribution) = metadata.mcp_attribution.as_mut() { + *attribution = Default::default(); + replaced_legacy_checkpoint = true; + } + })?; + assert!( + replaced_legacy_checkpoint, + "first turn should persist legacy MCP attribution" + ); + test = model_search_builder(&apps, ToolMode::Direct) + .restart_with_auto_env(&server, &test) + .await?; discovery_available.store(false, Ordering::SeqCst); test.submit_turn("Open the paper and check its speedup.") .await?; @@ -353,6 +393,54 @@ async fn model_selected_search_preserves_discovery_and_call_history() -> Result< Ok(()) } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn metadata_free_history_withholds_native_fallback() -> Result<()> { + skip_if_no_network!(Ok(())); + let server = start_mock_server().await; + let discovery_available = Arc::new(AtomicBool::new(true)); + let apps = mount_model_search(&server, &discovery_available).await?; + let responses = mount_sse_sequence( + &server, + vec![ + sse(vec![ + ev_assistant_message("imported", "Keep the imported reference [turn0search0]."), + ev_completed("imported"), + ]), + sse(vec![ + ev_assistant_message("outage", "Search is temporarily unavailable."), + ev_completed("outage"), + ]), + ], + ) + .await; + let mut test = model_search_builder(&apps, ToolMode::Direct) + .build_with_auto_env(&server) + .await?; + test.submit_turn("Remember this imported search result.") + .await?; + let rollout_path = test.codex.rollout_path().context("rollout path")?; + test.codex.shutdown_and_wait().await?; + let mut removed_checkpoint = false; + rewrite_rollout_response_metadata(&rollout_path, |metadata| { + removed_checkpoint |= metadata.model_search_state.take().is_some(); + metadata.mcp_attribution = None; + })?; + assert!( + removed_checkpoint, + "first turn should persist model search state" + ); + test = model_search_builder(&apps, ToolMode::Direct) + .restart_with_auto_env(&server, &test) + .await?; + discovery_available.store(false, Ordering::SeqCst); + test.submit_turn("Open the imported reference.").await?; + + let requests = responses.requests(); + assert_eq!(requests.len(), 2); + assert!(requests[1].tool_by_name("web", "run").is_none()); + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn native_fallback_reference_survives_discovery_recovery_and_resume() -> Result<()> { skip_if_no_network!(Ok(())); diff --git a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__web_search__model_selected_search_preserves_discovery_and_call_history.snap b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__web_search__model_selected_search_preserves_discovery_and_call_history.snap index 56dfe8ca2d..23d4f44666 100644 --- a/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__web_search__model_selected_search_preserves_discovery_and_call_history.snap +++ b/codex-rs/core/tests/suite/snapshots/all__suite__scenarios__web_search__model_selected_search_preserves_discovery_and_call_history.snap @@ -15,7 +15,7 @@ Settings: stream: true text: {"verbosity":"low"} tool_choice: "auto" - tools (9; hash=47fc21674da7fb11): + tools (10; hash=2b1f11b924b13f60): - function/exec_command: Runs a command in a PTY, returning output or a session ID for ongoing interaction.; args=[cmd, justification, login, max_output_tokens, prefix_rule, sandbox_permissions, shell, tty, workdir, yield_time_ms]; hash=24f4b6739dd5d940 - function/write_stdin: Writes characters to an existing unified exec session and returns recent output.; args=[chars, max_output_tokens, session_id, yield_time_ms]; hash=7fb62d8a3e2df4e2 - function/list_mcp_resources: Lists resources provided by MCP servers. Resources allow servers to share data that provides cont...; args=[cursor, server]; hash=6792edaff13561bd @@ -24,6 +24,8 @@ Settings: - function/request_user_input: Request user input for one to three short questions and wait for the response. This tool is only ...; args=[questions]; hash=64a729b25c424fc6 - custom/apply_patch: The `apply_patch` tool can be used to edit files. This is a FREEFORM tool, so do not wrap the pat...; hash=dea9f12b0111a4ba - function/view_image: View a local image file from the filesystem when visual inspection is needed. Use this for images...; args=[path]; hash=1908de9c0be7118a + - namespace/web: Tools in the web namespace.; hash=c60e4db83b9fd6b0 + - function/run - tool_search: # Tool discovery Searches over deferred tool metadata with BM25 and exposes matching tools for t...; args=[limit, query]; hash=b573ed69c0b0e6c7 -- request 1 (turn) -- 00:message/developer: @@ -47,36 +49,62 @@ Settings: 06:function_call/mcp__codex_apps__search_service._web_run:{"literature_search_query":[{"q":"FlashAttention-2"}]} 07:function_call_output:Wall time: seconds Output: | [turn0academia0] FlashAttention-2 by Tri Dao. + +## Window 2 (after request 3) +Settings: relative to window 1 + tools (9; hash=47fc21674da7fb11): + - removed namespace/web -- request 4 (turn) -- +00:message/developer: + +01:message/developer[3]: + [01] + [02] + [03] + Deferred tool namespaces: + - mcp__codex_apps__search_service: Tools for working with search_service. + - multi_agent_v1: Tools for spawning and managing sub-agents. + +02:message/user: + +03:message/user: + Find the FlashAttention-2 paper. +04:tool_search_call +05:tool_search_output +06:function_call/mcp__codex_apps__search_service._web_run:{"literature_search_query":[{"q":"FlashAttention-2"}]} +07:function_call_output:Wall time: seconds + Output: | [turn0academia0] FlashAttention-2 by Tri Dao. 08:message/assistant: The paper is by Tri Dao. -09:message/developer: +09:message/user: + +10:message/developer: Removed deferred tool namespaces: - mcp__codex_apps__search_service: Tools for working with search_service. -10:message/user: +11:message/user: Open the paper and check its speedup. -- request 5 (turn) -- -11:message/assistant: +12:message/assistant: Search is temporarily unavailable. -12:message/developer: +13:message/developer: Added deferred tool namespaces: - mcp__codex_apps__search_service: Tools for working with search_service. -13:message/user: +14:message/user: Try opening the same paper again. -- request 6 (turn) -- -14:tool_search_call -15:tool_search_output +15:tool_search_call +16:tool_search_output -- request 7 (turn) -- -16:function_call/mcp__codex_apps__search_service._web_run:{"open":[{"ref_id":"turn0academia0"}]} -17:function_call_output:Wall time: seconds +17:function_call/mcp__codex_apps__search_service._web_run:{"open":[{"ref_id":"turn0academia0"}]} +18:function_call_output:Wall time: seconds Output: | The paper reports a 2x speedup. -## Window 2 (after request 7) -Settings: relative to window 1 +## Window 3 (after request 7) +Settings: relative to window 2 model: "native-paper" tools (10; hash=52194b2cfc736bb5): + namespace/web: Tools in the web namespace.; hash=0037b1ed8d50fab5 @@ -103,35 +131,37 @@ Settings: relative to window 1 Output: | [turn0academia0] FlashAttention-2 by Tri Dao. 08:message/assistant: The paper is by Tri Dao. -09:message/developer: +09:message/user: + +10:message/developer: Removed deferred tool namespaces: - mcp__codex_apps__search_service: Tools for working with search_service. -10:message/user: +11:message/user: Open the paper and check its speedup. -11:message/assistant: +12:message/assistant: Search is temporarily unavailable. -12:message/developer: +13:message/developer: Added deferred tool namespaces: - mcp__codex_apps__search_service: Tools for working with search_service. -13:message/user: +14:message/user: Try opening the same paper again. -14:tool_search_call -15:tool_search_output -16:function_call/mcp__codex_apps__search_service._web_run:{"open":[{"ref_id":"turn0academia0"}]} -17:function_call_output:Wall time: seconds +15:tool_search_call +16:tool_search_output +17:function_call/mcp__codex_apps__search_service._web_run:{"open":[{"ref_id":"turn0academia0"}]} +18:function_call_output:Wall time: seconds Output: | The paper reports a 2x speedup. -18:message/assistant: +19:message/assistant: It reports a 2x speedup. -19:message/developer: - 20:message/developer: + +21:message/developer: Removed deferred tool namespaces: - mcp__codex_apps__search_service: Tools for working with search_service. -21:message/user: +22:message/user: Summarize the result. diff --git a/codex-rs/history/src/lib.rs b/codex-rs/history/src/lib.rs index 8a2ec57b37..769b2562b8 100644 --- a/codex-rs/history/src/lib.rs +++ b/codex-rs/history/src/lib.rs @@ -64,6 +64,18 @@ pub struct ResponseItemEnvelope { pub metadata: Option, } +/// Persisted search-provider state for a thread. +/// +/// A missing checkpoint means the history predates this field and may contain Search MCP +/// references. `Unused` means the writer knows that neither provider has run yet. +#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum ModelSearchState { + Unused, + SearchMcp, + Standalone, +} + /// Metadata owned by the Codex harness and persisted with a response item. /// #[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, Eq, JsonSchema)] @@ -174,6 +186,10 @@ pub struct CodexHarnessMetadata { )] pub mcp_attribution: Option, + /// Search provider already used by this thread, or confirmation that neither has run yet. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub model_search_state: Option, + /// Native search ran during automatic fallback, so its browsing references stay on native. #[serde(default, skip_serializing_if = "std::ops::Not::not")] pub native_search_fallback_used: bool,