Release v0.6.3 Claude Code web compatibility

Author: Eunho Jung

README.md

@@ -410,7 +410,7 @@ GPT-5.6 requests can instead use the public Responses-shaped object:
 - Responses Lite uses `all_turns` as the Codex wire default. An explicitly different context is rejected instead of silently overwritten; use `responses_lite: false` when the backend route supports classic Responses and another context is required.
 - Remote compact keeps its existing private Codex `reasoning_effort` field but does not accept public `reasoning.mode` or `reasoning.context`.
 
-Anthropic `thinking` values map as `enabled → high`, `adaptive → medium`, and `disabled → none`. Claude Code's `output_config.effort` takes precedence over the adaptive default and supports `low`, `medium`, `high`, `xhigh`, and `max`. The supported reasoning context and verbosity extensions are also available on `/v1/messages`, image generation, and inspection requests; Pro and non-null public cache policy/breakpoints or `safety_identifier` fail explicitly on the private Codex provider.
+Anthropic `thinking` values map as `enabled → high`, `adaptive → medium`, and `disabled → none`. Claude Code's `output_config.effort` takes precedence over adaptive or enabled thinking and supports `low`, `medium`, `high`, `xhigh`, and `max`. Call-level `thinking.disabled` takes precedence over ambient `output_config.effort`, so Claude Code WebSearch/WebFetch auxiliary calls use `none` instead of failing the compatibility check with HTTP 400. The supported reasoning context and verbosity extensions are also available on `/v1/messages`, image generation, and inspection requests; Pro and non-null public cache policy/breakpoints or `safety_identifier` fail explicitly on the private Codex provider.
 
 The pinned official Codex HTTP request has no `stop` field. Omitted, `null`, and empty stop values are omitted from the private request; any non-empty OpenAI `stop` or Anthropic `stop_sequences` value returns HTTP 400 before the private transport starts.
 
@@ -613,9 +613,13 @@ The `/v1/messages` endpoint implements the Anthropic Messages gateway shape used
 Start the proxy first. `CODEX_AS_API_MODEL` is the fallback used when Claude Code sends a built-in Anthropic model name:
 
 ```bash
-CODEX_AS_API_MODEL=gpt-5.6-terra codex-as-api
+CODEX_AS_API_MODEL=gpt-5.6-terra \
+CODEX_AS_API_RESPONSES_LITE=off \
+codex-as-api
 ```
 
