mirror of
https://github.com/openai/codex.git
synced 2026-11-20 22:40:37 +00:00
Remove model-selected Search MCP routing (#62808)
## What changed Use the turn's effective `web_search` mode for standalone and hosted web search. Remove model-selected Search MCP discovery, fallback, and provider tracking across thread resumes. Remove `web_search_provider` from model metadata, the `tools.client_search_provider` hint from configuration, and the `hosted_search_policy` feature flag. Update the app-server schemas and generated SDK types to match. GitOrigin-RevId: 59e3371f4a43d532a484db52d5998f6770292028
This commit is contained in:
-19
@@ -10114,17 +10114,6 @@
|
||||
}
|
||||
]
|
||||
},
|
||||
"client_search_provider": {
|
||||
"anyOf": [
|
||||
{
|
||||
"$ref": "#/definitions/v2/WebSearchProvider"
|
||||
},
|
||||
{
|
||||
"type": "null"
|
||||
}
|
||||
],
|
||||
"description": "Effective tools.client_search_provider hint. Model-selected providers take precedence."
|
||||
},
|
||||
"compact_prompt": {
|
||||
"type": [
|
||||
"string",
|
||||
@@ -28993,14 +28982,6 @@
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchProvider": {
|
||||
"description": "Provider preference selected by the resolved model catalog entry.",
|
||||
"enum": [
|
||||
"standalone",
|
||||
"search_mcp"
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchToolConfig": {
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
|
||||
-19
@@ -5868,17 +5868,6 @@
|
||||
}
|
||||
]
|
||||
},
|
||||
"client_search_provider": {
|
||||
"anyOf": [
|
||||
{
|
||||
"$ref": "#/definitions/WebSearchProvider"
|
||||
},
|
||||
{
|
||||
"type": "null"
|
||||
}
|
||||
],
|
||||
"description": "Effective tools.client_search_provider hint. Model-selected providers take precedence."
|
||||
},
|
||||
"compact_prompt": {
|
||||
"type": [
|
||||
"string",
|
||||
@@ -26689,14 +26678,6 @@
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchProvider": {
|
||||
"description": "Provider preference selected by the resolved model catalog entry.",
|
||||
"enum": [
|
||||
"standalone",
|
||||
"search_mcp"
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchToolConfig": {
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
|
||||
@@ -521,17 +521,6 @@
|
||||
}
|
||||
]
|
||||
},
|
||||
"client_search_provider": {
|
||||
"anyOf": [
|
||||
{
|
||||
"$ref": "#/definitions/WebSearchProvider"
|
||||
},
|
||||
{
|
||||
"type": "null"
|
||||
}
|
||||
],
|
||||
"description": "Effective tools.client_search_provider hint. Model-selected providers take precedence."
|
||||
},
|
||||
"compact_prompt": {
|
||||
"type": [
|
||||
"string",
|
||||
@@ -1137,14 +1126,6 @@
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchProvider": {
|
||||
"description": "Provider preference selected by the resolved model catalog entry.",
|
||||
"enum": [
|
||||
"standalone",
|
||||
"search_mcp"
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchToolConfig": {
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -1,8 +0,0 @@
|
||||
// GENERATED CODE! DO NOT MODIFY BY HAND!
|
||||
|
||||
// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
|
||||
|
||||
/**
|
||||
* Provider preference selected by the resolved model catalog entry.
|
||||
*/
|
||||
export type WebSearchProvider = "standalone" | "search_mcp";
|
||||
@@ -93,6 +93,5 @@ export type { WebSearchContextSize } from "./WebSearchContextSize";
|
||||
export type { WebSearchItem } from "./WebSearchItem";
|
||||
export type { WebSearchLocation } from "./WebSearchLocation";
|
||||
export type { WebSearchMode } from "./WebSearchMode";
|
||||
export type { WebSearchProvider } from "./WebSearchProvider";
|
||||
export type { WebSearchToolConfig } from "./WebSearchToolConfig";
|
||||
export * as v2 from "./v2";
|
||||
|
||||
+1
-5
@@ -7,7 +7,6 @@ import type { ReasoningEffort } from "../ReasoningEffort";
|
||||
import type { ReasoningSummary } from "../ReasoningSummary";
|
||||
import type { Verbosity } from "../Verbosity";
|
||||
import type { WebSearchMode } from "../WebSearchMode";
|
||||
import type { WebSearchProvider } from "../WebSearchProvider";
|
||||
import type { JsonValue } from "../serde_json/JsonValue";
|
||||
import type { AnalyticsConfig } from "./AnalyticsConfig";
|
||||
import type { ApprovalsReviewer } from "./ApprovalsReviewer";
|
||||
@@ -23,7 +22,4 @@ export type Config = {model: string | null, review_model: string | null, model_c
|
||||
* [UNSTABLE] Optional default for where approval requests are routed for
|
||||
* review.
|
||||
*/
|
||||
approvals_reviewer: ApprovalsReviewer | null, sandbox_mode: SandboxMode | null, sandbox_workspace_write: SandboxWorkspaceWrite | null, forced_chatgpt_workspace_id: ForcedChatgptWorkspaceIds | null, forced_login_method: ForcedLoginMethod | null, web_search: WebSearchMode | null, /**
|
||||
* Effective tools.client_search_provider hint. Model-selected providers take precedence.
|
||||
*/
|
||||
client_search_provider: WebSearchProvider | null, tools: ToolsV2 | null, instructions: string | null, developer_instructions: string | null, compact_prompt: string | null, model_reasoning_effort: ReasoningEffort | null, model_reasoning_summary: ReasoningSummary | null, model_verbosity: Verbosity | null, service_tier: string | null, analytics: AnalyticsConfig | null, browser_use: BrowserUseConfig | null, computer_use: ComputerUseConfig | null, desktop: { [key in string]?: JsonValue } | null} & ({ [key in string]?: number | string | boolean | Array<JsonValue> | { [key in string]?: JsonValue } | null });
|
||||
approvals_reviewer: ApprovalsReviewer | null, sandbox_mode: SandboxMode | null, sandbox_workspace_write: SandboxWorkspaceWrite | null, forced_chatgpt_workspace_id: ForcedChatgptWorkspaceIds | null, forced_login_method: ForcedLoginMethod | null, web_search: WebSearchMode | null, tools: ToolsV2 | null, instructions: string | null, developer_instructions: string | null, compact_prompt: string | null, model_reasoning_effort: ReasoningEffort | null, model_reasoning_summary: ReasoningSummary | null, model_verbosity: Verbosity | null, service_tier: string | null, analytics: AnalyticsConfig | null, browser_use: BrowserUseConfig | null, computer_use: ComputerUseConfig | null, desktop: { [key in string]?: JsonValue } | null} & ({ [key in string]?: number | string | boolean | Array<JsonValue> | { [key in string]?: JsonValue } | null });
|
||||
|
||||
@@ -299,8 +299,6 @@ pub struct Config {
|
||||
pub forced_chatgpt_workspace_id: Option<ForcedChatgptWorkspaceIds>,
|
||||
pub forced_login_method: Option<ForcedLoginMethod>,
|
||||
pub web_search: Option<WebSearchMode>,
|
||||
/// Effective tools.client_search_provider hint. Model-selected providers take precedence.
|
||||
pub client_search_provider: Option<codex_protocol::openai_models::WebSearchProvider>,
|
||||
pub tools: Option<ToolsV2>,
|
||||
pub instructions: Option<String>,
|
||||
pub developer_instructions: Option<String>,
|
||||
|
||||
@@ -2151,7 +2151,6 @@ fn config_granular_approval_policy_is_marked_experimental() {
|
||||
forced_chatgpt_workspace_id: None,
|
||||
forced_login_method: None,
|
||||
web_search: None,
|
||||
client_search_provider: None,
|
||||
tools: None,
|
||||
instructions: None,
|
||||
developer_instructions: None,
|
||||
@@ -2187,7 +2186,6 @@ fn config_approvals_reviewer_is_marked_experimental() {
|
||||
forced_chatgpt_workspace_id: None,
|
||||
forced_login_method: None,
|
||||
web_search: None,
|
||||
client_search_provider: None,
|
||||
tools: None,
|
||||
instructions: None,
|
||||
developer_instructions: None,
|
||||
|
||||
@@ -166,12 +166,8 @@ impl ConfigManager {
|
||||
|
||||
let json_value = serde_json::to_value(&effective_config_toml)
|
||||
.map_err(|err| ConfigManagerError::json("failed to serialize configuration", err))?;
|
||||
let mut config: ApiConfig = serde_json::from_value(json_value)
|
||||
let config: ApiConfig = serde_json::from_value(json_value)
|
||||
.map_err(|err| ConfigManagerError::json("failed to deserialize configuration", err))?;
|
||||
config.client_search_provider = effective_config_toml
|
||||
.tools
|
||||
.as_ref()
|
||||
.and_then(|tools| tools.client_search_provider);
|
||||
|
||||
let mut origins = layers.origins_with_path_filter(|segments| {
|
||||
layers
|
||||
|
||||
@@ -56,7 +56,6 @@ fn preset_to_info(preset: &ModelPreset, priority: i32) -> ModelInfo {
|
||||
availability_nux: preset.availability_nux.clone(),
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -692,7 +692,7 @@ async fn subagents_inherit_spawn_metadata_without_live_parent_updates(
|
||||
.with_provider_config("supports_websockets = true")
|
||||
.with_provider_config("supports_standalone_web_search = true")
|
||||
.enable_feature(Feature::StandaloneWebSearch)
|
||||
.with_root_config("web_search = \"live\"\ntools.client_search_provider = \"standalone\"")
|
||||
.with_root_config("web_search = \"live\"")
|
||||
.with_extra_config(&format!(
|
||||
"[agents]\nmax_depth = 3\n[features.multi_agent_v2]\nenabled = {multi_agent_v2}"
|
||||
))
|
||||
|
||||
@@ -680,7 +680,6 @@ 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",
|
||||
}))?)
|
||||
);
|
||||
|
||||
|
||||
@@ -27,7 +27,6 @@ use codex_app_server_protocol::WebSearchItem;
|
||||
use codex_config::types::AuthCredentialsStoreMode;
|
||||
use codex_features::Feature;
|
||||
use codex_models_manager::model_info::model_info_from_slug;
|
||||
use codex_protocol::config_types::WebSearchMode;
|
||||
use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS;
|
||||
use core_test_support::responses;
|
||||
use core_test_support::responses::strip_response_item_ids_from_json;
|
||||
@@ -610,420 +609,3 @@ async fn search_request(server: &MockServer, search_path: &str) -> Result<wiremo
|
||||
.find(|request| request.url.path() == search_path)
|
||||
.context("expected standalone search request")
|
||||
}
|
||||
|
||||
const XATU_V99: &str = "SonicBrowserToolV99";
|
||||
const PAPER_MODEL_TOOLS: &[&str] = &["literature_search_query", "other_model_tool"];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum SearchPolicy {
|
||||
Standard,
|
||||
HostedOnly,
|
||||
RequireNative,
|
||||
RequireNativeClientMcp,
|
||||
RequireNativeCached,
|
||||
RequireNativeTelemetry,
|
||||
RequireNativeDomainPolicy,
|
||||
HostAllowedDomains(&'static [&'static str]),
|
||||
Standalone(WebSearchMode),
|
||||
Disabled,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum DiscoveryFailure {
|
||||
Rpc(i32),
|
||||
Http(u16),
|
||||
}
|
||||
|
||||
/// Model Lab selection is resolved for the active turn on the same app-server used by both clients.
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::Standard, false; "xatu_literature_treatment")]
|
||||
#[test_case::test_case(XATU_V99, (&[], false), None, SearchPolicy::Standard, false; "xatu_control")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), Some(DiscoveryFailure::Rpc(-32603)), SearchPolicy::Standard, false; "critical_discovery_error")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), Some(DiscoveryFailure::Rpc(-32602)), SearchPolicy::Standard, false; "invalid_discovery_request")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), Some(DiscoveryFailure::Http(503)), SearchPolicy::Standard, false; "service_unavailable_after_retries_allows_fallback")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), Some(DiscoveryFailure::Http(403)), SearchPolicy::Standard, false; "forbidden_discovery_disables_search")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::HostedOnly, false; "work_hosted_only")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), Some(DiscoveryFailure::Rpc(-32603)), SearchPolicy::HostedOnly, false; "work_prohibits_native_fallback")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::Standard, true; "failed_invocation_never_replays_on_native")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, false), None, SearchPolicy::Standard, false; "host_disables_literature_only")]
|
||||
#[test_case::test_case(XATU_V99, (&["other_model_tool"], false), None, SearchPolicy::Standard, false; "model_with_other_supported_tools")]
|
||||
#[test_case::test_case("SonicBrowserToolV66", (PAPER_MODEL_TOOLS, false), None, SearchPolicy::Standard, false; "inherit_connector_version")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::RequireNative, false; "managed_native_requirement")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::RequireNativeClientMcp, false; "native_requirement_overrides_client_mcp_without_model_preference")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::RequireNativeCached, false; "native_requirement_enforces_cached_turn")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::RequireNativeTelemetry, false; "native_requirement_with_telemetry_and_no_search_connector")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::RequireNativeDomainPolicy, false; "native_requirement_cannot_bypass_connector_domain_policy")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::Standalone(WebSearchMode::Cached), false; "standalone_model_honors_cached_turn")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::Standalone(WebSearchMode::Live), false; "desktop_installation_id_preserves_standalone_search")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), Some(DiscoveryFailure::Rpc(-32603)), SearchPolicy::HostAllowedDomains(&[]), false; "empty_host_and_native_domain_lists_deny_fallback")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), Some(DiscoveryFailure::Rpc(-32603)), SearchPolicy::HostAllowedDomains(&["example.com"]), false; "matching_query_filter_cannot_authorize_cached_navigation")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::Standalone(WebSearchMode::Disabled), false; "standalone_model_honors_disabled_turn")]
|
||||
#[test_case::test_case(XATU_V99, (PAPER_MODEL_TOOLS, true), None, SearchPolicy::Disabled, false; "metadata_cannot_authorize_search")]
|
||||
#[tokio::test]
|
||||
async fn model_lab_search_provider(
|
||||
pinned_type: &str,
|
||||
(supported_tools, pinned_literature): (&[&str], bool),
|
||||
error: Option<DiscoveryFailure>,
|
||||
policy: SearchPolicy,
|
||||
invocation_error: bool,
|
||||
) -> Result<()> {
|
||||
use core_test_support::apps_test_server::AppsTestServer;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
let server = responses::start_mock_server().await;
|
||||
let tool = json!({
|
||||
"name": "search_service.web_run", "description": "Search", "annotations": {"readOnlyHint": true},
|
||||
"inputSchema": {"type":"object","properties":{"system2_search_query":{"type":"array"},"open":{"type":"array"}}},
|
||||
"_meta": {"connector_id": codex_mcp::SEARCH_CONNECTOR, "connector_name":"search_service"}
|
||||
});
|
||||
let catalog_tools = if policy == SearchPolicy::RequireNativeTelemetry {
|
||||
vec![]
|
||||
} else {
|
||||
vec![tool.clone()]
|
||||
};
|
||||
let apps =
|
||||
AppsTestServer::mount_with_tools(&server, Arc::new(Mutex::new(catalog_tools))).await?;
|
||||
let mut pinned = tool;
|
||||
let search_query = if pinned_type == "SonicBrowserToolV66" {
|
||||
let properties = pinned["inputSchema"]["properties"]
|
||||
.as_object_mut()
|
||||
.context("search schema")?;
|
||||
let query = properties
|
||||
.remove("system2_search_query")
|
||||
.context("query schema")?;
|
||||
properties.insert("system1_search_query".into(), query);
|
||||
"system1_search_query"
|
||||
} else {
|
||||
"system2_search_query"
|
||||
};
|
||||
if pinned_literature {
|
||||
pinned["inputSchema"]["properties"]["literature_search_query"] =
|
||||
json!({"type":"array","items":{"type":"object"}});
|
||||
}
|
||||
let profile =
|
||||
json!({"config":{"tool_type":pinned_type,"allow_literature_search":pinned_literature}});
|
||||
pinned["_meta"]["_codex_apps"] = json!({"invocation_context":profile});
|
||||
Mock::given(method("POST"))
|
||||
.and(wiremock::matchers::body_partial_json(json!({
|
||||
"method":"tools/list","params":{"_meta":{"x-codex-turn-metadata":{"mcp_request_meta":{
|
||||
"openai/search_context":{"model_supported_tools":supported_tools}
|
||||
}}}}
|
||||
})))
|
||||
.respond_with(move |r: &wiremock::Request| {
|
||||
let req: Value = r.body_json().expect("JSON-RPC request");
|
||||
let mut response = json!({"jsonrpc":"2.0","id":req["id"]});
|
||||
match error {
|
||||
Some(DiscoveryFailure::Http(status)) => return ResponseTemplate::new(status),
|
||||
Some(DiscoveryFailure::Rpc(code)) => {
|
||||
response["error"] = json!({"code":code,"message":"discovery failed"});
|
||||
}
|
||||
None => response["result"] = json!({"tools":[pinned]}),
|
||||
}
|
||||
ResponseTemplate::new(200).set_body_json(response)
|
||||
})
|
||||
.with_priority(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let namespace = "mcp__codex_apps__search_service";
|
||||
let key = if pinned_literature {
|
||||
"literature_search_query"
|
||||
} else {
|
||||
search_query
|
||||
};
|
||||
let commands = json!({(key): [{"q":"plasma biomarkers"}]});
|
||||
let mut steps = Vec::new();
|
||||
let native = matches!(
|
||||
policy,
|
||||
SearchPolicy::RequireNative
|
||||
| SearchPolicy::RequireNativeClientMcp
|
||||
| SearchPolicy::RequireNativeCached
|
||||
| SearchPolicy::RequireNativeTelemetry
|
||||
| SearchPolicy::Standalone(WebSearchMode::Cached | WebSearchMode::Live)
|
||||
) || (matches!(
|
||||
error,
|
||||
Some(DiscoveryFailure::Rpc(-32603) | DiscoveryFailure::Http(503))
|
||||
) && policy == SearchPolicy::Standard);
|
||||
if let SearchPolicy::HostAllowedDomains(domains) = policy
|
||||
&& !domains.is_empty()
|
||||
{
|
||||
// A stale model call must not reach native, even for a URL already in its cache.
|
||||
steps.push(responses::sse(vec![
|
||||
responses::ev_function_call_with_namespace(
|
||||
"outside",
|
||||
"web",
|
||||
"run",
|
||||
&json!({"open":[{"ref_id":"https://outside.example/paper"}]}).to_string(),
|
||||
),
|
||||
responses::ev_completed("outside"),
|
||||
]));
|
||||
}
|
||||
if native {
|
||||
mount_search_response(&server, "/v1/alpha/search", /*expected_calls*/ 1).await;
|
||||
steps.push(responses::sse(vec![
|
||||
responses::ev_function_call_with_namespace(
|
||||
"native-search",
|
||||
"web",
|
||||
"run",
|
||||
&commands.to_string(),
|
||||
),
|
||||
responses::ev_completed("native"),
|
||||
]));
|
||||
}
|
||||
let allow_hosted = matches!(
|
||||
policy,
|
||||
SearchPolicy::Standard | SearchPolicy::HostedOnly | SearchPolicy::HostAllowedDomains(_)
|
||||
);
|
||||
let hosted = allow_hosted && error.is_none();
|
||||
if hosted {
|
||||
steps.push(responses::sse(vec![
|
||||
responses::ev_tool_search_call(
|
||||
"find-search",
|
||||
&json!({"query": "search_service web_run"}),
|
||||
),
|
||||
responses::ev_completed("discovered"),
|
||||
]));
|
||||
steps.push(responses::sse(vec![
|
||||
responses::ev_function_call_with_namespace(
|
||||
"search-1",
|
||||
namespace,
|
||||
"_web_run",
|
||||
&commands.to_string(),
|
||||
),
|
||||
responses::ev_completed("resp-1"),
|
||||
]));
|
||||
Mock::given(method("POST"))
|
||||
.and(wiremock::matchers::body_partial_json(json!({
|
||||
"method": "tools/call",
|
||||
"params": {"name": "search_service.web_run"}
|
||||
})))
|
||||
.respond_with(move |r: &wiremock::Request| {
|
||||
let body: Value = r.body_json().expect("JSON-RPC request");
|
||||
ResponseTemplate::new(200).set_body_json(json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": body["id"],
|
||||
"result": {
|
||||
"isError": invocation_error,
|
||||
"content": [{"type": "text", "text": "search result"}]
|
||||
}
|
||||
}))
|
||||
})
|
||||
.with_priority(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
}
|
||||
steps.push(responses::sse(vec![
|
||||
responses::ev_assistant_message("msg", "Done"),
|
||||
responses::ev_completed("resp-final"),
|
||||
]));
|
||||
let responses = responses::mount_sse_sequence(&server, steps).await;
|
||||
let home = TempDir::new()?;
|
||||
let mut model = model_info_from_slug("mock-model");
|
||||
model.web_search_provider = match policy {
|
||||
SearchPolicy::RequireNativeClientMcp => None,
|
||||
SearchPolicy::Standalone(_) => {
|
||||
Some(codex_protocol::openai_models::WebSearchProvider::Standalone)
|
||||
}
|
||||
_ => Some(codex_protocol::openai_models::WebSearchProvider::SearchMcp),
|
||||
};
|
||||
model.supports_search_tool = true;
|
||||
model.use_responses_lite = true;
|
||||
model.experimental_supported_tools = supported_tools
|
||||
.iter()
|
||||
.map(|tool| (*tool).to_owned())
|
||||
.collect();
|
||||
let catalog = home.path().join("models.json");
|
||||
std::fs::write(&catalog, serde_json::to_vec(&json!({"models":[model]}))?)?;
|
||||
let mode = if matches!(policy, SearchPolicy::HostedOnly | SearchPolicy::Disabled) {
|
||||
"disabled"
|
||||
} else {
|
||||
"live"
|
||||
};
|
||||
if matches!(
|
||||
policy,
|
||||
SearchPolicy::RequireNative
|
||||
| SearchPolicy::RequireNativeClientMcp
|
||||
| SearchPolicy::RequireNativeCached
|
||||
| SearchPolicy::RequireNativeTelemetry
|
||||
| SearchPolicy::RequireNativeDomainPolicy
|
||||
) {
|
||||
std::fs::write(
|
||||
home.path().join("requirements.toml"),
|
||||
"[feature_requirements]\nstandalone_web_search = true\n",
|
||||
)?;
|
||||
}
|
||||
let client_provider = if policy == SearchPolicy::RequireNativeClientMcp {
|
||||
"search_mcp"
|
||||
} else {
|
||||
"standalone"
|
||||
};
|
||||
let domain_config = match policy {
|
||||
SearchPolicy::HostAllowedDomains(domains) => format!(
|
||||
"\ntools.web_search.allowed_domains = {}",
|
||||
serde_json::to_string(domains)?
|
||||
),
|
||||
_ => String::new(),
|
||||
};
|
||||
MockResponsesConfig::new(&server.uri())
|
||||
.with_root_config(&format!(
|
||||
"chatgpt_base_url = {}\nmodel_catalog_json = {}\nweb_search = \"{mode}\"\ntools.client_search_provider = \"{client_provider}\"{domain_config}",
|
||||
serde_json::to_string(&apps.chatgpt_base_url)?,
|
||||
serde_json::to_string(&catalog)?,
|
||||
))
|
||||
.with_model_provider("openai-custom")
|
||||
.with_provider_name("OpenAI")
|
||||
.with_provider_config("requires_openai_auth = true")
|
||||
.with_features(&[
|
||||
(Feature::Apps, !matches!(policy, SearchPolicy::Standalone(_))),
|
||||
(Feature::StandaloneWebSearch, true),
|
||||
(Feature::HostedSearchPolicy, policy == SearchPolicy::HostedOnly),
|
||||
].into())
|
||||
.with_provider_config("supports_websockets = false")
|
||||
.with_provider_config("supports_standalone_web_search = true")
|
||||
.write(home.path())?;
|
||||
write_chatgpt_auth(
|
||||
home.path(),
|
||||
ChatGptAuthFixture::new("test-account-token").account_id("account-123"),
|
||||
AuthCredentialsStoreMode::File,
|
||||
)?;
|
||||
let mut app = TestAppServer::builder()
|
||||
.with_codex_home(home.path())
|
||||
.with_env_overrides(&[("OPENAI_API_KEY", None)])
|
||||
.build_initialized()
|
||||
.await?;
|
||||
let thread = app.start_thread(ThreadStartParams::default()).await?.thread;
|
||||
if allow_hosted {
|
||||
// A binding captured during MCP startup need not be cached: its catalogs can
|
||||
// still change. Measure per-turn discovery reuse with an already stable binding.
|
||||
timeout(
|
||||
DEFAULT_READ_TIMEOUT,
|
||||
app.read_stream_until_matching_notification("search connector ready", |notification| {
|
||||
notification.method == "mcpServer/startupStatus/updated"
|
||||
&& notification.params.as_ref().is_some_and(|params| {
|
||||
params["threadId"] == thread.id
|
||||
&& params["name"] == codex_mcp::CODEX_APPS_MCP_SERVER_NAME
|
||||
&& params["status"] == "ready"
|
||||
})
|
||||
}),
|
||||
)
|
||||
.await??;
|
||||
}
|
||||
app.start_turn_and_wait_for_completion(TurnStartParams {
|
||||
thread_id: thread.id,
|
||||
responsesapi_client_metadata: match policy {
|
||||
SearchPolicy::HostedOnly | SearchPolicy::Disabled => Some(json!({"mode":"live"})),
|
||||
SearchPolicy::RequireNativeCached => Some(json!({"mode":"cached"})),
|
||||
SearchPolicy::RequireNativeTelemetry => {
|
||||
Some(json!({"telemetry_attributes":{"source":"test"}}))
|
||||
}
|
||||
SearchPolicy::RequireNativeDomainPolicy => {
|
||||
Some(json!({"allowed_domains":["example.org"]}))
|
||||
}
|
||||
SearchPolicy::HostAllowedDomains([]) => Some(json!({"allowed_domains":[]})),
|
||||
SearchPolicy::HostAllowedDomains(domains) => {
|
||||
Some(json!({"mode":"cached","allowed_domains":domains}))
|
||||
}
|
||||
SearchPolicy::Standalone(mode) => Some(json!({"mode":mode})),
|
||||
_ => None,
|
||||
}
|
||||
.map(|context| {
|
||||
let mut meta = json!({"openai/search_context":context});
|
||||
if matches!(
|
||||
policy,
|
||||
SearchPolicy::Standalone(_) | SearchPolicy::RequireNativeTelemetry
|
||||
) {
|
||||
meta["openai/codex_installation_id"] = json!("desktop-installation");
|
||||
}
|
||||
[("mcp_request_meta".to_string(), meta.to_string())].into()
|
||||
}),
|
||||
input: vec![V2UserInput::Text {
|
||||
text: "Search papers".into(),
|
||||
text_elements: vec![],
|
||||
}],
|
||||
..Default::default()
|
||||
})
|
||||
.await?;
|
||||
let requests = responses.requests();
|
||||
let received = server
|
||||
.received_requests()
|
||||
.await
|
||||
.context("recorded search requests")?;
|
||||
let rpc: Vec<Value> = received
|
||||
.iter()
|
||||
.filter_map(|r| r.body_json::<Value>().ok())
|
||||
.filter(|r| r.get("method").is_some())
|
||||
.collect();
|
||||
let scoped_lists = rpc
|
||||
.iter()
|
||||
.filter(|r| r["method"] == "tools/list")
|
||||
.filter_map(|r| {
|
||||
r.pointer("/params/_meta/x-codex-turn-metadata/mcp_request_meta/openai~1search_context")
|
||||
})
|
||||
.filter(|ctx| ctx["model_supported_tools"] == json!(supported_tools))
|
||||
.count();
|
||||
if error == Some(DiscoveryFailure::Http(503)) {
|
||||
assert!(scoped_lists > 1, "fallback should follow a discovery retry");
|
||||
} else {
|
||||
assert_eq!(scoped_lists, usize::from(allow_hosted));
|
||||
}
|
||||
let request = requests[0].body_json();
|
||||
let tools = request["input"]
|
||||
.as_array()
|
||||
.context("Lite input")?
|
||||
.iter()
|
||||
.find(|item| item["type"] == "additional_tools")
|
||||
.context("Lite additional_tools")?;
|
||||
let find_tool = |ns: &str, name: &str| responses::namespace_child_tool(tools, ns, name);
|
||||
assert_eq!(find_tool("web", "run").is_some(), native);
|
||||
assert!(!has_hosted_web_search(&request));
|
||||
assert!(find_tool(namespace, "_web_run").is_none());
|
||||
if hosted {
|
||||
let found = requests[1].tool_search_output("find-search");
|
||||
let tool = responses::namespace_child_tool(&found, namespace, "_web_run")
|
||||
.context("profiled search tool in the lookup result")?;
|
||||
assert_eq!(
|
||||
tool.pointer("/parameters/properties/literature_search_query")
|
||||
.is_some(),
|
||||
pinned_literature
|
||||
);
|
||||
assert!(
|
||||
requests[2]
|
||||
.function_call_output("search-1")
|
||||
.to_string()
|
||||
.contains("search result")
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
received
|
||||
.iter()
|
||||
.filter(|r| r.url.path().ends_with("/alpha/search"))
|
||||
.count(),
|
||||
usize::from(native)
|
||||
);
|
||||
if matches!(
|
||||
policy,
|
||||
SearchPolicy::Standalone(WebSearchMode::Cached)
|
||||
| SearchPolicy::RequireNativeCached
|
||||
| SearchPolicy::RequireNativeTelemetry
|
||||
) {
|
||||
let body = search_request(&server, "/v1/alpha/search")
|
||||
.await?
|
||||
.body_json::<Value>()?;
|
||||
assert_eq!(
|
||||
body["settings"]["external_web_access"],
|
||||
policy == SearchPolicy::RequireNativeTelemetry
|
||||
);
|
||||
}
|
||||
let calls = core_test_support::apps_test_server::recorded_apps_tool_calls(&server).await;
|
||||
assert_eq!(calls.len(), usize::from(hosted));
|
||||
if let Some(call) = calls.first() {
|
||||
assert_eq!(call["params"]["arguments"], commands);
|
||||
assert_eq!(
|
||||
call.pointer("/params/_meta/x-codex-turn-metadata/mcp_request_meta/openai~1search_context/model_supported_tools"),
|
||||
Some(&json!(supported_tools))
|
||||
);
|
||||
assert_eq!(
|
||||
call.pointer("/params/_meta/_codex_apps/invocation_context"),
|
||||
Some(&profile)
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -148,7 +148,6 @@ async fn models_client_hits_models_endpoint() {
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -1,11 +1,5 @@
|
||||
//! Immutable MCP catalog and execution handles.
|
||||
|
||||
#[path = "model_search.rs"]
|
||||
mod model_search;
|
||||
pub use model_search::SEARCH_CONNECTOR;
|
||||
pub use model_search::SearchDiscovery;
|
||||
pub use model_search::is_model_search_tool;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::fmt;
|
||||
use std::future::Future;
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
pub use binding::McpBinding;
|
||||
pub use binding::McpPermissionSource;
|
||||
pub use binding::PreparedMcpCall;
|
||||
pub use binding::SEARCH_CONNECTOR;
|
||||
pub use binding::SearchDiscovery;
|
||||
pub use binding::is_model_search_tool;
|
||||
pub use binding_clients::McpResourceListing;
|
||||
pub use client_capabilities::client_mcp_extensions;
|
||||
pub use client_tool_catalog::CodexAppsToolSnapshot;
|
||||
|
||||
@@ -1,146 +0,0 @@
|
||||
//! Resolve the model's Search profile on an already authorized Apps connection.
|
||||
//! Keep the projected declaration and invocation pin private to its sampling step.
|
||||
|
||||
use super::McpBinding;
|
||||
use crate::CODEX_APPS_MCP_SERVER_NAME;
|
||||
use crate::MCP_TOOL_CODEX_APPS_META_KEY;
|
||||
use crate::pagination::MAX_CODEX_APPS_TOOL_CATALOG_ITEMS;
|
||||
use crate::pagination::collect_paginated_with_limit;
|
||||
use rmcp::model::RequestMetaObject;
|
||||
use serde_json::Value as JsonValue;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
pub const SEARCH_CONNECTOR: &str = "connector_openai_search_service";
|
||||
|
||||
pub fn is_model_search_tool(tool: &crate::ToolInfo) -> bool {
|
||||
tool.server_name() == CODEX_APPS_MCP_SERVER_NAME
|
||||
&& tool.connector_id.as_deref() == Some(SEARCH_CONNECTOR)
|
||||
&& tool.tool.name.rsplit('.').next() == Some("web_run")
|
||||
}
|
||||
|
||||
pub enum SearchDiscovery {
|
||||
Ready(Arc<McpBinding>),
|
||||
Critical(&'static str),
|
||||
Unavailable,
|
||||
}
|
||||
|
||||
impl McpBinding {
|
||||
/// Preserve the discovery pin while letting normal dispatch recheck current tool visibility,
|
||||
/// account selection and approval policy. Never transfer the pin to a different transport.
|
||||
pub fn search_invocation_context(&self, live: &crate::PreparedMcpCall) -> Option<&JsonValue> {
|
||||
if !live.is_host_owned_apps() {
|
||||
return None;
|
||||
}
|
||||
let tool = live.tool_info();
|
||||
let scoped = self
|
||||
.calls
|
||||
.get(&(tool.server_key().clone(), tool.tool.name.to_string()))?;
|
||||
if !Arc::ptr_eq(&scoped.client.client, &live.client.client) {
|
||||
return None;
|
||||
}
|
||||
invocation_context(&scoped.tool_info().tool)
|
||||
}
|
||||
|
||||
/// A catalog omission, policy denial, or untrusted registration never authorizes fallback.
|
||||
pub async fn discover_model_search(&self, turn_metadata: JsonValue) -> SearchDiscovery {
|
||||
let Some((index, original)) = self
|
||||
.tools
|
||||
.iter()
|
||||
.enumerate()
|
||||
.find(|(_, tool)| is_model_search_tool(tool))
|
||||
else {
|
||||
return SearchDiscovery::Unavailable;
|
||||
};
|
||||
let key = (
|
||||
original.server_key().clone(),
|
||||
original.tool.name.to_string(),
|
||||
);
|
||||
let Some(call) = self
|
||||
.calls
|
||||
.get(&key)
|
||||
.filter(|call| call.is_host_owned_apps())
|
||||
else {
|
||||
return SearchDiscovery::Unavailable;
|
||||
};
|
||||
let meta = RequestMetaObject::from(serde_json::Map::from_iter([(
|
||||
"x-codex-turn-metadata".to_string(),
|
||||
turn_metadata,
|
||||
)]));
|
||||
let client = &call.client;
|
||||
let limit = Duration::from_secs(5);
|
||||
let listed = collect_paginated_with_limit(
|
||||
"tools/list",
|
||||
/*overall_timeout*/ None,
|
||||
MAX_CODEX_APPS_TOOL_CATALOG_ITEMS,
|
||||
|params| {
|
||||
let mut params = params.unwrap_or_default();
|
||||
params.meta = Some(meta.clone());
|
||||
async move {
|
||||
let page = client
|
||||
.client
|
||||
.list_tools_with_connector_ids(Some(params), /*timeout*/ None)
|
||||
.await?;
|
||||
Ok((page.tools, page.next_cursor))
|
||||
}
|
||||
},
|
||||
);
|
||||
let listed = tokio::time::timeout(limit, client.with_lease_request(listed)).await;
|
||||
let tools = match listed {
|
||||
Err(_) => return SearchDiscovery::Critical("discovery_timeout"),
|
||||
Ok(Err(err)) => {
|
||||
if matches!(
|
||||
codex_rmcp_client::request_error_code(&err),
|
||||
Some("transport_closed" | "request_timeout")
|
||||
) || codex_rmcp_client::is_retryable_transport_error(&err)
|
||||
|| codex_rmcp_client::mcp_error(&err).is_some_and(|e| e.code.0 == -32603)
|
||||
{
|
||||
return SearchDiscovery::Critical("discovery_error");
|
||||
}
|
||||
return SearchDiscovery::Unavailable;
|
||||
}
|
||||
Ok(Ok(tools)) => tools,
|
||||
};
|
||||
let Some(listed) = tools.into_iter().find(|tool| {
|
||||
tool.connector_id.as_deref() == Some(SEARCH_CONNECTOR)
|
||||
&& tool.tool.name == original.tool.name
|
||||
}) else {
|
||||
return SearchDiscovery::Unavailable;
|
||||
};
|
||||
let mut projected = original.clone();
|
||||
projected.namespace_description = listed.connector_description;
|
||||
projected.tool = listed.tool;
|
||||
if !crate::tool_is_model_visible(&projected)
|
||||
|| invocation_context(&projected.tool).is_none()
|
||||
{
|
||||
return SearchDiscovery::Unavailable;
|
||||
}
|
||||
let mut tools = self.tools.to_vec();
|
||||
tools[index] = projected.clone();
|
||||
let mut calls = self.calls.clone();
|
||||
let mut call = call.clone();
|
||||
call.tool_info = projected.into();
|
||||
calls.insert(key, call);
|
||||
SearchDiscovery::Ready(Arc::new(Self::new(
|
||||
Arc::clone(&self.connections),
|
||||
Arc::clone(&self.clients),
|
||||
Arc::clone(&self.config),
|
||||
self.plugins_available,
|
||||
tools,
|
||||
calls,
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
// The connector owns the contents of its invocation context.
|
||||
fn invocation_context(tool: &rmcp::model::Tool) -> Option<&JsonValue> {
|
||||
tool.meta
|
||||
.as_ref()?
|
||||
.get(MCP_TOOL_CODEX_APPS_META_KEY)?
|
||||
.get("invocation_context")
|
||||
.filter(|context| context.is_object())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "model_search_tests.rs"]
|
||||
mod tests;
|
||||
@@ -1,20 +0,0 @@
|
||||
#![cfg(test)]
|
||||
|
||||
use super::invocation_context;
|
||||
use rmcp::model::Tool;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn discovery_preserves_the_connectors_opaque_invocation_context() {
|
||||
let mut declaration = json!({
|
||||
"name": "search_service.web_run",
|
||||
"inputSchema": {"type": "object"},
|
||||
});
|
||||
let tool: Tool = serde_json::from_value(declaration.clone()).unwrap();
|
||||
assert_eq!(invocation_context(&tool), None);
|
||||
|
||||
let pin = json!({"revision": "connector-selected"});
|
||||
declaration["_meta"] = json!({"_codex_apps": {"invocation_context": pin}});
|
||||
let tool: Tool = serde_json::from_value(declaration).unwrap();
|
||||
assert_eq!(invocation_context(&tool), Some(&pin));
|
||||
}
|
||||
@@ -59,10 +59,7 @@ impl ManagedClient {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) async fn with_lease_request<T>(
|
||||
&self,
|
||||
operation: impl Future<Output = Result<T>>,
|
||||
) -> Result<T> {
|
||||
async fn with_lease_request<T>(&self, operation: impl Future<Output = Result<T>>) -> Result<T> {
|
||||
// Keep one copy of the request future as it passes through both lease scopes.
|
||||
let operation = std::pin::pin!(operation);
|
||||
self.with_active_shared_lease(async {
|
||||
|
||||
@@ -720,8 +720,6 @@ pub struct RealtimeAudioToml {
|
||||
#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, JsonSchema)]
|
||||
#[schemars(deny_unknown_fields)]
|
||||
pub struct ToolsToml {
|
||||
/// Client provider preference when the model does not select a provider.
|
||||
pub client_search_provider: Option<codex_protocol::openai_models::WebSearchProvider>,
|
||||
#[serde(
|
||||
default,
|
||||
deserialize_with = "deserialize_optional_web_search_tool_config"
|
||||
|
||||
@@ -1126,9 +1126,6 @@
|
||||
"hooks": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"hosted_search_policy": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"image_detail_original": {
|
||||
"type": "boolean"
|
||||
},
|
||||
@@ -5410,14 +5407,6 @@
|
||||
"ToolsToml": {
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
"client_search_provider": {
|
||||
"allOf": [
|
||||
{
|
||||
"$ref": "#/definitions/WebSearchProvider"
|
||||
}
|
||||
],
|
||||
"description": "Client provider preference when the model does not select a provider."
|
||||
},
|
||||
"experimental_request_user_input": {
|
||||
"$ref": "#/definitions/ExperimentalRequestUserInput"
|
||||
},
|
||||
@@ -7945,14 +7934,6 @@
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchProvider": {
|
||||
"description": "Provider preference selected by the resolved model catalog entry.",
|
||||
"enum": [
|
||||
"standalone",
|
||||
"search_mcp"
|
||||
],
|
||||
"type": "string"
|
||||
},
|
||||
"WebSearchToolConfig": {
|
||||
"additionalProperties": false,
|
||||
"properties": {
|
||||
@@ -8497,9 +8478,6 @@
|
||||
"hooks": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"hosted_search_policy": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"image_detail_original": {
|
||||
"type": "boolean"
|
||||
},
|
||||
|
||||
@@ -492,7 +492,8 @@ web_search = true
|
||||
cfg.tools,
|
||||
Some(ToolsToml {
|
||||
web_search: None,
|
||||
..Default::default()
|
||||
experimental_request_user_input: None,
|
||||
update_plan: None,
|
||||
})
|
||||
);
|
||||
}
|
||||
@@ -511,7 +512,8 @@ web_search = false
|
||||
cfg.tools,
|
||||
Some(ToolsToml {
|
||||
web_search: None,
|
||||
..Default::default()
|
||||
experimental_request_user_input: None,
|
||||
update_plan: None,
|
||||
})
|
||||
);
|
||||
}
|
||||
@@ -528,8 +530,9 @@ fn tools_experimental_request_user_input_defaults_to_enabled() {
|
||||
assert_eq!(
|
||||
cfg.tools,
|
||||
Some(ToolsToml {
|
||||
web_search: None,
|
||||
experimental_request_user_input: Some(ExperimentalRequestUserInput { enabled: true }),
|
||||
..Default::default()
|
||||
update_plan: None,
|
||||
})
|
||||
);
|
||||
}
|
||||
@@ -547,8 +550,9 @@ enabled = false
|
||||
assert_eq!(
|
||||
cfg.tools,
|
||||
Some(ToolsToml {
|
||||
web_search: None,
|
||||
experimental_request_user_input: Some(ExperimentalRequestUserInput { enabled: false }),
|
||||
..Default::default()
|
||||
update_plan: None,
|
||||
})
|
||||
);
|
||||
}
|
||||
@@ -564,7 +568,6 @@ async fn load_config_resolves_experimental_request_user_input_enabled() -> std::
|
||||
enabled: false,
|
||||
}),
|
||||
update_plan: None,
|
||||
..Default::default()
|
||||
}),
|
||||
..ConfigToml::default()
|
||||
},
|
||||
|
||||
@@ -119,7 +119,6 @@ pub(crate) mod mcp;
|
||||
mod mcp_skill_dependencies;
|
||||
mod mcp_tool_approval_templates;
|
||||
mod mcp_tool_exposure;
|
||||
mod model_search;
|
||||
mod network_policy_decision;
|
||||
pub use mcp::McpManager;
|
||||
pub use mcp::McpServersDisabled;
|
||||
|
||||
@@ -506,38 +506,6 @@ async fn handle_approved_mcp_tool_call(
|
||||
let mut tool_input = arguments_value
|
||||
.clone()
|
||||
.unwrap_or_else(|| JsonValue::Object(serde_json::Map::new()));
|
||||
let is_search = prepared_call.is_host_owned_apps()
|
||||
&& codex_mcp::is_model_search_tool(prepared_call.tool_info());
|
||||
let search = if is_search {
|
||||
step_context
|
||||
.extension_data
|
||||
.get::<crate::model_search::ModelSearch>()
|
||||
} else {
|
||||
None
|
||||
};
|
||||
// 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,
|
||||
call_id,
|
||||
invocation,
|
||||
item_metadata,
|
||||
"This thread is using native search".to_string(),
|
||||
/*already_started*/ true,
|
||||
)
|
||||
.await;
|
||||
return Ok(CompletedMcpToolCall {
|
||||
result: CallToolResult::from_result(result),
|
||||
tool_input,
|
||||
});
|
||||
}
|
||||
let mut elicitation_type = None;
|
||||
let mut request_error_code = None;
|
||||
let mut admission_error = None;
|
||||
@@ -638,32 +606,6 @@ async fn handle_approved_mcp_tool_call(
|
||||
serde_json::json!(turn_context.cyber_access_program),
|
||||
);
|
||||
}
|
||||
let request_meta = if let Some(crate::model_search::ModelSearch::Hosted {
|
||||
binding,
|
||||
context,
|
||||
}) = search.as_deref()
|
||||
{
|
||||
let mut meta = request_meta.unwrap_or_else(|| serde_json::json!({}));
|
||||
let turn_meta = meta
|
||||
.as_object_mut()
|
||||
.ok_or_else(|| anyhow::anyhow!("invalid MCP metadata"))?
|
||||
.entry(crate::X_CODEX_TURN_METADATA_HEADER)
|
||||
.or_insert_with(|| serde_json::json!({}));
|
||||
crate::model_search::with_search_context(turn_meta, context)?;
|
||||
let pin = binding
|
||||
.search_invocation_context(&prepared_call)
|
||||
.ok_or_else(|| {
|
||||
anyhow::anyhow!("Search MCP connection changed after discovery")
|
||||
})?;
|
||||
let apps = meta
|
||||
.get_mut(MCP_TOOL_CODEX_APPS_META_KEY)
|
||||
.and_then(serde_json::Value::as_object_mut)
|
||||
.ok_or_else(|| anyhow::anyhow!("missing hosted Apps call metadata"))?;
|
||||
apps.insert("invocation_context".to_string(), pin.clone());
|
||||
Some(meta)
|
||||
} else {
|
||||
request_meta
|
||||
};
|
||||
let request_meta = with_mcp_tool_call_ids_meta(
|
||||
request_meta,
|
||||
&sess.thread_id.to_string(),
|
||||
@@ -676,17 +618,6 @@ async fn handle_approved_mcp_tool_call(
|
||||
request_meta,
|
||||
)
|
||||
.await?;
|
||||
if is_search
|
||||
&& let Some(usage) = step_context
|
||||
.turn
|
||||
.extension_data
|
||||
.get::<crate::model_search::SearchTurnUsage>()
|
||||
{
|
||||
usage.record(
|
||||
&step_context.turn,
|
||||
codex_protocol::openai_models::WebSearchProvider::SearchMcp,
|
||||
);
|
||||
}
|
||||
let mcp_call_trace = sess
|
||||
.services
|
||||
.rollout_thread_trace
|
||||
|
||||
@@ -245,7 +245,7 @@ fn filter_non_codex_apps_mcp_tools_only(
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn filter_codex_apps_mcp_tools<'a>(
|
||||
fn filter_codex_apps_mcp_tools<'a>(
|
||||
mcp_tools: &'a [McpToolInfo],
|
||||
config: &'a Config,
|
||||
) -> impl Iterator<Item = &'a McpToolInfo> + 'a {
|
||||
|
||||
@@ -1,500 +0,0 @@
|
||||
//! Resolve one search provider for the sampling step, preserving the host's search policy.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
use std::sync::Weak;
|
||||
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::openai_models::WebSearchProvider;
|
||||
use codex_tools::ToolSpec;
|
||||
use serde_json::Map;
|
||||
use serde_json::Value;
|
||||
use serde_json::json;
|
||||
|
||||
use crate::session::step_settings::ResolvedStepSettings;
|
||||
use crate::session::turn_context::TurnContext;
|
||||
use crate::state::SessionServices;
|
||||
use crate::turn_metadata::ExecutionMetadata;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) enum ModelSearch {
|
||||
Hosted {
|
||||
binding: Arc<McpBinding>,
|
||||
context: Map<String, Value>,
|
||||
},
|
||||
ClientMcp,
|
||||
Native {
|
||||
mode: WebSearchMode,
|
||||
fallback: bool,
|
||||
},
|
||||
Disabled,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct SearchTurnUsage(AtomicU8);
|
||||
|
||||
impl SearchTurnUsage {
|
||||
const MCP: u8 = 1;
|
||||
const NATIVE: u8 = 2;
|
||||
|
||||
pub(crate) fn record(&self, turn: &TurnContext, provider: WebSearchProvider) {
|
||||
let (flag, label) = match provider {
|
||||
WebSearchProvider::SearchMcp => (Self::MCP, "search_mcp"),
|
||||
WebSearchProvider::Standalone => (Self::NATIVE, "native"),
|
||||
};
|
||||
let previous = self.0.fetch_or(flag, Ordering::Relaxed);
|
||||
if previous & flag == 0 {
|
||||
turn.session_telemetry.counter(
|
||||
"codex.model_search.turn",
|
||||
/*inc*/ 1,
|
||||
&[("provider", label)],
|
||||
);
|
||||
if previous != 0 {
|
||||
turn.session_telemetry.counter(
|
||||
"codex.model_search.turn",
|
||||
/*inc*/ 1,
|
||||
&[("provider", "mixed")],
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct CachedSearch {
|
||||
base: Arc<McpBinding>,
|
||||
request: Map<String, Value>,
|
||||
discovery: SearchDiscovery,
|
||||
}
|
||||
|
||||
/// Concurrent calls on the same provider share a reservation. An actual search
|
||||
/// keeps it for the thread. An unused offer releases it when sampling finishes.
|
||||
pub(crate) struct SearchOwner(WebSearchProvider);
|
||||
|
||||
impl SearchOwner {
|
||||
fn reserve(store: &ExtensionData, provider: WebSearchProvider) -> Option<Arc<Self>> {
|
||||
let slot = store.get_or_init(Mutex::<Weak<Self>>::default);
|
||||
let mut slot = slot
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
if let Some(owner) = slot.upgrade() {
|
||||
return (owner.0 == provider).then_some(owner);
|
||||
}
|
||||
let owner = Arc::new(Self(provider));
|
||||
*slot = Arc::downgrade(&owner);
|
||||
Some(owner)
|
||||
}
|
||||
|
||||
pub(crate) fn admit(store: &ExtensionData, provider: WebSearchProvider) -> bool {
|
||||
let Some(owner) = Self::reserve(store, provider) else {
|
||||
return false;
|
||||
};
|
||||
store.insert_arc(owner);
|
||||
true
|
||||
}
|
||||
|
||||
pub(crate) fn reserve_native_fallback(
|
||||
step: &ExtensionData,
|
||||
thread: &ExtensionData,
|
||||
) -> Result<Option<Arc<Self>>, &'static str> {
|
||||
if matches!(
|
||||
step.get::<ModelSearch>().as_deref(),
|
||||
Some(ModelSearch::Native { fallback: true, .. })
|
||||
) {
|
||||
return Self::reserve(thread, WebSearchProvider::Standalone)
|
||||
.map(Some)
|
||||
.ok_or("Search MCP is already in use in this thread");
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
// Responses can execute its built-in search before the harness receives the
|
||||
// first search event. Reserve it while that request can still issue a call.
|
||||
pub(crate) fn reserve_server_fallback(
|
||||
step: &ExtensionData,
|
||||
thread: &ExtensionData,
|
||||
tools: &mut Arc<[ToolSpec]>,
|
||||
) -> Option<Arc<Self>> {
|
||||
let is_search = |tool: &ToolSpec| matches!(tool, ToolSpec::WebSearch { .. });
|
||||
if !tools.iter().any(is_search) {
|
||||
return None;
|
||||
}
|
||||
match Self::reserve_native_fallback(step, thread) {
|
||||
Ok(owner) => owner,
|
||||
Err(_) => {
|
||||
*tools = tools
|
||||
.iter()
|
||||
.filter(|tool| !is_search(tool))
|
||||
.cloned()
|
||||
.collect();
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn current(store: &ExtensionData) -> Option<WebSearchProvider> {
|
||||
store.get::<Self>().map(|owner| owner.0)
|
||||
}
|
||||
|
||||
pub(crate) fn restore(store: &ExtensionData, history: &InitialHistory) {
|
||||
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(search_mcp_used) = metadata.legacy_search_mcp_used {
|
||||
legacy_search_mcp |= search_mcp_used;
|
||||
}
|
||||
has_checkpoint |=
|
||||
metadata.model_search_state.is_some() || metadata.legacy_search_mcp_used.is_some();
|
||||
};
|
||||
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]) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn object(value: Option<&Value>) -> Option<Map<String, Value>> {
|
||||
match value {
|
||||
None => Some(Map::new()),
|
||||
Some(Value::Object(map)) => Some(map.clone()),
|
||||
Some(Value::String(encoded)) => serde_json::from_str(encoded).ok(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::config::Config {
|
||||
// Read the scalar override from the highest enabled configuration layer. Hosts can
|
||||
// supply it through normal session flags without extending the shared Config struct.
|
||||
pub(crate) fn client_search_provider(&self) -> Option<WebSearchProvider> {
|
||||
self.config_layer_stack
|
||||
.layers_high_to_low()
|
||||
.find_map(|layer| layer.config.get("tools")?.get("client_search_provider"))?
|
||||
.clone()
|
||||
.try_into()
|
||||
.ok()
|
||||
}
|
||||
|
||||
pub(crate) fn requires_native_search(&self) -> bool {
|
||||
let standalone = codex_features::Feature::StandaloneWebSearch;
|
||||
if !self.features.enabled(standalone) {
|
||||
return false;
|
||||
}
|
||||
let mut features = self.features.clone();
|
||||
features.disable(standalone).is_err() || features.enabled(standalone)
|
||||
}
|
||||
}
|
||||
|
||||
fn requested_mode(context: &Map<String, Value>, default: WebSearchMode) -> Option<WebSearchMode> {
|
||||
context.get("mode").map_or(Some(default), |value| {
|
||||
serde_json::from_value(value.clone()).ok()
|
||||
})
|
||||
}
|
||||
|
||||
// These host metadata fields do not select connectors. Preserve the installation ID
|
||||
// when narrowing discovery, and validate the search context separately for native.
|
||||
fn unrestricted_connectors(request: &Map<String, Value>) -> bool {
|
||||
request.keys().all(|key| {
|
||||
matches!(
|
||||
key.as_str(),
|
||||
"openai/search_context" | "openai/codex_installation_id"
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
fn native_search_mode(turn: &TurnContext, request: &Map<String, Value>) -> Option<WebSearchMode> {
|
||||
if !unrestricted_connectors(request) {
|
||||
return None;
|
||||
}
|
||||
let context = object(request.get("openai/search_context"))?;
|
||||
let configured = turn.config.web_search_mode.value();
|
||||
let mut mode = configured.restrict_to(requested_mode(&context, configured)?);
|
||||
// A host domain allowlist covers opens and clicks. Native filters only the query.
|
||||
for (key, value) in &context {
|
||||
match key.as_str() {
|
||||
"mode" | "telemetry_attributes" | "model_supported_tools" => {}
|
||||
"is_web_access_restricted" => {
|
||||
if value.as_bool()? {
|
||||
mode = mode.restrict_to(WebSearchMode::Cached);
|
||||
}
|
||||
}
|
||||
"session_persistent" if value.as_bool()? || turn.config.ephemeral => {}
|
||||
_ => return None,
|
||||
}
|
||||
}
|
||||
turn.config.web_search_mode.can_set(&mode).ok()?;
|
||||
(mode != WebSearchMode::Disabled).then_some(mode)
|
||||
}
|
||||
|
||||
fn search_context(turn: &TurnContext, request: &Map<String, Value>) -> Option<Map<String, Value>> {
|
||||
let native_mode = turn.config.web_search_mode.value();
|
||||
if !turn.apps_enabled() {
|
||||
return None;
|
||||
}
|
||||
let config = turn.config.web_search_config.as_ref();
|
||||
if config.is_some_and(|config| {
|
||||
config.user_location.is_some() || config.search_context_size.is_some()
|
||||
}) {
|
||||
return None;
|
||||
}
|
||||
let mut context = object(request.get("openai/search_context"))?;
|
||||
let host_mode = requested_mode(&context, native_mode)?;
|
||||
let mode = if native_mode == WebSearchMode::Disabled
|
||||
&& turn
|
||||
.config
|
||||
.features
|
||||
.enabled(codex_features::Feature::HostedSearchPolicy)
|
||||
{
|
||||
host_mode
|
||||
} else {
|
||||
native_mode.restrict_to(host_mode)
|
||||
};
|
||||
if mode == WebSearchMode::Disabled {
|
||||
return None;
|
||||
}
|
||||
turn.config.web_search_mode.can_set(&mode).ok()?;
|
||||
context.insert("mode".into(), json!(mode));
|
||||
let restricted = context
|
||||
.get("is_web_access_restricted")
|
||||
.map_or(Some(false), Value::as_bool)?;
|
||||
context.insert(
|
||||
"is_web_access_restricted".into(),
|
||||
json!(restricted || mode == WebSearchMode::Cached),
|
||||
);
|
||||
let persistent = context
|
||||
.get("session_persistent")
|
||||
.map_or(Some(true), Value::as_bool)?;
|
||||
context.insert(
|
||||
"session_persistent".into(),
|
||||
json!(persistent && !turn.config.ephemeral),
|
||||
);
|
||||
if let Some(domains) = config
|
||||
.and_then(|c| c.filters.as_ref()?.allowed_domains.as_ref())
|
||||
.filter(|d| !d.is_empty())
|
||||
{
|
||||
// Distinct domain policies can contain wildcards. Don't guess at their intersection.
|
||||
if context
|
||||
.get("allowed_domains")
|
||||
.is_some_and(|value| *value != json!(domains))
|
||||
{
|
||||
return None;
|
||||
}
|
||||
context.insert("allowed_domains".into(), json!(domains));
|
||||
}
|
||||
Some(context)
|
||||
}
|
||||
|
||||
pub(crate) async fn resolve(
|
||||
turn: &TurnContext,
|
||||
settings: &ResolvedStepSettings,
|
||||
base: &Arc<McpBinding>,
|
||||
services: &SessionServices,
|
||||
) -> Option<ModelSearch> {
|
||||
let native_required = turn.config.requires_native_search();
|
||||
let provider = if native_required {
|
||||
WebSearchProvider::Standalone
|
||||
} else if let Some(provider) = settings.model_info.web_search_provider {
|
||||
provider
|
||||
} else {
|
||||
match turn.config.client_search_provider()? {
|
||||
WebSearchProvider::SearchMcp => return Some(ModelSearch::ClientMcp),
|
||||
WebSearchProvider::Standalone => WebSearchProvider::Standalone,
|
||||
}
|
||||
};
|
||||
let observe = |decision, reason| {
|
||||
turn.session_telemetry.counter(
|
||||
"codex.model_search.discovery",
|
||||
/*inc*/ 1,
|
||||
&[("reason", reason)],
|
||||
);
|
||||
Some(decision)
|
||||
};
|
||||
let mut turn_meta = turn
|
||||
.turn_metadata_state
|
||||
.current_meta_value_for_mcp_request(ExecutionMetadata::from_settings(settings))
|
||||
.unwrap_or_else(|| json!({}));
|
||||
let Some(mut request) = object(turn_meta.get("mcp_request_meta")) else {
|
||||
return observe(ModelSearch::Disabled, "invalid_request_metadata");
|
||||
};
|
||||
let native_mode = native_search_mode(turn, &request);
|
||||
if native_required {
|
||||
return match native_mode {
|
||||
Some(mode) => observe(
|
||||
ModelSearch::Native {
|
||||
mode,
|
||||
fallback: false,
|
||||
},
|
||||
"native_required",
|
||||
),
|
||||
None => observe(ModelSearch::Disabled, "fallback_restricted"),
|
||||
};
|
||||
}
|
||||
if provider == WebSearchProvider::Standalone {
|
||||
return Some(
|
||||
native_mode.map_or(ModelSearch::Disabled, |mode| ModelSearch::Native {
|
||||
mode,
|
||||
fallback: false,
|
||||
}),
|
||||
);
|
||||
}
|
||||
if !crate::mcp_tool_exposure::filter_codex_apps_mcp_tools(base.tools(), &turn.config)
|
||||
.any(codex_mcp::is_model_search_tool)
|
||||
{
|
||||
return observe(ModelSearch::Disabled, "connector_unavailable");
|
||||
}
|
||||
let usage = turn.extension_data.get_or_init(SearchTurnUsage::default);
|
||||
let Some(mut context) = search_context(turn, &request) else {
|
||||
return observe(ModelSearch::Disabled, "search_policy");
|
||||
};
|
||||
context.insert(
|
||||
"model_supported_tools".into(),
|
||||
json!(settings.model_info.experimental_supported_tools),
|
||||
);
|
||||
// Scoped discovery may narrow an unrestricted catalog. Keep existing allowlists,
|
||||
// denylists, plugin selection, and all other host metadata intact.
|
||||
if unrestricted_connectors(&request) {
|
||||
request.insert(
|
||||
"selected_connector_ids".into(),
|
||||
json!([codex_mcp::SEARCH_CONNECTOR]),
|
||||
);
|
||||
}
|
||||
request.insert("openai/search_context".into(), json!(&context));
|
||||
turn_meta["mcp_request_meta"] = json!(&request);
|
||||
// Only discovery is stable within the turn. A yielded search can finish on a later step.
|
||||
let cached = turn
|
||||
.extension_data
|
||||
.get::<CachedSearch>()
|
||||
.filter(|cached| Arc::ptr_eq(&cached.base, base) && cached.request == request);
|
||||
let fresh = cached.is_none();
|
||||
let cached = match cached {
|
||||
Some(cached) => cached,
|
||||
None => {
|
||||
let cached = Arc::new(CachedSearch {
|
||||
base: Arc::clone(base),
|
||||
request,
|
||||
discovery: base.discover_model_search(turn_meta).await,
|
||||
});
|
||||
turn.extension_data.insert_arc(Arc::clone(&cached));
|
||||
cached
|
||||
}
|
||||
};
|
||||
let finish = |decision, reason| {
|
||||
if fresh {
|
||||
observe(decision, reason)
|
||||
} else {
|
||||
Some(decision)
|
||||
}
|
||||
};
|
||||
let owner = SearchOwner::current(&services.thread_extension_data);
|
||||
let reason = match &cached.discovery {
|
||||
SearchDiscovery::Ready(binding) => {
|
||||
if owner != Some(WebSearchProvider::Standalone) {
|
||||
return finish(
|
||||
ModelSearch::Hosted {
|
||||
binding: Arc::clone(binding),
|
||||
context,
|
||||
},
|
||||
"hosted",
|
||||
);
|
||||
}
|
||||
"native_browsing_state"
|
||||
}
|
||||
SearchDiscovery::Critical(reason) => *reason,
|
||||
SearchDiscovery::Unavailable => return finish(ModelSearch::Disabled, "unavailable"),
|
||||
};
|
||||
if let Some(mode) = native_mode
|
||||
&& owner != Some(WebSearchProvider::SearchMcp)
|
||||
&& usage.0.load(Ordering::Relaxed) & SearchTurnUsage::MCP == 0
|
||||
{
|
||||
finish(
|
||||
ModelSearch::Native {
|
||||
mode,
|
||||
fallback: true,
|
||||
},
|
||||
reason,
|
||||
)
|
||||
} else {
|
||||
finish(ModelSearch::Disabled, "fallback_restricted")
|
||||
}
|
||||
}
|
||||
|
||||
/// Preserve all other per-call metadata while replacing the policy with the one used for discovery.
|
||||
pub(crate) fn with_search_context(
|
||||
request: &mut Value,
|
||||
context: &Map<String, Value>,
|
||||
) -> anyhow::Result<()> {
|
||||
let envelope = request
|
||||
.as_object_mut()
|
||||
.ok_or_else(|| anyhow::anyhow!("invalid search turn metadata"))?;
|
||||
let mut meta = object(envelope.get("mcp_request_meta"))
|
||||
.ok_or_else(|| anyhow::anyhow!("invalid MCP request metadata"))?;
|
||||
meta.insert("openai/search_context".into(), json!(context));
|
||||
envelope.insert("mcp_request_meta".into(), Value::Object(meta));
|
||||
Ok(())
|
||||
}
|
||||
@@ -36,7 +36,6 @@ 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);
|
||||
|
||||
let recorded = session.clone_history().await.into_annotated_items();
|
||||
assert_eq!(recorded, vec![expected.clone()]);
|
||||
|
||||
@@ -3103,24 +3103,6 @@ impl Session {
|
||||
}
|
||||
|
||||
pub(crate) async fn emit_turn_item_started(&self, turn_context: &TurnContext, item: &TurnItem) {
|
||||
if matches!(
|
||||
item,
|
||||
TurnItem::WebSearch(_)
|
||||
| TurnItem::Extension(codex_extension_items::ExtensionItem::WebSearch(_))
|
||||
) && let Some(usage) = turn_context
|
||||
.extension_data
|
||||
.get::<crate::model_search::SearchTurnUsage>()
|
||||
{
|
||||
// This turn selected Search MCP. Pin native only when a fallback call starts.
|
||||
crate::model_search::SearchOwner::admit(
|
||||
&self.services.thread_extension_data,
|
||||
codex_protocol::openai_models::WebSearchProvider::Standalone,
|
||||
);
|
||||
usage.record(
|
||||
turn_context,
|
||||
codex_protocol::openai_models::WebSearchProvider::Standalone,
|
||||
);
|
||||
}
|
||||
let started_at_ms = turn_context
|
||||
.turn_timing_state
|
||||
.record_item_started(item.id(), now_unix_timestamp_ms())
|
||||
@@ -4141,10 +4123,6 @@ impl Session {
|
||||
// Preserve any existing tool-specific override.
|
||||
let policy: codex_utils_output_truncation::TruncationPolicy =
|
||||
model_info.truncation_policy.into();
|
||||
crate::model_search::SearchOwner::checkpoint(
|
||||
&self.services.thread_extension_data,
|
||||
&mut items,
|
||||
);
|
||||
for envelope in &mut items {
|
||||
if matches!(
|
||||
envelope.item,
|
||||
@@ -4543,6 +4521,8 @@ impl Session {
|
||||
session_telemetry.clone(),
|
||||
));
|
||||
extension_data.insert_arc(Arc::clone(&settings.model_info.model));
|
||||
// Standalone and hosted search must use the same turn-scoped permission mode.
|
||||
extension_data.insert(turn_context.config.web_search_mode.value());
|
||||
extension_data.insert_arc(
|
||||
self.host_skills_for_step(&turn_context, &environments)
|
||||
.await,
|
||||
@@ -4594,20 +4574,6 @@ impl Session {
|
||||
if let Some(messages) = model_messages.notes() {
|
||||
extension_data.insert(messages.clone());
|
||||
}
|
||||
let mut required_servers = required_servers.to_vec();
|
||||
if settings.model_info.web_search_provider
|
||||
== Some(codex_protocol::openai_models::WebSearchProvider::SearchMcp)
|
||||
&& turn_context.apps_enabled()
|
||||
&& !turn_context.config.requires_native_search()
|
||||
&& (turn_context.config.web_search_mode.value()
|
||||
!= codex_protocol::config_types::WebSearchMode::Disabled
|
||||
|| turn_context
|
||||
.config
|
||||
.features
|
||||
.enabled(codex_features::Feature::HostedSearchPolicy))
|
||||
{
|
||||
required_servers.push(codex_mcp::CODEX_APPS_MCP_SERVER_NAME.to_owned());
|
||||
}
|
||||
let captured_executor_discovery_v2 = executor_capability_discovery_v2.as_deref();
|
||||
let catalogs = self.lock_cloud_catalogs().await;
|
||||
let (mcp, prepared_recommendations) = tokio::join!(
|
||||
@@ -4616,7 +4582,7 @@ impl Session {
|
||||
turn_context.as_ref(),
|
||||
&selected_capability_roots,
|
||||
captured_executor_discovery_v2,
|
||||
&required_servers,
|
||||
required_servers,
|
||||
required_plugins,
|
||||
)),
|
||||
async {
|
||||
@@ -4632,27 +4598,6 @@ impl Session {
|
||||
let mut plugin_config = turn_context.config.as_ref().clone();
|
||||
plugin_config.plugins = mcp.config().plugins.clone();
|
||||
plugin_config.config_layer_stack = mcp.config().config_layer_stack.clone();
|
||||
let search = crate::model_search::resolve(
|
||||
turn_context.as_ref(),
|
||||
&settings,
|
||||
&mcp,
|
||||
&self.services,
|
||||
)
|
||||
.await;
|
||||
extension_data.insert(match &search {
|
||||
Some(crate::model_search::ModelSearch::Native { mode, .. }) => *mode,
|
||||
_ => turn_context.config.web_search_mode.value(),
|
||||
});
|
||||
let mcp = if let Some(search) = search {
|
||||
let binding = match &search {
|
||||
crate::model_search::ModelSearch::Hosted { binding, .. } => Arc::clone(binding),
|
||||
_ => mcp,
|
||||
};
|
||||
extension_data.insert(search);
|
||||
binding
|
||||
} else {
|
||||
mcp
|
||||
};
|
||||
extension_data.insert(selected_capability_roots);
|
||||
let selected_environments = environments.all_selections();
|
||||
let select_plugins = |discovery, discovery_v2| {
|
||||
@@ -4990,10 +4935,6 @@ impl Session {
|
||||
}
|
||||
CompactedHistoryInstallation::Prefix(prefix) => (&prefix.model_info.comp_hash, None),
|
||||
};
|
||||
crate::model_search::SearchOwner::checkpoint(
|
||||
&self.services.thread_extension_data,
|
||||
&mut items,
|
||||
);
|
||||
if let Some(checkpoint) = items.iter_mut().rev().find(|envelope| {
|
||||
matches!(
|
||||
envelope.item,
|
||||
|
||||
@@ -1099,7 +1099,6 @@ impl Session {
|
||||
thread_extension_data.insert(crate::agent::helper_daybreak::Enrollment::Root);
|
||||
}
|
||||
thread_extension_data.insert(crate::context::GuardianReviewEvidence::default());
|
||||
crate::model_search::SearchOwner::restore(&thread_extension_data, &initial_history);
|
||||
// Kick off independent async setup tasks in parallel to reduce startup latency.
|
||||
//
|
||||
// - initialize thread persistence with new or resumed session info
|
||||
|
||||
@@ -2810,7 +2810,6 @@ 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 {
|
||||
|
||||
@@ -2186,11 +2186,6 @@ async fn run_sampling_request(
|
||||
if first_attempt && turn_context.config.notify.is_some() {
|
||||
notify_messages = legacy_notify_input_messages(&prompt.input);
|
||||
}
|
||||
let _native_search = crate::model_search::SearchOwner::reserve_server_fallback(
|
||||
&step_context.extension_data,
|
||||
&sess.services.thread_extension_data,
|
||||
&mut prompt.tools,
|
||||
);
|
||||
let (submitted_audio, pending_audio) = {
|
||||
let model = &step_context.settings.model_info.slug;
|
||||
let provider = &turn_context.config.model_provider_id;
|
||||
|
||||
@@ -66,17 +66,6 @@ impl ToolExecutor<ToolInvocation> for ExtensionToolAdapter {
|
||||
{
|
||||
Box::pin(async move {
|
||||
let step = &invocation.step_context;
|
||||
let _native_search = if invocation.tool_name.namespace.as_deref() == Some("web")
|
||||
&& invocation.tool_name.name == "run"
|
||||
{
|
||||
crate::model_search::SearchOwner::reserve_native_fallback(
|
||||
&step.extension_data,
|
||||
&invocation.session.services.thread_extension_data,
|
||||
)
|
||||
.map_err(|err| codex_tools::FunctionCallError::RespondToModel(err.to_string()))?
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let selected: Vec<_> = match &invocation.environments {
|
||||
ToolEnvironments::Arguments(environments) => {
|
||||
environments.iter().map(|(_, env)| env.as_ref()).collect()
|
||||
|
||||
@@ -159,7 +159,6 @@ pub(crate) fn build_tool_router(
|
||||
session.services.mcp_manager.shared_definitions(),
|
||||
&mut registry,
|
||||
);
|
||||
let search = step_store.get::<crate::model_search::ModelSearch>();
|
||||
apply_mcp_tool_exposure_policy(
|
||||
turn_context,
|
||||
model_info,
|
||||
@@ -173,40 +172,12 @@ pub(crate) fn build_tool_router(
|
||||
extension_tool_executors(session, step_store),
|
||||
&mut registry,
|
||||
);
|
||||
let native_mode = match search.as_deref() {
|
||||
None => Some(turn_context.config.web_search_mode.value()),
|
||||
Some(crate::model_search::ModelSearch::Native { mode, .. }) => Some(*mode),
|
||||
_ => None,
|
||||
};
|
||||
if matches!(
|
||||
search.as_deref(),
|
||||
Some(
|
||||
crate::model_search::ModelSearch::Native { .. }
|
||||
| crate::model_search::ModelSearch::Disabled
|
||||
)
|
||||
) {
|
||||
for tool in mcp
|
||||
.tools()
|
||||
.iter()
|
||||
.filter(|tool| codex_mcp::is_model_search_tool(tool))
|
||||
{
|
||||
registry.remove(&tool.canonical_tool_name());
|
||||
}
|
||||
}
|
||||
if native_mode.is_none() {
|
||||
registry.remove(&ToolName::namespaced("web", "run"));
|
||||
}
|
||||
append_dynamic_tool_runtimes(dynamic_tools, &mut registry);
|
||||
let hosted_specs = if let Some(mode) = native_mode {
|
||||
hosted_model_tool_specs(
|
||||
turn_context,
|
||||
model_info,
|
||||
mode,
|
||||
standalone_web_search_tool.as_slice(),
|
||||
)
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
let hosted_specs = hosted_model_tool_specs(
|
||||
turn_context,
|
||||
model_info,
|
||||
standalone_web_search_tool.as_slice(),
|
||||
);
|
||||
|
||||
finalize_tool_router(
|
||||
turn_context,
|
||||
@@ -373,7 +344,6 @@ pub(crate) fn append_source_tools(
|
||||
hosted_model_tool_specs(
|
||||
turn_context,
|
||||
model_info,
|
||||
turn_context.config.web_search_mode.value(),
|
||||
standalone_web_search_tool.as_slice(),
|
||||
)
|
||||
}
|
||||
@@ -723,7 +693,6 @@ fn spec_for_model_request(
|
||||
fn hosted_model_tool_specs(
|
||||
turn_context: &TurnContext,
|
||||
model_info: &ModelInfo,
|
||||
mode: WebSearchMode,
|
||||
registered_extension_tool_names: &[ToolName],
|
||||
) -> Vec<ToolSpec> {
|
||||
// Responses Lite accepts schemas for client-executed tools, not hosted Responses tools.
|
||||
@@ -738,7 +707,7 @@ fn hosted_model_tool_specs(
|
||||
// and the provider supports hosted search. `None` prevents emitting a hosted search tool.
|
||||
let web_search_mode = (!standalone_web_search_available
|
||||
&& turn_context.provider.capabilities().web_search)
|
||||
.then_some(mode);
|
||||
.then_some(turn_context.config.web_search_mode.value());
|
||||
let web_search_config = web_search_mode
|
||||
.as_ref()
|
||||
.and(turn_context.config.web_search_config.as_ref());
|
||||
|
||||
@@ -1150,12 +1150,7 @@ async fn environment_tools_follow_the_step_context() {
|
||||
/*tool_suggest_candidates*/ None,
|
||||
/*wait_for_environment_tool_config*/ None,
|
||||
),
|
||||
super::hosted_model_tool_specs(
|
||||
turn.as_ref(),
|
||||
turn.model_info(),
|
||||
turn.config.web_search_mode.value(),
|
||||
&[],
|
||||
),
|
||||
super::hosted_model_tool_specs(turn.as_ref(), turn.model_info(), &[]),
|
||||
&Default::default(),
|
||||
));
|
||||
|
||||
@@ -2289,7 +2284,6 @@ async fn tool_search_cache_rebuilds_when_deferred_sources_change() {
|
||||
super::hosted_model_tool_specs(
|
||||
first_step_context.turn.as_ref(),
|
||||
first_step_context.turn.model_info(),
|
||||
first_step_context.turn.config.web_search_mode.value(),
|
||||
&[],
|
||||
),
|
||||
&cache,
|
||||
@@ -2324,7 +2318,6 @@ async fn tool_search_cache_rebuilds_when_deferred_sources_change() {
|
||||
super::hosted_model_tool_specs(
|
||||
second_step_context.turn.as_ref(),
|
||||
second_step_context.turn.model_info(),
|
||||
second_step_context.turn.config.web_search_mode.value(),
|
||||
&[],
|
||||
),
|
||||
&cache,
|
||||
@@ -2390,7 +2383,6 @@ async fn tool_search_cache_rebuilds_when_deferred_world_state_changes() {
|
||||
super::hosted_model_tool_specs(
|
||||
step_context.turn.as_ref(),
|
||||
step_context.turn.model_info(),
|
||||
step_context.turn.config.web_search_mode.value(),
|
||||
&[],
|
||||
),
|
||||
&cache,
|
||||
|
||||
@@ -674,7 +674,6 @@ fn remote_model_with_auto_review_override(slug: &str, review_model: &str) -> Mod
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: Some(ApplyPatchToolType::Freeform),
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -153,7 +153,6 @@ fn test_model_info(
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
@@ -1301,7 +1300,6 @@ async fn model_switch_to_smaller_model_updates_token_context_window() -> Result<
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(large_context_window),
|
||||
|
||||
@@ -726,7 +726,6 @@ fn test_remote_model(slug: &str, priority: i32) -> ModelInfo {
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -855,7 +855,6 @@ async fn remote_models_remote_model_uses_unified_exec() -> Result<()> {
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
@@ -1134,7 +1133,6 @@ async fn remote_models_apply_legacy_instructions(auth: CodexAuth) -> Result<()>
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
@@ -1721,7 +1719,6 @@ fn test_remote_model_with_policy(
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy,
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -3656,7 +3656,6 @@ async fn stdio_image_responses_are_sanitized_for_text_only_model() -> anyhow::Re
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -1,20 +1,8 @@
|
||||
//! Model-visible context for standalone web search.
|
||||
|
||||
use super::*;
|
||||
use anyhow::Context;
|
||||
use codex_history::RolloutItem;
|
||||
use codex_protocol::config_types::WebSearchMode;
|
||||
use codex_protocol::openai_models::WebSearchProvider;
|
||||
use core_test_support::apps_test_server::AppsTestServer;
|
||||
use core_test_support::apps_test_server::apps_enabled_builder;
|
||||
use core_test_support::responses::ev_function_call;
|
||||
use core_test_support::responses::ev_tool_search_call;
|
||||
use core_test_support::test_codex::TestCodexBuilder;
|
||||
use pretty_assertions::assert_eq;
|
||||
use serde_json::Value;
|
||||
use std::sync::Mutex;
|
||||
use std::sync::atomic::AtomicBool;
|
||||
use std::sync::atomic::Ordering;
|
||||
use wiremock::Mock;
|
||||
use wiremock::ResponseTemplate;
|
||||
use wiremock::matchers::body_partial_json;
|
||||
@@ -110,613 +98,3 @@ async fn literature_search_and_open() -> Result<()> {
|
||||
));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn literature_search_pin() -> Value {
|
||||
json!({"config":{"tool_type":"SonicBrowserToolV99","allow_literature_search":true}})
|
||||
}
|
||||
|
||||
async fn mount_model_search(
|
||||
server: &wiremock::MockServer,
|
||||
available: &Arc<AtomicBool>,
|
||||
) -> Result<AppsTestServer> {
|
||||
let mut tool = json!({
|
||||
"name": "search_service.web_run", "description": "Find papers on the web.",
|
||||
"annotations": {"readOnlyHint": true},
|
||||
"inputSchema": {"type":"object","properties":{"system2_search_query":{"type":"array"},"open":{"type":"array"}}},
|
||||
"_meta": {"connector_id": codex_mcp::SEARCH_CONNECTOR,"connector_name":"search_service"}
|
||||
});
|
||||
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"}}))
|
||||
.collect();
|
||||
catalog.push(tool);
|
||||
let available = Arc::clone(available);
|
||||
Mock::given(method("POST"))
|
||||
.and(body_partial_json(json!({
|
||||
"method":"tools/list","params":{"_meta":{"x-codex-turn-metadata":{"mcp_request_meta":{
|
||||
"selected_connector_ids":[codex_mcp::SEARCH_CONNECTOR]
|
||||
}}}}
|
||||
})))
|
||||
.respond_with(move |request: &wiremock::Request| {
|
||||
let body: serde_json::Value = request.body_json().expect("tools/list request JSON");
|
||||
let mut response = json!({"jsonrpc":"2.0","id":body["id"]});
|
||||
if available.load(Ordering::SeqCst) {
|
||||
response["result"] = json!({"tools":catalog});
|
||||
} else {
|
||||
response["error"] = json!({"code":-32603,"message":"discovery unavailable"});
|
||||
}
|
||||
ResponseTemplate::new(200).set_body_json(response)
|
||||
})
|
||||
.with_priority(1)
|
||||
.expect(2..)
|
||||
.mount(server)
|
||||
.await;
|
||||
Ok(apps)
|
||||
}
|
||||
|
||||
fn model_search_builder(apps: &AppsTestServer, tool_mode: ToolMode) -> TestCodexBuilder {
|
||||
let auth = codex_core::test_support::auth_manager_from_auth(
|
||||
CodexAuth::create_dummy_chatgpt_auth_for_testing(),
|
||||
);
|
||||
let mut extensions = ExtensionRegistryBuilder::new();
|
||||
codex_web_search_extension::install(&mut extensions, Arc::clone(&auth));
|
||||
apps_enabled_builder(apps.chatgpt_base_url.clone())
|
||||
.with_auth_manager(auth)
|
||||
.with_extensions(Arc::new(extensions.build()))
|
||||
.with_config(move |config| {
|
||||
configure_scenario_catalog(config);
|
||||
if tool_mode == ToolMode::CodeMode {
|
||||
config
|
||||
.features
|
||||
.enable(Feature::CodeMode)
|
||||
.expect("enable code mode");
|
||||
}
|
||||
config
|
||||
.features
|
||||
.enable(Feature::StandaloneWebSearch)
|
||||
.expect("enable standalone web search");
|
||||
config
|
||||
.web_search_mode
|
||||
.set(WebSearchMode::Live)
|
||||
.expect("set live web search mode");
|
||||
})
|
||||
.with_model_info_override("native-paper", |model| {
|
||||
model.web_search_provider = Some(WebSearchProvider::Standalone);
|
||||
model.tool_mode = Some(ToolMode::Direct);
|
||||
})
|
||||
.with_model_info_override("hosted-paper", move |model| {
|
||||
model.web_search_provider = Some(WebSearchProvider::SearchMcp);
|
||||
model.tool_mode = Some(tool_mode);
|
||||
if tool_mode == ToolMode::CodeMode {
|
||||
model
|
||||
.experimental_supported_tools
|
||||
.push("test_sync_tool".into());
|
||||
}
|
||||
model.supports_search_tool = true;
|
||||
model
|
||||
.experimental_supported_tools
|
||||
.push("literature_search_query".into());
|
||||
})
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn model_selected_search_preserves_discovery_and_call_history() -> Result<()> {
|
||||
use codex_protocol::protocol::ThreadSettingsOverrides;
|
||||
|
||||
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 pin = literature_search_pin();
|
||||
let search = json!({"literature_search_query":[{"q":"FlashAttention-2"}]});
|
||||
let reference_issued = Arc::new(AtomicBool::new(false));
|
||||
let issued = Arc::clone(&reference_issued);
|
||||
Mock::given(method("POST"))
|
||||
.and(body_partial_json(json!({
|
||||
"method":"tools/call","params":{"name":"search_service.web_run","arguments":search,
|
||||
"_meta":{"_codex_apps":{"invocation_context":pin}}}
|
||||
})))
|
||||
.respond_with(move |request: &wiremock::Request| {
|
||||
let body: serde_json::Value = request.body_json().unwrap();
|
||||
issued.store(true, Ordering::SeqCst);
|
||||
ResponseTemplate::new(200).set_body_json(json!({"jsonrpc":"2.0","id":body["id"],
|
||||
"result":{"content":[{"type":"text","text":"[turn0academia0] FlashAttention-2 by Tri Dao."}]}}))
|
||||
})
|
||||
.with_priority(1)
|
||||
.expect(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let open = json!({"open":[{"ref_id":"turn0academia0"}]});
|
||||
Mock::given(method("POST"))
|
||||
.and(body_partial_json(json!({
|
||||
"method":"tools/call","params":{"name":"search_service.web_run","arguments":open,
|
||||
"_meta":{"_codex_apps":{"invocation_context":pin}}}
|
||||
})))
|
||||
.respond_with(move |request: &wiremock::Request| {
|
||||
let body: serde_json::Value = request.body_json().unwrap();
|
||||
let text = if reference_issued.load(Ordering::SeqCst) {
|
||||
"The paper reports a 2x speedup."
|
||||
} else {
|
||||
"Unknown reference."
|
||||
};
|
||||
ResponseTemplate::new(200).set_body_json(json!({"jsonrpc":"2.0","id":body["id"],
|
||||
"result":{"content":[{"type":"text","text":text}]}}))
|
||||
})
|
||||
.with_priority(1)
|
||||
.expect(1)
|
||||
.mount(&server)
|
||||
.await;
|
||||
Mock::given(method("POST"))
|
||||
.and(path("/v1/alpha/search"))
|
||||
.respond_with(ResponseTemplate::new(400))
|
||||
.expect(0)
|
||||
.mount(&server)
|
||||
.await;
|
||||
let responses = mount_sse_sequence(
|
||||
&server,
|
||||
vec![
|
||||
sse(vec![
|
||||
ev_tool_search_call("find-search", &json!({"query":"search_service web_run"})),
|
||||
ev_completed("lookup"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_function_call_with_namespace(
|
||||
"paper-search",
|
||||
"mcp__codex_apps__search_service",
|
||||
"_web_run",
|
||||
&search.to_string(),
|
||||
),
|
||||
ev_completed("search"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("author", "The paper is by Tri Dao."),
|
||||
ev_completed("first"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("unavailable", "Search is temporarily unavailable."),
|
||||
ev_completed("outage"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_tool_search_call("find-open", &json!({"query":"search_service web_run"})),
|
||||
ev_completed("lookup-open"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_function_call_with_namespace(
|
||||
"open",
|
||||
"mcp__codex_apps__search_service",
|
||||
"_web_run",
|
||||
&open.to_string(),
|
||||
),
|
||||
ev_completed("opened"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("speed", "It reports a 2x speedup."),
|
||||
ev_completed("second"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("recap", "Tri Dao reports a 2x speedup."),
|
||||
ev_completed("third"),
|
||||
]),
|
||||
],
|
||||
)
|
||||
.await;
|
||||
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?;
|
||||
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?;
|
||||
discovery_available.store(true, Ordering::SeqCst);
|
||||
test.submit_turn("Try opening the same paper again.")
|
||||
.await?;
|
||||
test.codex
|
||||
.start_or_steer_turn(
|
||||
TurnInputRequest::user_input(vec![text("Summarize the result.")]).with_thread_settings(
|
||||
ThreadSettingsOverrides {
|
||||
model: Some("native-paper".into()),
|
||||
..Default::default()
|
||||
},
|
||||
),
|
||||
)
|
||||
.await?;
|
||||
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
|
||||
let requests = responses.requests();
|
||||
assert_eq!(requests.len(), 8);
|
||||
assert!(
|
||||
requests[0]
|
||||
.tool_by_name("mcp__codex_apps__search_service", "_web_run")
|
||||
.is_none()
|
||||
);
|
||||
assert!(
|
||||
requests[1]
|
||||
.tool_search_output("find-search")
|
||||
.to_string()
|
||||
.contains("literature_search_query")
|
||||
);
|
||||
let output = requests[2].function_call_output("paper-search");
|
||||
assert!(output.to_string().contains("Tri Dao"), "{output}");
|
||||
assert!(requests[3].tool_by_name("web", "run").is_none());
|
||||
let output = requests[6].function_call_output("open");
|
||||
assert!(output.to_string().contains("2x"), "{output}");
|
||||
insta::assert_snapshot!(context_snapshot::format_request_history_snapshot(
|
||||
"MCP returns a paper reference. A discovery outage withholds native search, then MCP opens the same reference after recovery. Switching to a standalone model retains the history.",
|
||||
&requests,
|
||||
&ContextSnapshotOptions::default()
|
||||
.rewrite_known_segments()
|
||||
.include_request_settings(),
|
||||
));
|
||||
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;
|
||||
let mut rollout = Vec::new();
|
||||
for original in std::fs::read_to_string(&rollout_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()
|
||||
{
|
||||
removed_checkpoint |= metadata.model_search_state.take().is_some();
|
||||
}
|
||||
rollout.push(serde_json::to_string(&line)?);
|
||||
}
|
||||
let rollout = rollout.join("\n");
|
||||
std::fs::write(&rollout_path, format!("{rollout}\n"))?;
|
||||
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(()));
|
||||
let server = start_mock_server().await;
|
||||
let available = Arc::new(AtomicBool::new(false));
|
||||
let apps = mount_model_search(&server, &available).await?;
|
||||
let mut test = model_search_builder(&apps, ToolMode::Direct)
|
||||
.build_with_auto_env(&server)
|
||||
.await?;
|
||||
// Merely offering fallback during an outage must not pin a healthy thread to native.
|
||||
let idle = mount_sse_sequence(
|
||||
&server,
|
||||
vec![
|
||||
sse(vec![
|
||||
ev_assistant_message("hello", "Hello."),
|
||||
ev_completed("hello"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_tool_search_call("lookup", &json!({"query":"search_service web_run"})),
|
||||
ev_completed("lookup"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("ready", "Search is ready."),
|
||||
ev_completed("ready"),
|
||||
]),
|
||||
],
|
||||
)
|
||||
.await;
|
||||
test.submit_turn("Say hello.").await?;
|
||||
available.store(true, Ordering::SeqCst);
|
||||
test.submit_turn("Look up the search tool.").await?;
|
||||
let requests = idle.requests();
|
||||
assert!(requests[0].tool_by_name("web", "run").is_some());
|
||||
assert!(
|
||||
requests[2]
|
||||
.tool_search_output("lookup")
|
||||
.to_string()
|
||||
.contains("literature_search_query")
|
||||
);
|
||||
|
||||
let search = json!({"search_query":[{"q":"FlashAttention-2"}]});
|
||||
let open = json!({"open":[{"ref_id":"turn0search0"}]});
|
||||
|
||||
let mut browser_session = None;
|
||||
for (id, commands, output) in [
|
||||
("search", search, "[turn0search0] FlashAttention-2"),
|
||||
("open", open.clone(), "Tri Dao reports a 2x speedup."),
|
||||
("reopen", open, "Tri Dao reports a 2x speedup."),
|
||||
] {
|
||||
let first_turn = id == "search";
|
||||
available.store(!first_turn, Ordering::SeqCst);
|
||||
if id == "reopen" {
|
||||
test = model_search_builder(&apps, ToolMode::Direct)
|
||||
.restart_with_auto_env(&server, &test)
|
||||
.await?;
|
||||
}
|
||||
let native = Mock::given(method("POST"))
|
||||
.and(path("/v1/alpha/search"))
|
||||
.respond_with(ResponseTemplate::new(200).set_body_json(json!({"output":output})))
|
||||
.expect(1)
|
||||
.mount_as_scoped(&server)
|
||||
.await;
|
||||
let responses = mount_sse_sequence(
|
||||
&server,
|
||||
vec![
|
||||
sse(vec![
|
||||
ev_function_call_with_namespace(id, "web", "run", &commands.to_string()),
|
||||
ev_completed("tool"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("answer", output),
|
||||
ev_completed("answer"),
|
||||
]),
|
||||
],
|
||||
)
|
||||
.await;
|
||||
test.submit_turn(if first_turn {
|
||||
"Find the paper."
|
||||
} else {
|
||||
"Open the paper you found."
|
||||
})
|
||||
.await?;
|
||||
let requests = responses.requests();
|
||||
assert!(requests[0].tool_by_name("web", "run").is_some());
|
||||
let result = requests[1].function_call_output(id);
|
||||
assert!(result.to_string().contains(output), "{result}");
|
||||
let body: Value = native.received_requests().await[0].body_json()?;
|
||||
assert_eq!(body["commands"], commands);
|
||||
let session_id = body["id"].as_str().context("native search session ID")?;
|
||||
assert_eq!(
|
||||
browser_session
|
||||
.get_or_insert_with(|| session_id.to_owned())
|
||||
.as_str(),
|
||||
session_id
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
core_test_support::apps_test_server::recorded_apps_tool_calls(&server)
|
||||
.await
|
||||
.is_empty()
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test_case::test_case(false; "unused_offer_releases_provider")]
|
||||
#[test_case::test_case(true; "executed_call_keeps_provider")]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn responses_native_fallback(used: bool) -> Result<()> {
|
||||
skip_if_no_network!(Ok(()));
|
||||
let server = start_mock_server().await;
|
||||
let available = Arc::new(AtomicBool::new(false));
|
||||
let apps = mount_model_search(&server, &available).await?;
|
||||
let test = model_search_builder(&apps, ToolMode::Direct)
|
||||
.with_config(|config| {
|
||||
config
|
||||
.features
|
||||
.disable(Feature::StandaloneWebSearch)
|
||||
.expect("disable standalone web search");
|
||||
})
|
||||
.with_model_info_override("hosted-paper", |model| model.use_responses_lite = false)
|
||||
.build_with_auto_env(&server)
|
||||
.await?;
|
||||
let mut events = Vec::new();
|
||||
if used {
|
||||
events.push(
|
||||
core_test_support::responses::ev_web_search_call_added_partial("native", "in_progress"),
|
||||
);
|
||||
events.push(core_test_support::responses::ev_web_search_call_done(
|
||||
"native",
|
||||
"completed",
|
||||
"FlashAttention-2",
|
||||
));
|
||||
}
|
||||
events.extend([
|
||||
ev_assistant_message("first", "Ready."),
|
||||
ev_completed("first"),
|
||||
]);
|
||||
let responses = mount_sse_sequence(
|
||||
&server,
|
||||
vec![
|
||||
sse(events),
|
||||
sse(vec![
|
||||
ev_assistant_message("second", "Ready."),
|
||||
ev_completed("second"),
|
||||
]),
|
||||
],
|
||||
)
|
||||
.await;
|
||||
test.submit_turn("Look for the paper.").await?;
|
||||
available.store(true, Ordering::SeqCst);
|
||||
test.submit_turn("Continue.").await?;
|
||||
let native_offers: Vec<_> = responses
|
||||
.requests()
|
||||
.iter()
|
||||
.map(|request| {
|
||||
request.body_json()["tools"]
|
||||
.as_array()
|
||||
.expect("request tools array")
|
||||
.iter()
|
||||
.any(|tool| tool["type"] == "web_search")
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(native_offers, vec![true, used]);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test_case::test_case(false; "mcp_finishes_before_native_is_used")]
|
||||
#[test_case::test_case(true; "native_runs_before_retained_mcp_call")]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn background_search_and_native_fallback(native_first: bool) -> Result<()> {
|
||||
skip_if_no_network!(Ok(()));
|
||||
let server = start_mock_server().await;
|
||||
let available = Arc::new(AtomicBool::new(true));
|
||||
let apps = mount_model_search(&server, &available).await?;
|
||||
let test = model_search_builder(&apps, ToolMode::CodeMode)
|
||||
.build_with_auto_env(&server)
|
||||
.await?;
|
||||
Mock::given(method("POST"))
|
||||
.and(body_partial_json(json!({"method":"tools/call","params":{"name":"search_service.web_run","_meta":{"_codex_apps":{"invocation_context":literature_search_pin()}}}})))
|
||||
.respond_with(|request: &wiremock::Request| {
|
||||
let body: Value = request.body_json().expect("tools/call request JSON");
|
||||
ResponseTemplate::new(200).set_body_json(json!({
|
||||
"jsonrpc":"2.0", "id":body["id"], "result":{"content":[{"type":"text","text":"[turn0academia0] FlashAttention-2"}]}
|
||||
}))
|
||||
})
|
||||
.with_priority(1).expect(u64::from(!native_first)).mount(&server).await;
|
||||
|
||||
// The barrier holds the original step's MCP call until the next turn has offered native.
|
||||
let barrier = json!({"barrier":{"id":"background-search","participants":2,"timeout_ms":60000}});
|
||||
let pending = format!(
|
||||
r#"yield_control();
|
||||
await tools.test_sync_tool({barrier});
|
||||
text((await tools.mcp__codex_apps__search_service_web_run({{literature_search_query:[{{q:"FlashAttention-2"}}]}})).content);"#
|
||||
);
|
||||
let first = mount_sse_sequence(
|
||||
&server,
|
||||
vec![
|
||||
sse(vec![
|
||||
ev_custom_tool_call("pending", "exec", &pending),
|
||||
ev_completed("yielded"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("message", "Searching."),
|
||||
ev_completed("first"),
|
||||
]),
|
||||
],
|
||||
)
|
||||
.await;
|
||||
test.submit_turn("Start a background paper search.").await?;
|
||||
let yielded = first.requests()[1].custom_tool_call_output("pending");
|
||||
let running = yielded["output"]
|
||||
.as_str()
|
||||
.or_else(|| yielded.pointer("/output/0/text")?.as_str())
|
||||
.expect("yielded exec output");
|
||||
let cell_id = running
|
||||
.lines()
|
||||
.next()
|
||||
.expect("yielded exec output line")
|
||||
.strip_prefix("Script running with cell ID ")
|
||||
.expect("yielded exec cell");
|
||||
available.store(false, Ordering::SeqCst);
|
||||
let native_commands = json!({"search_query":[{"q":"FlashAttention-2"}]});
|
||||
Mock::given(method("POST"))
|
||||
.and(path("/v1/alpha/search"))
|
||||
.and(body_partial_json(json!({"commands":native_commands})))
|
||||
.respond_with(
|
||||
ResponseTemplate::new(200)
|
||||
.set_body_json(json!({"output":"[turn0search0] native paper"})),
|
||||
)
|
||||
.expect(u64::from(native_first))
|
||||
.mount(&server)
|
||||
.await;
|
||||
let mut steps = Vec::new();
|
||||
if native_first {
|
||||
steps.push(sse(vec![
|
||||
ev_function_call_with_namespace("native", "web", "run", &native_commands.to_string()),
|
||||
ev_completed("native"),
|
||||
]));
|
||||
}
|
||||
steps.extend([
|
||||
sse(vec![
|
||||
ev_function_call("release", "test_sync_tool", &barrier.to_string()),
|
||||
ev_completed("released"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_function_call_with_namespace(
|
||||
"wait-search",
|
||||
"functions",
|
||||
"wait",
|
||||
&json!({"cell_id":cell_id,"yield_time_ms":10000}).to_string(),
|
||||
),
|
||||
ev_completed("waited"),
|
||||
]),
|
||||
sse(vec![
|
||||
ev_assistant_message("answer", "The background result is available."),
|
||||
ev_completed("done"),
|
||||
]),
|
||||
]);
|
||||
let second = mount_sse_sequence(&server, steps).await;
|
||||
test.submit_turn("Wait for the paper.").await?;
|
||||
let requests = second.requests();
|
||||
assert!(
|
||||
requests[0].tool_by_name("web", "run").is_some(),
|
||||
"outage initially allows native"
|
||||
);
|
||||
let last = requests.last().expect("final response request");
|
||||
let result = last.function_call_output("wait-search").to_string();
|
||||
if native_first {
|
||||
assert!(
|
||||
requests[1]
|
||||
.function_call_output("native")
|
||||
.to_string()
|
||||
.contains("turn0search0")
|
||||
);
|
||||
assert!(result.contains("native search"), "{result}");
|
||||
assert!(
|
||||
last.tool_by_name("web", "run").is_some(),
|
||||
"the skipped MCP call must not change ownership"
|
||||
);
|
||||
available.store(true, Ordering::SeqCst);
|
||||
let recovered = mount_sse_sequence(
|
||||
&server,
|
||||
vec![sse(vec![
|
||||
ev_assistant_message("answer", "Ready."),
|
||||
ev_completed("recovered"),
|
||||
])],
|
||||
)
|
||||
.await;
|
||||
test.submit_turn("Continue using the same paper.").await?;
|
||||
assert!(
|
||||
recovered
|
||||
.single_request()
|
||||
.tool_by_name("web", "run")
|
||||
.is_some()
|
||||
);
|
||||
} else {
|
||||
assert!(result.contains("turn0academia0"), "{result}");
|
||||
assert!(
|
||||
last.tool_by_name("web", "run").is_none(),
|
||||
"MCP owns the reference"
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
-167
@@ -1,167 +0,0 @@
|
||||
---
|
||||
source: core/tests/suite/scenarios_web_search.rs
|
||||
expression: "context_snapshot::format_request_history_snapshot(\"MCP returns a paper reference. A discovery outage withholds native search, then MCP opens the same reference after recovery. Switching to a standalone model retains the history.\",\n&requests,\n&ContextSnapshotOptions::default().rewrite_known_segments().include_request_settings(),)"
|
||||
---
|
||||
Scenario: MCP returns a paper reference. A discovery outage withholds native search, then MCP opens the same reference after recovery. Switching to a standalone model retains the history.
|
||||
|
||||
## Window 1
|
||||
Settings:
|
||||
include: ["reasoning.encrypted_content"]
|
||||
model: "hosted-paper"
|
||||
parallel_tool_calls: true
|
||||
prompt_cache_key: "<PROMPT_CACHE_KEY 1>"
|
||||
reasoning: {"effort":"medium"}
|
||||
store: false
|
||||
stream: true
|
||||
text: {"verbosity":"low"}
|
||||
tool_choice: "auto"
|
||||
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
|
||||
- function/list_mcp_resource_templates: Lists resource templates provided by MCP servers. Parameterized resource templates allow servers ...; args=[cursor, server]; hash=60f17c90ef7a4ebb
|
||||
- function/read_mcp_resource: Read a specific resource from an MCP server given the server name and resource URI.; args=[server, uri]; hash=24246896b39008ae
|
||||
- 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:
|
||||
<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.
|
||||
-- request 2 (turn) --
|
||||
04:tool_search_call
|
||||
05:tool_search_output
|
||||
-- request 3 (turn) --
|
||||
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/user:
|
||||
<ENVIRONMENT_CONTEXT>
|
||||
10:message/developer:
|
||||
<tools>
|
||||
Removed deferred tool namespaces:
|
||||
- mcp__codex_apps__search_service: Tools for working with search_service.
|
||||
</tools>
|
||||
11:message/user:
|
||||
Open the paper and check its speedup.
|
||||
-- request 5 (turn) --
|
||||
12:message/assistant:
|
||||
Search is temporarily unavailable.
|
||||
13:message/developer:
|
||||
<tools>
|
||||
Added deferred tool namespaces:
|
||||
- mcp__codex_apps__search_service: Tools for working with search_service.
|
||||
</tools>
|
||||
14:message/user:
|
||||
Try opening the same paper again.
|
||||
-- request 6 (turn) --
|
||||
15:tool_search_call
|
||||
16:tool_search_output
|
||||
-- request 7 (turn) --
|
||||
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 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
|
||||
- function/run
|
||||
-- request 8 (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/user:
|
||||
<ENVIRONMENT_CONTEXT>
|
||||
10:message/developer:
|
||||
<tools>
|
||||
Removed deferred tool namespaces:
|
||||
- mcp__codex_apps__search_service: Tools for working with search_service.
|
||||
</tools>
|
||||
11:message/user:
|
||||
Open the paper and check its speedup.
|
||||
12:message/assistant:
|
||||
Search is temporarily unavailable.
|
||||
13:message/developer:
|
||||
<tools>
|
||||
Added deferred tool namespaces:
|
||||
- mcp__codex_apps__search_service: Tools for working with search_service.
|
||||
</tools>
|
||||
14:message/user:
|
||||
Try opening the same paper again.
|
||||
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.
|
||||
19:message/assistant:
|
||||
It reports a 2x speedup.
|
||||
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>
|
||||
22:message/user:
|
||||
Summarize the result.
|
||||
@@ -121,7 +121,6 @@ fn test_model_info(
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -1656,7 +1656,6 @@ async fn view_image_tool_returns_unsupported_message_for_text_only_model() -> an
|
||||
availability_nux: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -205,8 +205,6 @@ pub enum Feature {
|
||||
WebSearchCached,
|
||||
/// Expose the extension-backed standalone web search tool.
|
||||
StandaloneWebSearch,
|
||||
/// Let the host authorize MCP search independently of native search through per-turn policy.
|
||||
HostedSearchPolicy,
|
||||
/// Request the legacy Landlock mode of the Linux sandbox.
|
||||
UseLegacyLandlock,
|
||||
/// Experimental shell snapshotting.
|
||||
@@ -1471,12 +1469,6 @@ pub const FEATURES: &[FeatureSpec] = &[
|
||||
stage: Stage::UnderDevelopment,
|
||||
default_enabled: false,
|
||||
},
|
||||
FeatureSpec {
|
||||
id: Feature::HostedSearchPolicy,
|
||||
key: "hosted_search_policy",
|
||||
stage: Stage::UnderDevelopment,
|
||||
default_enabled: false,
|
||||
},
|
||||
FeatureSpec {
|
||||
id: Feature::SearchTool,
|
||||
key: "search_tool",
|
||||
|
||||
@@ -1,47 +0,0 @@
|
||||
//! Decodes the removed `mcp_attribution` field in old rollouts.
|
||||
//!
|
||||
//! Only whether Search MCP may have been used is kept. New rollouts use
|
||||
//! `model_search_state`.
|
||||
|
||||
use serde::Deserialize;
|
||||
use serde::Deserializer;
|
||||
|
||||
const SEARCH_CONNECTOR_ID: &str = "connector_openai_search_service";
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct LegacyMcpAttribution {
|
||||
status: LegacyStatus,
|
||||
#[serde(default)]
|
||||
sources: Vec<LegacySource>,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
enum LegacyStatus {
|
||||
None,
|
||||
Complete,
|
||||
#[serde(other)]
|
||||
Error,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct LegacySource {
|
||||
#[serde(default)]
|
||||
connector_id: Option<String>,
|
||||
}
|
||||
|
||||
pub(super) fn deserialize_search_mcp_use<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
{
|
||||
let value = serde_json::Value::deserialize(deserializer)?;
|
||||
Ok(Some(
|
||||
serde_json::from_value::<LegacyMcpAttribution>(value).map_or(true, |attribution| {
|
||||
matches!(attribution.status, LegacyStatus::Error)
|
||||
|| attribution
|
||||
.sources
|
||||
.iter()
|
||||
.any(|source| source.connector_id.as_deref() == Some(SEARCH_CONNECTOR_ID))
|
||||
}),
|
||||
))
|
||||
}
|
||||
@@ -18,8 +18,6 @@ pub use compaction_checkpoint::CompactionCheckpoint;
|
||||
mod initialization;
|
||||
pub use initialization::HistoryInitialization;
|
||||
|
||||
mod legacy_mcp_attribution;
|
||||
|
||||
use std::borrow::Borrow;
|
||||
use std::borrow::Cow;
|
||||
use std::ops::Deref;
|
||||
@@ -68,18 +66,6 @@ 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)]
|
||||
@@ -198,25 +184,6 @@ pub struct CodexHarnessMetadata {
|
||||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||||
pub inherited_user_message: bool,
|
||||
|
||||
/// Whether an old `mcp_attribution` value indicates Search MCP may have been used.
|
||||
#[serde(
|
||||
default,
|
||||
rename = "mcp_attribution",
|
||||
skip_serializing,
|
||||
deserialize_with = "legacy_mcp_attribution::deserialize_search_mcp_use"
|
||||
)]
|
||||
#[schemars(skip)]
|
||||
#[doc(hidden)]
|
||||
pub legacy_search_mcp_used: Option<bool>,
|
||||
|
||||
/// 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,
|
||||
|
||||
/// Sender context captured by the host when this task message was accepted.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub sender_user_messages: Option<Box<SenderUserMessages>>,
|
||||
|
||||
@@ -268,35 +268,6 @@ fn response_item_envelope_accessors_preserve_item() {
|
||||
assert_eq!(envelope.into_item(), replacement_item);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn old_rollout_metadata_restores_search_mcp_use() -> Result<()> {
|
||||
let metadata: CodexHarnessMetadata = serde_json::from_value(json!({
|
||||
"mcp_attribution": {
|
||||
"status": "complete",
|
||||
"sources": [{
|
||||
"connector_id": "connector_openai_search_service",
|
||||
"server_name": "example",
|
||||
"tool_name": "search",
|
||||
"first_turn_id": "turn_1"
|
||||
}]
|
||||
}
|
||||
}))?;
|
||||
|
||||
assert_eq!(metadata.legacy_search_mcp_used, Some(true));
|
||||
|
||||
let clean: CodexHarnessMetadata = serde_json::from_value(json!({
|
||||
"mcp_attribution": {
|
||||
"status": "none",
|
||||
"sources": []
|
||||
}
|
||||
}))?;
|
||||
assert_eq!(clean.legacy_search_mcp_used, Some(false));
|
||||
|
||||
let missing: CodexHarnessMetadata = serde_json::from_value(json!({}))?;
|
||||
assert_eq!(missing.legacy_search_mcp_used, None);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
/// Keeps legacy response-item rollout lines readable and byte-shape compatible.
|
||||
fn response_item_rollout_line_preserves_shape() -> Result<()> {
|
||||
|
||||
@@ -123,7 +123,6 @@ pub fn model_info_from_slug(slug: &str) -> ModelInfo {
|
||||
default_verbosity: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: WebSearchToolType::Text,
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: Some(272_000),
|
||||
|
||||
@@ -34,7 +34,6 @@ fn test_model(model_messages: Option<ModelMessages>) -> ModelInfo {
|
||||
default_verbosity: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: Default::default(),
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: None,
|
||||
|
||||
@@ -350,14 +350,6 @@ pub enum WebSearchToolType {
|
||||
TextAndImage,
|
||||
}
|
||||
|
||||
/// Provider preference selected by the resolved model catalog entry.
|
||||
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, TS, JsonSchema)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum WebSearchProvider {
|
||||
Standalone,
|
||||
SearchMcp,
|
||||
}
|
||||
|
||||
/// Server-provided truncation policy metadata for a model.
|
||||
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, TS, JsonSchema)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
@@ -470,8 +462,6 @@ pub struct ModelInfo {
|
||||
pub apply_patch_tool_type: Option<ApplyPatchToolType>,
|
||||
#[serde(default)]
|
||||
pub web_search_tool_type: WebSearchToolType,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub web_search_provider: Option<WebSearchProvider>,
|
||||
pub truncation_policy: TruncationPolicyConfig,
|
||||
#[serde(default)]
|
||||
pub supports_image_detail_original: bool,
|
||||
@@ -1238,7 +1228,6 @@ mod tests {
|
||||
default_verbosity: None,
|
||||
apply_patch_tool_type: None,
|
||||
web_search_tool_type: WebSearchToolType::Text,
|
||||
web_search_provider: None,
|
||||
truncation_policy: TruncationPolicyConfig::bytes(/*limit*/ 10_000),
|
||||
supports_image_detail_original: false,
|
||||
context_window: None,
|
||||
|
||||
@@ -111,7 +111,6 @@ pub use rmcp_client::RmcpClient;
|
||||
pub use rmcp_client::SendElicitation;
|
||||
pub use rmcp_client::StreamableHttpBearerToken;
|
||||
pub use rmcp_client::ToolWithConnectorId;
|
||||
pub use service_error::is_retryable_transport_error;
|
||||
pub use service_error::mcp_error;
|
||||
pub use service_error::request_error_code;
|
||||
pub use service_error::request_timeout_error;
|
||||
|
||||
@@ -1909,9 +1909,7 @@ impl RmcpClient {
|
||||
.await
|
||||
{
|
||||
Ok(result) => return Ok(result),
|
||||
Err(error)
|
||||
if label == "tools/list" && Self::is_retryable_transport_error(&error) =>
|
||||
{
|
||||
Err(error) if Self::is_retryable_tools_list_error(label, &error) => {
|
||||
let Some(retry_delay_ms) = retry_delay_ms else {
|
||||
return Err(error);
|
||||
};
|
||||
@@ -1962,7 +1960,10 @@ impl RmcpClient {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_retryable_transport_error(error: &ClientOperationError) -> bool {
|
||||
fn is_retryable_tools_list_error(label: &str, error: &ClientOperationError) -> bool {
|
||||
if label != "tools/list" {
|
||||
return false;
|
||||
}
|
||||
let ClientOperationError::Service(rmcp::service::ServiceError::TransportSend(error)) =
|
||||
error
|
||||
else {
|
||||
|
||||
@@ -6,14 +6,6 @@ use rmcp::service::ServiceError;
|
||||
use std::time::Duration;
|
||||
|
||||
use crate::rmcp_client::ClientOperationError;
|
||||
use crate::rmcp_client::RmcpClient;
|
||||
|
||||
/// Whether tools/list would retry this transport error before returning it to the caller.
|
||||
pub fn is_retryable_transport_error(error: &Error) -> bool {
|
||||
error
|
||||
.downcast_ref()
|
||||
.is_some_and(RmcpClient::is_retryable_transport_error)
|
||||
}
|
||||
|
||||
/// Returns the server's structured protocol error, including its original data.
|
||||
pub fn mcp_error(error: &Error) -> Option<&ErrorData> {
|
||||
|
||||
@@ -55,8 +55,6 @@ fn streamable_http_retry_classifies_transport_and_auth_errors() {
|
||||
),
|
||||
)),
|
||||
StreamableHttpError::UnexpectedServerResponse("HTTP 502: upstream failure".into()),
|
||||
StreamableHttpError::UnexpectedServerResponse("HTTP 503: service unavailable".into()),
|
||||
StreamableHttpError::UnexpectedServerResponse("HTTP 403: forbidden".into()),
|
||||
StreamableHttpError::UnexpectedServerResponse("HTTP 400: bad request".into()),
|
||||
StreamableHttpError::Client(StreamableHttpClientAdapterError::Auth(
|
||||
codex_api::AuthError::Transient("credential refresh unavailable".to_string()),
|
||||
@@ -70,18 +68,9 @@ fn streamable_http_retry_classifies_transport_and_auth_errors() {
|
||||
];
|
||||
|
||||
assert_eq!(
|
||||
errors.map(|error| {
|
||||
let transport = DynamicTransportError::from_parts(
|
||||
"streamable_http",
|
||||
TypeId::of::<()>(),
|
||||
Box::new(error),
|
||||
);
|
||||
let error =
|
||||
ClientOperationError::from(rmcp::service::ServiceError::TransportSend(transport));
|
||||
crate::is_retryable_transport_error(&anyhow::Error::new(error).context("listing tools"))
|
||||
}),
|
||||
errors.map(|error| RmcpClient::is_retryable_streamable_http_error(&error)),
|
||||
[
|
||||
false, true, true, true, false, true, true, false, false, true, false, false
|
||||
false, true, true, true, false, true, false, true, false, false
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
@@ -7370,11 +7370,6 @@ class WebSearchMode(Enum):
|
||||
live = "live"
|
||||
|
||||
|
||||
class WebSearchProvider(Enum):
|
||||
standalone = "standalone"
|
||||
search_mcp = "search_mcp"
|
||||
|
||||
|
||||
class WebSearchToolConfig(BaseModel):
|
||||
model_config = ConfigDict(
|
||||
extra="forbid",
|
||||
@@ -12106,12 +12101,6 @@ class Config(BaseModel):
|
||||
),
|
||||
] = None
|
||||
browser_use: BrowserUseConfig | None = None
|
||||
client_search_provider: Annotated[
|
||||
WebSearchProvider | None,
|
||||
Field(
|
||||
description="Effective tools.client_search_provider hint. Model-selected providers take precedence."
|
||||
),
|
||||
] = None
|
||||
compact_prompt: str | None = None
|
||||
computer_use: ComputerUseConfig | None = None
|
||||
desktop: dict[str, Any] | None = None
|
||||
|
||||
Reference in New Issue
Block a user