Preserve web search provider ownership across thread resumes (#62144)

## Why

Search MCP and native web search produce provider-specific references.
Switching providers after a thread resumes can mix those references and
break follow-up calls that use them.

## What changed

Persist whether a thread has used Search MCP, native web search, or
neither. Restore that state from response history, including compacted
history, and use legacy attribution and fallback markers for older
threads. When resumed history lacks a search state or legacy attribution
checkpoint, withhold native fallback unless a legacy marker identifies
native search.

Require every Search MCP call to claim the thread's search provider
before execution, including calls retained by Code Mode.

## Testing

Cover resuming a thread with Search MCP references after discovery
becomes unavailable, both with a saved search state and with imported
history that lacks search checkpoints.

GitOrigin-RevId: 100d21c92b0bdbf737ec36c3474f0bc020df8efc
This commit is contained in:
Owen Lin
2026-11-18 00:45:07 +00:00
committed by copyberry
parent 83c46d0a58
commit 06789c7618
9 changed files with 243 additions and 59 deletions
@@ -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",
}))?)
);
+8 -9
View File
@@ -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,
+70 -22
View File
@@ -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 {
@@ -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
+1
View File
@@ -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 {
@@ -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(()));
@@ -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: <DURATION> 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:
<MODEL_INSTRUCTIONS>
01:message/developer[3]:
[01] <PERMISSIONS_INSTRUCTIONS>
[02] <APPS_INSTRUCTIONS>
[03] <tools>
Deferred tool namespaces:
- mcp__codex_apps__search_service: Tools for working with search_service.
- multi_agent_v1: Tools for spawning and managing sub-agents.
</tools>
02:message/user:
<ENVIRONMENT_CONTEXT>
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: <DURATION> seconds
Output: | [turn0academia0] FlashAttention-2 by Tri Dao.
08:message/assistant:
The paper is by Tri Dao.
09:message/developer:
09:message/user:
<ENVIRONMENT_CONTEXT>
10:message/developer:
<tools>
Removed deferred tool namespaces:
- mcp__codex_apps__search_service: Tools for working with search_service.
</tools>
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:
<tools>
Added deferred tool namespaces:
- mcp__codex_apps__search_service: Tools for working with search_service.
</tools>
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: <DURATION> seconds
17:function_call/mcp__codex_apps__search_service._web_run:{"open":[{"ref_id":"turn0academia0"}]}
18:function_call_output:Wall time: <DURATION> 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:
<ENVIRONMENT_CONTEXT>
10:message/developer:
<tools>
Removed deferred tool namespaces:
- mcp__codex_apps__search_service: Tools for working with search_service.
</tools>
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:
<tools>
Added deferred tool namespaces:
- mcp__codex_apps__search_service: Tools for working with search_service.
</tools>
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: <DURATION> 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: <DURATION> seconds
Output: | The paper reports a 2x speedup.
18:message/assistant:
19:message/assistant:
It reports a 2x speedup.
19:message/developer:
<MODEL_SWITCH>
20:message/developer:
<MODEL_SWITCH>
21:message/developer:
<tools>
Removed deferred tool namespaces:
- mcp__codex_apps__search_service: Tools for working with search_service.
</tools>
21:message/user:
22:message/user:
Summarize the result.
+16
View File
@@ -64,6 +64,18 @@ pub struct ResponseItemEnvelope {
pub metadata: Option<CodexHarnessMetadata>,
}
/// 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<McpAttribution>,
/// 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<ModelSearchState>,
/// 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,