+`CODEX_AS_API_RESPONSES_LITE=off` is required for Claude Code hosted WebSearch on GPT-5.6. Official Codex Responses Lite uses a client-side standalone `web.run` tool, while this gateway receives Anthropic's hosted `web_search` declaration and has no standalone executor; classic Responses preserves that hosted tool. WebFetch does not use a hosted Responses tool, but still needs the disabled-thinking precedence fix when process-level effort is enabled.
+
 To keep the built-in Fable, Opus, Sonnet, and Haiku rows and append one GPT row, launch the GPT-routed Claude Code process with these variables:
 
 ```bash
@@ -686,7 +690,7 @@ The provider handles:
 ## Release & package publishing
 
 - Bump versions in `pyproject.toml`, `src/codex_as_api/__init__.py`, `src/codex_as_api/server.py`, `ts/package.json`, `ts/package-lock.json`, `rust/Cargo.toml`, and `rust/Cargo.lock`.
-- Publish a GitHub Release such as `v0.6.2` from the matching commit.
+- Publish a GitHub Release such as `v0.6.3` from the matching commit.
 - The manually-dispatched `Publish npm packages` workflow builds/tests the TypeScript package, runs `npm pack --dry-run`, publishes `codex-as-api` to npmjs when `NPM_TOKEN` is configured, and publishes `@eunho-j/codex-as-api` to GitHub Packages with `GITHUB_TOKEN`.
 
 Publishing to npmjs requires an authenticated npm session (`npm login` beforehand; `npm whoami` should succeed). From the repository root, the publish itself is one command:
@@ -729,6 +733,14 @@ npm test
 
 ## Release Notes
 
+### v0.6.3
+
+- Accept Claude Code auxiliary requests that combine ambient `output_config.effort` with call-level `thinking.disabled`.
+- Give explicit disabled thinking precedence and send Codex reasoning effort `none` instead of returning HTTP 400.
+- Document and test `CODEX_AS_API_RESPONSES_LITE=off` for Claude Code hosted WebSearch on GPT-5.6; WebFetch needs no Responses Lite override.
+- Preserve fail-loudly validation for invalid effort values and unsupported `output_config` fields.
+- Add Python, TypeScript, and Rust adapter regressions, streamed `/v1/messages` coverage, and a `/count_tokens` regression for the WebSearch/WebFetch request shape.
+
 ### v0.6.2
 
 - Fix `/v1/messages/count_tokens` overcounting that could trigger Claude Code autocompaction on every turn.

RELEASES.md

@@ -1,5 +1,20 @@
 # Release Notes
 
+## v0.6.3
+
+### Claude Code WebSearch/WebFetch auxiliary calls
+
+- Fix HTTP 400 responses when a Claude Code session with ambient effort sends a WebSearch/WebFetch auxiliary request containing both `output_config.effort` and call-level `thinking: {"type":"disabled"}`.
+- Give explicit disabled thinking precedence over valid ambient effort and forward Codex reasoning effort `none` across Python, TypeScript, and Rust.
+- Require and document `CODEX_AS_API_RESPONSES_LITE=off` for Claude Code hosted WebSearch on GPT-5.6 because official Responses Lite relies on a standalone `web.run` executor; WebFetch does not require this override.
+- Continue rejecting empty, non-string, or unsupported effort values and unsupported `output_config` fields rather than silently discarding malformed requests.
+
+### Validation
+
+- Adapter tests cover every valid Claude Code effort value paired with disabled thinking while retaining invalid-value failures.
+- Streamed `/v1/messages` tests across all three runtimes and a local `/count_tokens` test reproduce the Claude Code 2.1.209 request shape and prove provider-backed requests reach the classic Codex wire with reasoning effort `none`.
+- A real GPT-5.6 Sol Codex OAuth WebSearch completed with HTTP 200 and structured `server_tool_use`, `web_search_tool_result`, and terminal SSE events.
+
 ## v0.6.2
 
 ### Claude Code count_tokens autocompact fix

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codex-as-api"
-version = "0.6.2"
+version = "0.6.3"
 description = "Use ChatGPT/Codex OAuth as a local OpenAI-compatible API server."
 readme = "README.md"
 license = { text = "Apache-2.0" }

rust/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "codex-as-api"
-version = "0.6.2"
+version = "0.6.3"
 edition = "2021"
 
 [[bin]]

rust/Cargo.toml

@@ -523,13 +523,14 @@ fn convert_reasoning_effort(body: &Value) -> Result<Option<String>, String> {
         Some(Value::String(effort)) if effort.trim().is_empty() => {
             Err("output_config.effort must be a non-empty string when provided".to_string())
         }
-        Some(Value::String(_)) if thinking_effort.as_deref() == Some("none") => {
-            Err("output_config.effort cannot be used when thinking.type is disabled".to_string())
-        }
         Some(Value::String(effort))
             if matches!(effort.as_str(), "low" | "medium" | "high" | "xhigh" | "max") =>
         {
-            Ok(Some(effort.clone()))
+            if thinking_effort.as_deref() == Some("none") {
+                Ok(Some("none".to_string()))
+            } else {
+                Ok(Some(effort.clone()))
+            }
         }
         Some(Value::String(_)) => {
             Err("output_config.effort must be one of: low, medium, high, xhigh, max".to_string())
@@ -1895,16 +1896,45 @@ mod tests {
     }
 
     #[test]
-    fn test_output_config_effort_rejects_disabled_thinking() {
-        let body = json!({
-            "messages": [],
-            "thinking": {"type": "disabled"},
-            "output_config": {"effort": "high"},
-        });
-        assert_eq!(
-            anthropic_request_to_internal(&body).unwrap_err(),
-            "output_config.effort cannot be used when thinking.type is disabled"
-        );
+    fn test_disabled_thinking_precedes_output_config_effort() {
+        for effort in ["low", "medium", "high", "xhigh", "max"] {
+            let body = json!({
+                "messages": [],
+                "thinking": {"type": "disabled"},
+                "output_config": {"effort": effort},
+            });
+            let (_, _, _, _, converted, _) = anthropic_request_to_internal(&body).unwrap();
+            assert_eq!(converted, Some("none".to_string()));
+        }
+    }
+
+    #[test]
+    fn test_output_config_effort_is_validated_before_disabled_thinking_precedence() {
+        let invalid_efforts = [
+            (
+                json!(""),
+                "output_config.effort must be a non-empty string when provided",
+            ),
+            (
+                json!(42),
+                "output_config.effort must be a non-empty string when provided",
+            ),
+            (
+                json!("ultra"),
+                "output_config.effort must be one of: low, medium, high, xhigh, max",
+            ),
+        ];
+        for (effort, expected_error) in invalid_efforts {
+            let body = json!({
+                "messages": [],
+                "thinking": {"type": "disabled"},
+                "output_config": {"effort": effort},
+            });
+            assert_eq!(
+                anthropic_request_to_internal(&body).unwrap_err(),
+                expected_error
+            );
+        }
     }
 
     #[test]

rust/src/anthropic_adapter.rs

@@ -2867,6 +2867,110 @@ mod tests {
         std::fs::remove_file(auth_path).unwrap();
     }
 
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    async fn anthropic_stream_web_search_uses_disabled_thinking_over_ambient_effort() {
+        let (upstream_url, recording, upstream_handle) = start_recording_upstream().await;
+        recording.set_response_output(vec![
+            json!({
+                "type": "web_search_call",
+                "id": "search-1",
+                "status": "completed",
+                "action": {
+                    "type": "search",
+                    "query": "Codex release notes",
+                    "sources": [{
+                        "type": "url",
+                        "url": "https://example.com/codex",
+                        "title": "Codex release notes"
+                    }]
+                }
+            }),
+            json!({
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": "Search complete."}]
+            }),
+        ]);
+        let (api_url, auth_path, api_handle) = start_api_server(
+            &upstream_url,
+            "gpt-5.6-sol",
+            test_codex_config(Some("high"), None, None),
+        )
+        .await;
+
+        let response = reqwest::Client::new()
+            .post(format!("{api_url}/v1/messages"))
+            .json(&json!({
+                "model": "claude-sonnet-4-5",
+                "max_tokens": 100,
+                "system": "Use the available tools.",
+                "messages": [{"role": "user", "content": "Search the web."}],
+                "tools": [{"type": "web_search_20250305", "name": "web_search"}],
+                "stream": true,
+                "thinking": {"type": "disabled"},
+                "output_config": {"effort": "high"},
+                "responses_lite": false
+            }))
+            .send()
+            .await
+            .unwrap();
+        assert_eq!(response.status(), reqwest::StatusCode::OK);
+        assert_eq!(
+            response
+                .headers()
+                .get(CONTENT_TYPE)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "text/event-stream"
+        );
+        let mut pending = response.text().await.unwrap();
+        let mut events = Vec::new();
+        parse_anthropic_sse_blocks(&mut pending, &mut events);
+        assert!(pending.is_empty());
+        assert_eq!(events.first().unwrap().0, "message_start");
+        assert_eq!(events.last().unwrap().0, "message_stop");
+        assert_eq!(events.last().unwrap().1["type"], json!("message_stop"));
+
+        let server_tool_use = events
+            .iter()
+            .find(|(event, data)| {
+                event == "content_block_start"
+                    && data["content_block"]["type"] == json!("server_tool_use")
+            })
+            .unwrap();
+        assert_eq!(server_tool_use.1["content_block"]["name"], "web_search");
+        let search_result = events
+            .iter()
+            .find(|(event, data)| {
+                event == "content_block_start"
+                    && data["content_block"]["type"] == json!("web_search_tool_result")
+            })
+            .unwrap();
+        assert_eq!(
+            search_result.1["content_block"]["tool_use_id"],
+            server_tool_use.1["content_block"]["id"]
+        );
+
+        let requests = recording.requests();
+        assert_eq!(requests.len(), 1);
+        assert_eq!(requests[0].endpoint, RecordedEndpoint::Responses);
+        assert_eq!(requests[0].body["model"], json!("gpt-5.6-sol"));
+        assert_eq!(requests[0].body["reasoning"]["effort"], json!("none"));
+        assert_eq!(
+            requests[0].body["tools"],
+            json!([{"type": "web_search", "external_web_access": true}])
+        );
+        assert!(requests[0]
+            .headers
+            .get(crate::model_capabilities::LITE_HEADER_NAME)
+            .is_none());
+
+        api_handle.abort();
+        upstream_handle.abort();
+        std::fs::remove_file(auth_path).unwrap();
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
     async fn anthropic_route_preserves_url_images_and_tool_error_results_on_provider_wire() {
         let (upstream_url, recording, upstream_handle) = start_recording_upstream().await;
@@ -3025,10 +3129,6 @@ mod tests {
             json!({"output_config": {"effort": "ultra"}}),
             json!({"output_config": {"effort": "low", "experimental": true}}),
             json!({"output_config": {"task_budget": {"type": "tokens", "total": 20_000}}}),
-            json!({
-                "thinking": {"type": "disabled"},
-                "output_config": {"effort": "high"}
-            }),
             json!({
                 "reasoning_effort": "high",
                 "output_config": {"effort": "low"}
@@ -3672,7 +3772,7 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn anthropic_stream_rejects_lite_hosted_web_search_before_sse_headers() {
+    async fn anthropic_stream_rejects_auto_and_on_lite_hosted_web_search_before_sse_headers() {
         let (upstream_url, recording, upstream_handle) = start_recording_upstream().await;
         let (api_url, auth_path, api_handle) = start_api_server(
             &upstream_url,
@@ -3681,34 +3781,36 @@ mod tests {
         )
         .await;
 
-        let response = reqwest::Client::new()
-            .post(format!("{api_url}/v1/messages"))
-            .json(&json!({
-                "model": "claude-sonnet-4-5",
-                "system": "Use the available tools.",
-                "messages": [{"role": "user", "content": "Search the web."}],
-                "tools": [{"type": "web_search_20250305", "name": "web_search"}],
-                "stream": true,
-                "responses_lite": "auto",
-                "max_tokens": 100
-            }))
-            .send()
-            .await
-            .unwrap();
+        for responses_lite in ["auto", "on"] {
+            let response = reqwest::Client::new()
+                .post(format!("{api_url}/v1/messages"))
+                .json(&json!({
+                    "model": "claude-sonnet-4-5",
+                    "system": "Use the available tools.",
+                    "messages": [{"role": "user", "content": "Search the web."}],
+                    "tools": [{"type": "web_search_20250305", "name": "web_search"}],
+                    "stream": true,
+                    "responses_lite": responses_lite,
+                    "max_tokens": 100
+                }))
+                .send()
+                .await
+                .unwrap();
 
-        assert_eq!(response.status(), reqwest::StatusCode::BAD_REQUEST);
-        assert_eq!(
-            response
-                .headers()
-                .get(CONTENT_TYPE)
-                .unwrap()
-                .to_str()
-                .unwrap(),
-            "application/json"
-        );
-        let body: Value = response.json().await.unwrap();
-        assert_eq!(body["type"], json!("error"));
-        assert_eq!(body["error"]["type"], json!("invalid_request_error"));
+            assert_eq!(response.status(), reqwest::StatusCode::BAD_REQUEST);
+            assert_eq!(
+                response
+                    .headers()
+                    .get(CONTENT_TYPE)
+                    .unwrap()
+                    .to_str()
+                    .unwrap(),
+                "application/json"
+            );
+            let body: Value = response.json().await.unwrap();
+            assert_eq!(body["type"], json!("error"));
+            assert_eq!(body["error"]["type"], json!("invalid_request_error"));
+        }
         assert!(recording.requests().is_empty());
 
         api_handle.abort();

rust/src/server.rs

@@ -1,3 +1,3 @@
 """codex-as-api: Use ChatGPT/Codex OAuth as a local OpenAI-compatible API server."""
 
-__version__ = "0.6.2"
+__version__ = "0.6.3"

src/codex_as_api/__init__.py

@@ -341,13 +341,19 @@ def _convert_reasoning_effort(thinking: dict[str, Any] | None, output_config: ob
             raise ValueError("output_config.task_budget is not supported by the Codex OAuth backend")
         raw_effort = output_config.get("effort")
         if raw_effort is not None:
-            if raw_effort not in {"low", "medium", "high", "xhigh", "max"}:
+            if not isinstance(raw_effort, str) or raw_effort not in {
+                "low",
+                "medium",
+                "high",
+                "xhigh",
+                "max",
+            }:
                 raise ValueError("output_config.effort must be one of: low, medium, high, xhigh, max")
             output_effort = raw_effort
 
     thinking_effort = _convert_thinking(thinking)
-    if thinking_effort == "none" and output_effort is not None:
-        raise ValueError("output_config.effort cannot be represented together with thinking.disabled")
+    if thinking_effort == "none":
+        return "none"
     return output_effort or thinking_effort