Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

feat(codex): use standalone endpoint for forced web search (#53)

mulfyxd005afd44a84
diff --git a/docs/src/content/docs/providers/codex.md b/docs/src/content/docs/providers/codex.md
index a2734b5..c6a9c39 100644
--- a/docs/src/content/docs/providers/codex.md
+++ b/docs/src/content/docs/providers/codex.md
@@ -35,7 +35,14 @@ Claude Code summary compaction requests are capped at low effort by default beca
## Tools and multimodal input
- Claude function tools and tool results map to Responses API function calls and outputs.
-- Claude Code hosted web search maps to Codex `web_search`, including supported domain filters and forced tool choice.
+- Claude Code's forced `web_search_20250305` subrequest uses Codex's standalone
+ `/alpha/search` endpoint. It keeps the resolved model, omits search reasoning,
+ and preserves non-empty domain filters, so Luna searches do not require a Sol
+ Responses turn. Automatic hosted-search requests remain on the full Responses
+ API because the standalone endpoint cannot decide whether to invoke a tool.
+ Structured result DTOs map back to Anthropic `server_tool_use` and
+ `web_search_tool_result` blocks, while standalone text output remains text.
+ The proxy locally estimates input and output tokens and reports search usage.
- Top-level base64 user images map to `input_image`.
- Supported base64 images nested in tool results also map to `input_image`.
- Remote image URLs, malformed images, and unsupported tool-result image forms remain textual placeholders.
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rs
index d3e7fb8..5792c80 100644
--- a/src/providers/codex/client.rs
+++ b/src/providers/codex/client.rs
@@ -11,6 +11,7 @@ use crate::traffic::TrafficCapture;
use super::auth::constants::{CODEX_API_ENDPOINT, ORIGINATOR, RESPONSES_LITE_ORIGINATOR};
use super::auth::manager::CodexAuthManager;
use super::auth::token_store::{DefaultCodexAuthStore, StoredAuth, file_store};
+use super::search::{SearchRequest, SearchResponse};
use super::translate::request::ResponsesRequest;
// ---------------------------------------------------------------------------
@@ -180,6 +181,27 @@ pub fn build_native_codex_headers(
Ok(headers)
}
+pub fn build_codex_search_headers(
+ auth: &StoredAuth,
+ ctx: &RequestContext,
+) -> Result<http::HeaderMap, CodexError> {
+ let mut headers = build_codex_headers(auth, ctx, false)?;
+ headers.insert(
+ http::header::ACCEPT,
+ header_value("accept", "application/json")?,
+ );
+ let originator = config::codex_originator(RESPONSES_LITE_ORIGINATOR);
+ headers.insert("originator", header_value("originator", &originator)?);
+ let user_agent = config::codex_user_agent(RESPONSES_LITE_ORIGINATOR);
+ if !user_agent.is_empty() {
+ headers.insert(
+ http::header::USER_AGENT,
+ header_value("user-agent", &user_agent)?,
+ );
+ }
+ Ok(headers)
+}
+
fn header_value(name: &str, value: &str) -> Result<http::HeaderValue, CodexError> {
http::HeaderValue::from_str(value).map_err(|e| CodexError {
status: 500,
@@ -190,6 +212,14 @@ fn header_value(name: &str, value: &str) -> Result<http::HeaderValue, CodexError
})
}
+fn search_endpoint(base_url: &str) -> String {
+ let base_url = base_url.trim_end_matches('/');
+ match base_url.strip_suffix("/responses") {
+ Some(api_root) => format!("{api_root}/alpha/search"),
+ None => format!("{base_url}/alpha/search"),
+ }
+}
+
// ---------------------------------------------------------------------------
// WebSocket request shaping
// ---------------------------------------------------------------------------
@@ -434,6 +464,68 @@ impl CodexHttpClient {
.await
}
+ pub async fn post_search(
+ &self,
+ body: &SearchRequest,
+ ctx: &RequestContext,
+ ) -> Result<SearchResponse, CodexError> {
+ let mut auth = self.auth_manager.get_auth().await.map_err(|e| CodexError {
+ status: 401,
+ message: "Auth error".to_string(),
+ detail: Some(e.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Auth,
+ })?;
+ let body_json = serde_json::to_string(body).map_err(|e| CodexError {
+ status: 500,
+ message: "Failed to serialize search request".to_string(),
+ detail: Some(e.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?;
+ let mut auth_refresh_attempted = false;
+ let mut retries = 0_u32;
+
+ loop {
+ let response = self.attempt_post_search(&auth, &body_json, ctx).await?;
+ if response.status == 401 && !auth_refresh_attempted {
+ auth_refresh_attempted = true;
+ auth = self
+ .auth_manager
+ .force_refresh(&auth.access)
+ .await
+ .map_err(auth_refresh_error)?;
+ continue;
+ }
+ if should_retry_codex_status(response.status)
+ && retries < MAX_BUFFERED_TRANSPORT_RETRIES
+ {
+ let retry_after = response
+ .headers
+ .iter()
+ .find(|(key, _)| key.eq_ignore_ascii_case("retry-after"))
+ .map(|(_, value)| value.as_str());
+ let delay = compute_backoff_delay(retries, retry_after);
+ if delay.exceeds_budget {
+ return Err(codex_status_error(response));
+ }
+ retries += 1;
+ sleep(delay.wait_ms).await;
+ continue;
+ }
+ if !(200..300).contains(&response.status) {
+ return Err(codex_status_error(response));
+ }
+ return serde_json::from_slice(&response.body).map_err(|e| CodexError {
+ status: 502,
+ message: "Failed to decode Codex search response".to_string(),
+ detail: Some(e.to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ });
+ }
+ }
+
async fn post_codex_with_transport(
&self,
body: &ResponsesRequest,
@@ -1076,6 +1168,107 @@ impl CodexHttpClient {
transport: ActualTransport::Http,
})
}
+
+ async fn attempt_post_search(
+ &self,
+ auth: &StoredAuth,
+ body_json: &str,
+ ctx: &RequestContext,
+ ) -> Result<CodexResponse, CodexError> {
+ let url = search_endpoint(&self.base_url);
+ let headers = build_codex_search_headers(auth, ctx)?;
+
+ if let Some(traffic) = ctx.traffic.as_deref() {
+ write_codex_http_request_capture(traffic, &url, &headers, body_json);
+ }
+
+ let mut request = self.client.post(&url);
+ for (key, value) in headers.iter() {
+ request = request.header(key.as_str(), value.as_bytes());
+ }
+ let started_at = Instant::now();
+ let mut response = tokio::time::timeout(
+ Duration::from_millis(self.header_timeout_ms),
+ request.body(body_json.to_string()).send(),
+ )
+ .await
+ .map_err(|_| CodexError {
+ status: 0,
+ message: format!(
+ "Timed out waiting {}ms for Codex search response headers",
+ self.header_timeout_ms
+ ),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?
+ .map_err(|e| CodexError {
+ status: 0,
+ message: format!("Codex search network error: {e}"),
+ detail: None,
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?;
+
+ let status = response.status().as_u16();
+ let headers: Vec<(String, String)> = response
+ .headers()
+ .iter()
+ .map(|(key, value)| {
+ (
+ key.to_string(),
+ value.to_str().unwrap_or_default().to_string(),
+ )
+ })
+ .collect();
+ let mut body = Vec::new();
+ let mut response_started = false;
+ loop {
+ let chunk = tokio::time::timeout(
+ Duration::from_millis(self.body_idle_timeout_ms),
+ response.chunk(),
+ )
+ .await
+ .map_err(|_| CodexError {
+ status: 0,
+ message: format!(
+ "Timed out waiting {}ms for the next Codex search response body chunk",
+ self.body_idle_timeout_ms
+ ),
+ detail: Some("http_response_body".to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?
+ .map_err(|e| CodexError {
+ status: 0,
+ message: format!("Transport error reading Codex search response body: {e}"),
+ detail: Some("http_response_body".to_string()),
+ retry_after: None,
+ origin: CodexErrorOrigin::Http,
+ })?;
+ let Some(chunk) = chunk else {
+ break;
+ };
+ if !response_started {
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.generation_started(&ctx.req_id);
+ }
+ response_started = true;
+ }
+ body.extend_from_slice(&chunk);
+ }
+
+ if let Some(traffic) = ctx.traffic.as_deref() {
+ write_upstream_response_capture(traffic, status, started_at.elapsed(), &headers, &body);
+ }
+
+ Ok(CodexResponse {
+ body,
+ status,
+ headers,
+ transport: ActualTransport::Http,
+ })
+ }
}
fn write_codex_http_request_capture(
@@ -1506,6 +1699,32 @@ mod tests {
client
}
+ async fn read_http_request(stream: &mut tokio::net::TcpStream) -> Vec<u8> {
+ let mut request = Vec::new();
+ let mut chunk = [0_u8; 4096];
+ loop {
+ let read = stream.read(&mut chunk).await.unwrap();
+ assert!(read > 0, "request ended before its body was complete");
+ request.extend_from_slice(&chunk[..read]);
+ let Some(header_end) = request.windows(4).position(|part| part == b"\r\n\r\n") else {
+ continue;
+ };
+ let headers = String::from_utf8_lossy(&request[..header_end]);
+ let content_length = headers
+ .lines()
+ .find_map(|line| {
+ let (name, value) = line.split_once(':')?;
+ name.eq_ignore_ascii_case("content-length")
+ .then(|| value.trim().parse::<usize>().ok())
+ .flatten()
+ })
+ .unwrap_or(0);
+ if request.len() >= header_end + 4 + content_length {
+ return request;
+ }
+ }
+ }
+
#[tokio::test]
async fn native_responses_replaces_auth_and_preserves_json_body() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
@@ -1678,6 +1897,77 @@ mod tests {
assert_eq!(response.body, b"data: keep\n\n");
}
+ #[tokio::test]
+ async fn standalone_search_posts_json_to_alpha_endpoint() {
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let addr = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (mut stream, _) = listener.accept().await.unwrap();
+ let request = read_http_request(&mut stream).await;
+ let header_end = request
+ .windows(4)
+ .position(|part| part == b"\r\n\r\n")
+ .unwrap();
+ let headers = String::from_utf8_lossy(&request[..header_end]);
+ assert!(headers.starts_with("POST /alpha/search HTTP/1.1"));
+ assert!(
+ headers
+ .to_ascii_lowercase()
+ .contains("accept: application/json")
+ );
+ assert!(headers.contains("authorization: Bearer test"));
+ let body: serde_json::Value =
+ serde_json::from_slice(&request[header_end + 4..]).unwrap();
+ assert_eq!(body["model"], "gpt-5.6-luna");
+ assert!(body.get("reasoning").is_none());
+ assert_eq!(body["commands"]["search_query"][0]["q"], "find Codex");
+
+ let response = serde_json::to_vec(&serde_json::json!({
+ "encrypted_output": "opaque",
+ "output": "search output",
+ "results": [{
+ "type": "text_result",
+ "ref_id": "turn0search0",
+ "url": "https://example.com",
+ "title": "Example"
+ }]
+ }))
+ .unwrap();
+ let response_headers = format!(
+ "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",
+ response.len()
+ );
+ stream.write_all(response_headers.as_bytes()).await.unwrap();
+ stream.write_all(&response).await.unwrap();
+ });
+
+ let client = authenticated_http_test_client(format!("http://{addr}/responses"));
+ let request = super::super::search::SearchRequest {
+ id: "session".to_string(),
+ model: "gpt-5.6-luna".to_string(),
+ reasoning: None,
+ input: None,
+ commands: super::super::search::SearchCommands {
+ search_query: vec![super::super::search::SearchQuery {
+ q: "find Codex".to_string(),
+ }],
+ },
+ settings: super::super::search::SearchSettings {
+ filters: None,
+ allowed_callers: vec!["direct"],
+ external_web_access: true,
+ },
+ max_output_tokens: 2_500,
+ };
+ let response = client
+ .post_search(&request, &http_test_context())
+ .await
+ .unwrap();
+ server.await.unwrap();
+ assert_eq!(response.output, "search output");
+ assert_eq!(response.results.unwrap().len(), 1);
+ }
+
#[tokio::test]
async fn auto_falls_back_to_http_after_statusful_websocket_handshake_failure() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
diff --git a/src/providers/codex/count_tokens.rs b/src/providers/codex/count_tokens.rs
index 580e7d8..57051f8 100644
--- a/src/providers/codex/count_tokens.rs
+++ b/src/providers/codex/count_tokens.rs
@@ -116,7 +116,7 @@ fn count_tool_tokens(tools: &[ResponsesTool]) -> u64 {
total
}
-fn approx_token_count(text: &str) -> u64 {
+pub(crate) fn approx_token_count(text: &str) -> u64 {
if text.is_empty() {
return 0;
}
diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rs
index 0717421..5bcb583 100644
--- a/src/providers/codex/mod.rs
+++ b/src/providers/codex/mod.rs
@@ -7,6 +7,7 @@ pub mod count_tokens;
pub(crate) mod events;
pub mod native;
pub mod request_summary;
+pub mod search;
pub mod translate;
pub mod websocket;
@@ -17,6 +18,7 @@ use axum::response::{IntoResponse, Response};
use bytes::Bytes;
use http::StatusCode;
use std::sync::Arc;
+use std::time::Instant;
use crate::anthropic::error::json_error;
use crate::anthropic::schema::{CountTokensResponse, MessagesRequest};
@@ -123,6 +125,85 @@ impl Provider for CodexProvider {
),
);
}
+ if search::is_standalone_search_request(&body) {
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.model_resolved(&ctx.req_id, &resolved.model);
+ }
+ let (search_request, query) = match search::build_search_request(
+ &body,
+ &resolved.model,
+ ctx.session_id.as_deref(),
+ ) {
+ Ok(request) => request,
+ Err(error) => {
+ return json_error(
+ StatusCode::BAD_REQUEST,
+ "invalid_request_error",
+ error.to_string(),
+ );
+ }
+ };
+ let log = create_logger("codex");
+ let started_at = Instant::now();
+ log.info(
+ "codex_standalone_search_started",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), serde_json::json!(&ctx.req_id)),
+ ("model".to_string(), serde_json::json!(&resolved.model)),
+ ("stream".to_string(), serde_json::json!(want_stream)),
+ ])),
+ );
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.upstream_started(&ctx.req_id);
+ }
+ let search_response = match self.client.post_search(&search_request, &ctx).await {
+ Ok(response) => response,
+ Err(error) => {
+ log.warn(
+ "codex_standalone_search_failed",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), serde_json::json!(&ctx.req_id)),
+ ("model".to_string(), serde_json::json!(&resolved.model)),
+ ("status".to_string(), serde_json::json!(error.status)),
+ (
+ "ms".to_string(),
+ serde_json::json!(started_at.elapsed().as_millis()),
+ ),
+ ])),
+ );
+ return map_codex_error_to_response(&error);
+ }
+ };
+ log.info(
+ "codex_standalone_search_completed",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), serde_json::json!(&ctx.req_id)),
+ ("model".to_string(), serde_json::json!(&resolved.model)),
+ (
+ "resultCount".to_string(),
+ serde_json::json!(search_response.results.as_ref().map(Vec::len)),
+ ),
+ (
+ "ms".to_string(),
+ serde_json::json!(started_at.elapsed().as_millis()),
+ ),
+ ])),
+ );
+ let input_tokens = search::search_request_input_tokens(&search_request);
+ let output_tokens = search::search_response_output_tokens(&search_response);
+ if let Some(monitor) = ctx.monitor.as_ref() {
+ monitor.usage_updated(&ctx.req_id, Some(input_tokens), Some(output_tokens));
+ }
+ return search::anthropic_search_response(
+ &search_response,
+ &query,
+ &message_id,
+ model,
+ want_stream,
+ input_tokens,
+ ctx.traffic.as_deref(),
+ );
+ }
let use_responses_lite = apply_model_lane_for_request(&mut resolved.model, &body);
if let Some(monitor) = ctx.monitor.as_ref() {
monitor.model_resolved(&ctx.req_id, &resolved.model);
diff --git a/src/providers/codex/search.rs b/src/providers/codex/search.rs
new file mode 100644
index 0000000..8a787af
--- /dev/null
+++ b/src/providers/codex/search.rs
@@ -0,0 +1,710 @@
+use std::collections::HashSet;
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+
+use crate::anthropic::schema::MessagesRequest;
+use crate::anthropic::sse::encode_sse_event;
+use crate::traffic::TrafficCapture;
+
+use super::count_tokens::approx_token_count;
+
+const SEARCH_OUTPUT_TOKEN_BUDGET: u64 = 2_500;
+const SEARCH_ASSISTANT_CONTEXT_TOKEN_BUDGET: u64 = 1_000;
+const SEARCH_USER_CONTEXT_MESSAGES: usize = 2;
+const CLAUDE_SEARCH_PROMPT_PREFIX: &str = "Perform a web search for the query:";
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct SearchRequest {
+ pub id: String,
+ pub model: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub reasoning: Option<Value>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub input: Option<Value>,
+ pub commands: SearchCommands,
+ pub settings: SearchSettings,
+ pub max_output_tokens: u64,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct SearchCommands {
+ pub search_query: Vec<SearchQuery>,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct SearchQuery {
+ pub q: String,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct SearchSettings {
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub filters: Option<SearchFilters>,
+ pub allowed_callers: Vec<&'static str>,
+ pub external_web_access: bool,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct SearchFilters {
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub allowed_domains: Option<Vec<String>>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub blocked_domains: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+pub struct SearchResponse {
+ pub encrypted_output: Option<String>,
+ pub output: String,
+ #[serde(default)]
+ pub results: Option<Vec<Value>>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SearchResult {
+ title: String,
+ url: String,
+}
+
+pub fn is_standalone_search_request(req: &MessagesRequest) -> bool {
+ let Some(choice) = req.extra.get("tool_choice").and_then(Value::as_object) else {
+ return false;
+ };
+ if choice.get("type").and_then(Value::as_str) != Some("tool") {
+ return false;
+ }
+ let Some(selected_name) = choice.get("name").and_then(Value::as_str) else {
+ return false;
+ };
+ req.extra
+ .get("tools")
+ .and_then(Value::as_array)
+ .is_some_and(|tools| {
+ tools.iter().any(|tool| {
+ tool.get("type").and_then(Value::as_str) == Some("web_search_20250305")
+ && tool.get("name").and_then(Value::as_str) == Some(selected_name)
+ })
+ })
+}
+
+pub fn build_search_request(
+ req: &MessagesRequest,
+ model: &str,
+ session_id: Option<&str>,
+) -> Result<(SearchRequest, String), anyhow::Error> {
+ let query = extract_search_query(req)
+ .ok_or_else(|| anyhow::anyhow!("web_search request does not contain a text query"))?;
+ let input = search_input(req);
+ let filters = search_filters(req);
+ let id = session_id
+ .map(str::to_owned)
+ .unwrap_or_else(|| format!("search-{}", uuid::Uuid::new_v4()));
+
+ Ok((
+ SearchRequest {
+ id,
+ model: model.to_string(),
+ reasoning: None,
+ input,
+ commands: SearchCommands {
+ search_query: vec![SearchQuery { q: query.clone() }],
+ },
+ settings: SearchSettings {
+ filters,
+ allowed_callers: vec!["direct"],
+ external_web_access: true,
+ },
+ max_output_tokens: SEARCH_OUTPUT_TOKEN_BUDGET,
+ },
+ query,
+ ))
+}
+
+pub fn search_request_input_tokens(request: &SearchRequest) -> u64 {
+ let mut tokens = approx_token_count(&request.model);
+ tokens += request
+ .commands
+ .search_query
+ .iter()
+ .map(|query| approx_token_count(&query.q))
+ .sum::<u64>();
+ tokens += request.input.as_ref().map(value_text_tokens).unwrap_or(0);
+ if let Some(filters) = &request.settings.filters {
+ tokens += filters
+ .allowed_domains
+ .iter()
+ .flatten()
+ .chain(filters.blocked_domains.iter().flatten())
+ .map(|domain| approx_token_count(domain))
+ .sum::<u64>();
+ }
+ tokens.max(1)
+}
+
+pub fn search_response_output_tokens(response: &SearchResponse) -> u64 {
+ (approx_token_count(&response.output)
+ + response
+ .results
+ .as_ref()
+ .map(|results| results.iter().map(value_text_tokens).sum())
+ .unwrap_or(0))
+ .max(1)
+}
+
+fn value_text_tokens(value: &Value) -> u64 {
+ match value {
+ Value::String(text) => approx_token_count(text),
+ Value::Array(values) => values.iter().map(value_text_tokens).sum(),
+ Value::Object(values) => values.values().map(value_text_tokens).sum(),
+ _ => 0,
+ }
+}
+
+pub fn anthropic_search_response(
+ response: &SearchResponse,
+ query: &str,
+ message_id: &str,
+ model: &str,
+ stream: bool,
+ input_tokens: u64,
+ traffic: Option<&TrafficCapture>,
+) -> axum::response::Response {
+ use axum::response::IntoResponse;
+
+ let tool_use_id = format!("srvtoolu_ws_{}", uuid::Uuid::new_v4().simple());
+ let results = search_results(response);
+ let content = response_content(response, query, &tool_use_id, &results);
+ let output_tokens = search_response_output_tokens(response);
+ let usage = json!({
+ "input_tokens": input_tokens,
+ "output_tokens": output_tokens,
+ "cache_creation_input_tokens": 0,
+ "cache_read_input_tokens": 0,
+ "server_tool_use": {"web_search_requests": 1}
+ });
+
+ if !stream {
+ return (
+ http::StatusCode::OK,
+ axum::Json(json!({
+ "id": message_id,
+ "type": "message",
+ "role": "assistant",
+ "model": model,
+ "content": content,
+ "stop_reason": "end_turn",
+ "stop_sequence": null,
+ "usage": usage,
+ })),
+ )
+ .into_response();
+ }
+
+ let mut body = Vec::new();
+ emit(
+ &mut body,
+ traffic,
+ "message_start",
+ &json!({
+ "type": "message_start",
+ "message": {
+ "id": message_id,
+ "type": "message",
+ "role": "assistant",
+ "model": model,
+ "content": [],
+ "stop_reason": null,
+ "stop_sequence": null,
+ "usage": {"input_tokens": input_tokens, "output_tokens": 0}
+ }
+ }),
+ );
+ emit(
+ &mut body,
+ traffic,
+ "content_block_start",
+ &json!({
+ "type": "content_block_start",
+ "index": 0,
+ "content_block": {
+ "type": "server_tool_use",
+ "id": tool_use_id,
+ "name": "web_search",
+ "input": {}
+ }
+ }),
+ );
+ emit(
+ &mut body,
+ traffic,
+ "content_block_delta",
+ &json!({
+ "type": "content_block_delta",
+ "index": 0,
+ "delta": {
+ "type": "input_json_delta",
+ "partial_json": json!({"query": query}).to_string()
+ }
+ }),
+ );
+ emit_block_stop(&mut body, traffic, 0);
+ emit(
+ &mut body,
+ traffic,
+ "content_block_start",
+ &json!({
+ "type": "content_block_start",
+ "index": 1,
+ "content_block": {
+ "type": "web_search_tool_result",
+ "tool_use_id": tool_use_id,
+ "content": web_search_result_values(&results)
+ }
+ }),
+ );
+ emit_block_stop(&mut body, traffic, 1);
+ if !response.output.is_empty() {
+ emit(
+ &mut body,
+ traffic,
+ "content_block_start",
+ &json!({
+ "type": "content_block_start",
+ "index": 2,
+ "content_block": {"type": "text", "text": ""}
+ }),
+ );
+ emit(
+ &mut body,
+ traffic,
+ "content_block_delta",
+ &json!({
+ "type": "content_block_delta",
+ "index": 2,
+ "delta": {"type": "text_delta", "text": response.output}
+ }),
+ );
+ emit_block_stop(&mut body, traffic, 2);
+ }
+ emit(
+ &mut body,
+ traffic,
+ "message_delta",
+ &json!({
+ "type": "message_delta",
+ "delta": {"stop_reason": "end_turn", "stop_sequence": null},
+ "usage": usage
+ }),
+ );
+ emit(
+ &mut body,
+ traffic,
+ "message_stop",
+ &json!({"type": "message_stop"}),
+ );
+
+ let headers = [
+ (http::header::CONTENT_TYPE, "text/event-stream"),
+ (http::header::CACHE_CONTROL, "no-cache"),
+ (http::header::CONNECTION, "keep-alive"),
+ ];
+ (headers, body).into_response()
+}
+
+fn extract_search_query(req: &MessagesRequest) -> Option<String> {
+ req.messages
+ .iter()
+ .rev()
+ .filter(|message| message.role == "user")
+ .find_map(|message| {
+ let text = content_text(&message.content);
+ let text = text.trim();
+ if text.is_empty() {
+ return None;
+ }
+ Some(
+ text.strip_prefix(CLAUDE_SEARCH_PROMPT_PREFIX)
+ .map(str::trim)
+ .filter(|query| !query.is_empty())
+ .unwrap_or(text)
+ .to_string(),
+ )
+ })
+}
+
+fn search_input(req: &MessagesRequest) -> Option<Value> {
+ let mut messages: Vec<(&str, String)> = req
+ .messages
+ .iter()
+ .filter(|message| matches!(message.role.as_str(), "user" | "assistant"))
+ .filter_map(|message| {
+ let text = content_text(&message.content);
+ (!text.is_empty()).then_some((message.role.as_str(), text))
+ })
+ .collect();
+ let latest_user = messages.iter().rposition(|(role, _)| *role == "user")?;
+ messages.truncate(latest_user + 1);
+ let first_user = messages
+ .iter()
+ .enumerate()
+ .rev()
+ .filter(|(_, (role, _))| *role == "user")
+ .take(SEARCH_USER_CONTEXT_MESSAGES)
+ .last()
+ .map(|(index, _)| index)
+ .unwrap_or(latest_user);
+ messages.drain(..first_user);
+
+ let mut assistant_budget = SEARCH_ASSISTANT_CONTEXT_TOKEN_BUDGET;
+ let items: Vec<Value> = messages
+ .into_iter()
+ .filter_map(|(role, text)| {
+ let (content_type, text) = if role == "assistant" {
+ if assistant_budget == 0 {
+ return None;
+ }
+ let text = truncate_to_approx_tokens(&text, assistant_budget);
+ assistant_budget = assistant_budget.saturating_sub(approx_token_count(&text));
+ ("output_text", text)
+ } else {
+ ("input_text", text)
+ };
+ (!text.is_empty()).then(|| {
+ json!({
+ "type": "message",
+ "role": role,
+ "content": [{"type": content_type, "text": text}]
+ })
+ })
+ })
+ .collect();
+ (!items.is_empty()).then_some(Value::Array(items))
+}
+
+fn truncate_to_approx_tokens(text: &str, max_tokens: u64) -> String {
+ if approx_token_count(text) <= max_tokens {
+ return text.to_string();
+ }
+
+ let mut tokens = 0_u64;
+ let mut in_word = false;
+ let mut end = 0;
+ for (index, ch) in text.char_indices() {
+ let word_char = ch.is_alphanumeric() || ch == '-' || ch == '_';
+ let starts_token = if word_char {
+ !in_word
+ } else {
+ !ch.is_whitespace()
+ };
+ if starts_token {
+ if tokens == max_tokens {
+ break;
+ }
+ tokens += 1;
+ }
+ in_word = word_char;
+ end = index + ch.len_utf8();
+ }
+ text[..end].to_string()
+}
+
+fn content_text(content: &Value) -> String {
+ match content {
+ Value::String(text) => text.clone(),
+ Value::Array(blocks) => blocks
+ .iter()
+ .filter(|block| block.get("type").and_then(Value::as_str) == Some("text"))
+ .filter_map(|block| block.get("text").and_then(Value::as_str))
+ .collect::<Vec<_>>()
+ .join("\n"),
+ _ => String::new(),
+ }
+}
+
+fn search_filters(req: &MessagesRequest) -> Option<SearchFilters> {
+ let tool = req
+ .extra
+ .get("tools")?
+ .as_array()?
+ .iter()
+ .find(|tool| tool.get("type").and_then(Value::as_str) == Some("web_search_20250305"))?;
+ let allowed_domains = string_array(tool.get("allowed_domains"));
+ let blocked_domains = string_array(tool.get("blocked_domains"));
+ (allowed_domains.is_some() || blocked_domains.is_some()).then_some(SearchFilters {
+ allowed_domains,
+ blocked_domains,
+ })
+}
+
+fn string_array(value: Option<&Value>) -> Option<Vec<String>> {
+ let values = value?.as_array()?;
+ let values: Vec<String> = values
+ .iter()
+ .filter_map(Value::as_str)
+ .map(str::to_owned)
+ .collect();
+ (!values.is_empty()).then_some(values)
+}
+
+fn search_results(response: &SearchResponse) -> Vec<SearchResult> {
+ let mut results = Vec::new();
+ let mut seen = HashSet::new();
+ for result in response.results.iter().flatten() {
+ let Some(url) = result.get("url").and_then(Value::as_str) else {
+ continue;
+ };
+ if !seen.insert(url.to_string()) {
+ continue;
+ }
+ let title = result
+ .get("title")
+ .and_then(Value::as_str)
+ .or_else(|| result.get("ref_id").and_then(Value::as_str))
+ .unwrap_or(url);
+ results.push(SearchResult {
+ title: title.to_string(),
+ url: url.to_string(),
+ });
+ }
+ results
+}
+
+fn response_content(
+ response: &SearchResponse,
+ query: &str,
+ tool_use_id: &str,
+ results: &[SearchResult],
+) -> Vec<Value> {
+ let mut content = vec![
+ json!({
+ "type": "server_tool_use",
+ "id": tool_use_id,
+ "name": "web_search",
+ "input": {"query": query}
+ }),
+ json!({
+ "type": "web_search_tool_result",
+ "tool_use_id": tool_use_id,
+ "content": web_search_result_values(results)
+ }),
+ ];
+ if !response.output.is_empty() {
+ content.push(json!({"type": "text", "text": response.output}));
+ }
+ content
+}
+
+fn web_search_result_values(results: &[SearchResult]) -> Vec<Value> {
+ results
+ .iter()
+ .map(|result| {
+ json!({
+ "type": "web_search_result",
+ "title": result.title,
+ "url": result.url,
+ })
+ })
+ .collect()
+}
+
+fn emit_block_stop(out: &mut Vec<u8>, traffic: Option<&TrafficCapture>, index: usize) {
+ emit(
+ out,
+ traffic,
+ "content_block_stop",
+ &json!({"type": "content_block_stop", "index": index}),
+ );
+}
+
+fn emit(out: &mut Vec<u8>, traffic: Option<&TrafficCapture>, event: &str, data: &Value) {
+ if let Some(traffic) = traffic {
+ traffic.write_json_event(
+ "050-downstream-event",
+ &json!({"event": event, "data": data}),
+ );
+ }
+ out.extend_from_slice(&encode_sse_event(Some(event), &data.to_string()));
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::anthropic::sse::parse_sse_events;
+
+ fn request() -> MessagesRequest {
+ serde_json::from_value(json!({
+ "model": "claude-haiku-4-5-20251001",
+ "max_tokens": 32000,
+ "stream": true,
+ "messages": [{
+ "role": "user",
+ "content": [{
+ "type": "text",
+ "text": "Perform a web search for the query: Codex standalone search"
+ }]
+ }],
+ "tools": [{
+ "type": "web_search_20250305",
+ "name": "web_search",
+ "allowed_domains": ["openai.com"]
+ }],
+ "tool_choice": {"type": "tool", "name": "web_search"}
+ }))
+ .unwrap()
+ }
+
+ #[test]
+ fn request_preserves_luna_and_omits_reasoning() {
+ let (request, query) =
+ build_search_request(&request(), "gpt-5.6-luna", Some("session-1")).unwrap();
+ assert_eq!(request.model, "gpt-5.6-luna");
+ assert_eq!(request.reasoning, None);
+ assert_eq!(request.id, "session-1");
+ assert_eq!(request.max_output_tokens, 2_500);
+ assert_eq!(query, "Codex standalone search");
+ assert_eq!(request.commands.search_query[0].q, query);
+ assert_eq!(
+ request.settings.filters.unwrap().allowed_domains,
+ Some(vec!["openai.com".to_string()])
+ );
+ }
+
+ #[test]
+ fn only_forced_claude_search_uses_standalone_endpoint() {
+ let forced = request();
+ assert!(is_standalone_search_request(&forced));
+
+ let mut automatic = forced.clone();
+ automatic
+ .extra
+ .insert("tool_choice".to_string(), json!({"type": "auto"}));
+ assert!(!is_standalone_search_request(&automatic));
+ }
+
+ #[test]
+ fn search_input_uses_role_specific_content_and_recent_context() {
+ let mut req = request();
+ req.messages = serde_json::from_value(json!([
+ {"role": "user", "content": "old user"},
+ {"role": "assistant", "content": "old assistant"},
+ {"role": "user", "content": "previous user"},
+ {"role": "assistant", "content": "previous assistant"},
+ {
+ "role": "user",
+ "content": "Perform a web search for the query: current query"
+ },
+ {"role": "assistant", "content": "content after latest user"}
+ ]))
+ .unwrap();
+
+ let (search, _) = build_search_request(&req, "gpt-5.6-luna", None).unwrap();
+ let input = search.input.unwrap();
+ let items = input.as_array().unwrap();
+ assert_eq!(items.len(), 3);
+ assert_eq!(items[0]["content"][0]["text"], "previous user");
+ assert_eq!(items[0]["content"][0]["type"], "input_text");
+ assert_eq!(items[1]["content"][0]["text"], "previous assistant");
+ assert_eq!(items[1]["content"][0]["type"], "output_text");
+ assert_eq!(items[2]["content"][0]["type"], "input_text");
+ }
+
+ #[test]
+ fn search_input_bounds_assistant_context() {
+ let mut req = request();
+ let long_assistant = (0..2_000)
+ .map(|index| format!("word{index}"))
+ .collect::<Vec<_>>()
+ .join(" ");
+ req.messages = serde_json::from_value(json!([
+ {"role": "user", "content": "previous user"},
+ {"role": "assistant", "content": long_assistant},
+ {
+ "role": "user",
+ "content": "Perform a web search for the query: current query"
+ }
+ ]))
+ .unwrap();
+
+ let (search, _) = build_search_request(&req, "gpt-5.6-luna", None).unwrap();
+ let assistant = search.input.unwrap()[1]["content"][0]["text"]
+ .as_str()
+ .unwrap()
+ .to_string();
+ assert!(approx_token_count(&assistant) <= SEARCH_ASSISTANT_CONTEXT_TOKEN_BUDGET);
+ assert!(!assistant.contains("word1999"));
+ }
+
+ #[test]
+ fn missing_structured_results_does_not_infer_urls_from_output() {
+ let response = SearchResponse {
+ encrypted_output: None,
+ output: "Result from https://github.com with an embedded https://example.com link"
+ .to_string(),
+ results: None,
+ };
+
+ assert!(search_results(&response).is_empty());
+ }
+
+ #[test]
+ fn standalone_usage_estimates_are_nonzero() {
+ let (request, _) = build_search_request(&request(), "gpt-5.6-luna", None).unwrap();
+ let response = SearchResponse {
+ encrypted_output: None,
+ output: "search output".to_string(),
+ results: None,
+ };
+
+ assert!(search_request_input_tokens(&request) > 0);
+ assert!(search_response_output_tokens(&response) > 0);
+ }
+
+ #[test]
+ fn streamed_response_matches_claude_server_tool_shape() {
+ let response = SearchResponse {
+ encrypted_output: Some("opaque".to_string()),
+ output: "See [OpenAI](https://openai.com).".to_string(),
+ results: Some(vec![json!({
+ "type": "text_result",
+ "ref_id": "turn0search0",
+ "url": "https://openai.com",
+ "title": "OpenAI"
+ })]),
+ };
+ let response = anthropic_search_response(
+ &response,
+ "Codex standalone search",
+ "msg_test",
+ "claude-haiku-4-5-20251001",
+ true,
+ 12,
+ None,
+ );
+ let runtime = tokio::runtime::Runtime::new().unwrap();
+ let body = runtime.block_on(axum::body::to_bytes(response.into_body(), usize::MAX));
+ let events = parse_sse_events(&body.unwrap());
+ let payloads: Vec<Value> = events
+ .iter()
+ .filter_map(|event| serde_json::from_str(&event.data).ok())
+ .collect();
+ assert!(payloads.iter().any(|payload| {
+ payload
+ .pointer("/content_block/type")
+ .and_then(Value::as_str)
+ == Some("server_tool_use")
+ }));
+ assert!(payloads.iter().any(|payload| {
+ payload
+ .pointer("/content_block/type")
+ .and_then(Value::as_str)
+ == Some("web_search_tool_result")
+ }));
+ assert!(payloads.iter().any(|payload| {
+ payload
+ .pointer("/usage/server_tool_use/web_search_requests")
+ .and_then(Value::as_u64)
+ == Some(1)
+ }));
+ }
+}