codex-as-api 0.8.1__tar.gz → 0.8.3__tar.gz

{codex_as_api-0.8.1 → codex_as_api-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codex-as-api
-Version: 0.8.1
+Version: 0.8.3
 Summary: Use ChatGPT/Codex OAuth as a local OpenAI-compatible API server.
 Project-URL: Homepage, https://github.com/Eunho-J/codex-as-api
 Project-URL: Repository, https://github.com/Eunho-J/codex-as-api
@@ -284,11 +284,9 @@ it; continuation uses the complete provider Response items saved behind
 
 ### `POST /v1/messages`
 
-Claude Code compatibility endpoint using the Anthropic Messages shape. It supports streaming (`stream: true`) and non-streaming only for requests carrying one valid `x-claude-code-session-id` header. A live Codex model ID routes directly. A recognized `claude-*` facade ID requires an explicit `CODEX_AS_API_MODEL` or Codex config model that is present in the same fresh catalog; it is not silently routed to a default. Other unknown IDs fail. The response preserves the client-supplied model name.
+Anthropic Messages compatibility endpoint for any client, including Claude Code and Scheherazade. It supports streaming (`stream: true`) and non-streaming without a client-identification header. A live Codex model ID routes directly. A `claude-*` facade ID uses the configured Codex backend model, or the authenticated catalog default when no backend model is configured. Other unknown IDs fail. The response preserves the client-supplied model name.
 
-This compatibility endpoint is scoped to Claude Code requests. The proxy accepts
-and strips the non-forwarded `max_tokens` and `cache_control` compatibility
-fields only when one valid `x-claude-code-session-id` header is present.
+`max_tokens` is a required positive compatibility hint: the private Codex OAuth transport does not expose a matching output-token cap. Valid ephemeral `cache_control` hints are accepted and stripped for every client; their TTL and breakpoint semantics are not forwarded. An optional `x-claude-code-session-id` provides stable hashed cache affinity, not permission to use the endpoint. `metadata.user_id` is accepted as client metadata and is not forwarded.
 
 ```bash
 curl http://localhost:18080/v1/messages \
@@ -325,7 +323,7 @@ curl -N http://localhost:18080/v1/messages \
   }'
 ```
 
-Codex reasoning summaries are not Anthropic signed-thinking blocks. A non-streaming response exposes real upstream reasoning only through the top-level `codex_reasoning` proxy extension. A stream emits `event: codex_reasoning_delta` with `type: "codex_reasoning_delta"`. The proxy never fabricates `thinking`, `thinking_delta`, or `signature_delta` data.
+With `thinking.display: "summarized"` (the enabled/adaptive default), real Codex reasoning summaries are returned as unsigned Anthropic `thinking` blocks and streamed `thinking_delta` content, alongside the existing `codex_reasoning` / `codex_reasoning_delta` extensions. `display: "omitted"` and disabled thinking suppress reasoning output. No Anthropic signature is fabricated. Valid thinking blocks in replayed assistant history are checked and stripped before Codex input; ordinary text and tool calls are preserved.
 
 Hosted Anthropic `web_search` declarations are rejected with HTTP 400 on
 Messages, token-counting, and compact requests. OpenAI Responses cannot supply
@@ -345,10 +343,7 @@ the completion is nonterminal or final usage is absent; a stream that has
 already started emits an Anthropic `error` event and never emits a successful
 `message_stop`. The final response includes every required usage field, using
 `null` only where the Anthropic type permits it, plus required container,
-citation, context-management, and direct-caller fields. To preserve Claude
-Code's realtime behavior, `message_start` is sent immediately without guessed
-input-token counts; this narrow stream-start shape is Claude Code compatibility
-behavior, not generic Anthropic API parity.
+citation, context-management, and direct-caller fields. `message_start` is sent immediately with numeric zero counters in `message.usage`; these are provisional, not measured counts. The final `message_delta.usage` replaces them with authoritative cumulative totals, including disjoint cache buckets.
 
 Generated `tool_use` blocks with `caller: {"type":"direct"}` and empty
 assistant content arrays can be replayed through the request adapter. Malformed,
@@ -364,9 +359,9 @@ different jobs:
 | `client_metadata.session_id` | Forwarded to Codex, used as the default `prompt_cache_key`, and required when Codex metadata mode is enabled | Not used or forwarded |
 | `client_metadata.thread_id` | Codex metadata thread identity; defaults to `session_id` for a root request and preserves an explicit child thread | Not used or synthesized |
 | `prompt_cache_key` | Explicit value wins; otherwise a non-empty `client_metadata.session_id` is used; otherwise omitted | Optional proxy extension; explicit value wins, otherwise the Claude Code session header is hashed |
-| `x-claude-code-session-id` | Not used | Required for the non-forwarded `max_tokens` and `cache_control` compatibility fields; its exact value also supplies hashed cache affinity |
+| `x-claude-code-session-id` | Not used | Optional cache-affinity header; its exact value supplies a hashed default key |
 | `previous_response_id` | Resolves a known entry from the 256-chain process-local history and replays full input/output over HTTP; never forwarded | Non-null values return Anthropic-style HTTP 400 because normal Messages is stateless |
-| `cache_control` | Not an OpenAI Chat control | Accepted only with the Claude Code session header, validated, then stripped before Codex transport |
+| `cache_control` | Not an OpenAI Chat control | Accepted for every client, validated, then stripped before Codex transport |
 
 Anthropic `cache_control` is a cache-boundary annotation, not an identifier.
 This proxy accepts only `{"type":"ephemeral"}` with optional `ttl: "5m"` or
@@ -378,15 +373,13 @@ responses do not expose the Chat-only `response_id`. The custom
 `previous_response_id` support.
 
 The Anthropic type permits `cache_control: null`; the proxy treats that exact
-value as omission. A non-null cache-control object is validated in full and is
-accepted only on a Claude Code request.
+value as omission. A non-null cache-control object is validated in full for every client.
 
 ### `POST /v1/messages/count_tokens`
 
-Anthropic-compatible token counting helper. Codex OAuth does not expose a count-only endpoint equivalent to Anthropic's native API, so this route counts text locally and returns context-window metadata for the effective backend model. Normalized model-visible messages, tool calls, tool-result metadata, reasoning, and tool schemas are counted once. Request-envelope fields and the approved Claude Code `max_tokens` compatibility hint are excluded; other unsupported generation controls fail instead of becoming no-ops. Image inputs use a separate fixed estimate so inline base64 data is not counted as text.
+Anthropic-compatible token counting helper. Codex OAuth does not expose a count-only endpoint equivalent to Anthropic's native API, so this route counts text locally and returns context-window metadata for the effective backend model. Normalized model-visible messages, tool calls, tool-result metadata, reasoning, and tool schemas are counted once. Request-envelope fields and the `max_tokens` compatibility hint are excluded; other unsupported generation controls fail instead of becoming no-ops. Image inputs use a separate fixed estimate so inline base64 data is not counted as text.
 
-`max_tokens` and `cache_control` remain Claude Code-only compatibility hints on
-this route and require `x-claude-code-session-id` when present.
+`max_tokens` and `cache_control` are optional client-neutral compatibility hints on this route; no Claude Code header is required.
 
 Text estimation uses a bundled port of official `tiktoken` `o200k_base` `encode_ordinary`: the same Unicode pre-tokenization regex, byte-pair merge algorithm, and merge-rank data are implemented in Python, TypeScript, and Rust. It is a local estimator, not model metadata and not a substitute for a provider count API. The project does not depend on a `tiktoken` package or download encoding data at runtime. The last upstream synchronization check was **2026-07-14**, against [`tiktoken` 0.13.0 at `08a5f3b`](https://github.com/openai/tiktoken/tree/08a5f3b2c987ada4fc5aa1f16c643c203fa8acaa); the bundled rank file SHA-256 is `446a9538cb6c348e3516120d7c08b09f57c36495e2acfffe59a5bf8b0cfb1a2d`.
 
@@ -405,7 +398,7 @@ curl http://localhost:18080/v1/messages/count_tokens \
 
 ### `POST /v1/messages/compact`
 
-Anthropic-compatible alias for remote conversation compaction. Accepts Anthropic Messages-shaped bodies and returns compacted checkpoint content. Live GPT model IDs select the matching backend model, and Claude Code effort and Fast Mode controls use the same mappings as `/v1/messages`. Its required non-forwarded `max_tokens` and any `cache_control` hints require one valid `x-claude-code-session-id` header.
+Anthropic-compatible alias for remote conversation compaction. Accepts Anthropic Messages-shaped bodies and returns compacted checkpoint content. Live GPT model IDs select the matching backend model, and Claude Code effort and Fast Mode controls use the same mappings as `/v1/messages`. Its required non-forwarded `max_tokens` and any valid `cache_control` hints are accepted for every client; the optional Claude Code session header only supplies cache affinity.
 
 ### `POST /v1/images/generations`
 
@@ -545,7 +538,7 @@ Requests can instead use the Responses-shaped effort/context 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 adaptive or enabled thinking and supports `low`, `medium`, `high`, `xhigh`, and `max`. Call-level `thinking.disabled` takes precedence over ambient `output_config.effort` for representable client-side auxiliary calls such as WebFetch; hosted Anthropic WebSearch is rejected before transport because its lifecycle cannot be translated losslessly. The supported reasoning context and verbosity extensions are also available on `/v1/messages`, image generation, and inspection requests; Pro, non-null public cache policy/breakpoints, and any supplied `safety_identifier` fail explicitly on the private Codex provider.
+Anthropic `thinking` values map as `enabled → high` and `adaptive → medium`. Disabled thinking selects `none` when available, otherwise the lowest supported catalog effort, and suppresses reasoning output; it does not claim to eliminate a model's internal reasoning. `output_config.effort` takes precedence over adaptive or enabled thinking and supports `low`, `medium`, `high`, `xhigh`, and `max`. Call-level disabled thinking takes precedence over ambient `output_config.effort` for auxiliary calls such as WebFetch. Explicit unsupported effort requests still fail. Hosted Anthropic WebSearch is rejected because its lifecycle cannot be translated losslessly. The supported reasoning context and verbosity extensions are also available on `/v1/messages`, image generation, and inspection requests; Pro, non-null public cache policy/breakpoints, and any supplied `safety_identifier` fail explicitly on the private Codex provider.
 
 Anthropic's `JSONOutputFormat` carries a schema but no name. When Claude Code
 sends that official shape, the proxy follows pinned Codex 0.153.3 and supplies
@@ -819,9 +812,9 @@ ANTHROPIC_BASE_URL=http://127.0.0.1:18080 ANTHROPIC_AUTH_TOKEN=unused \
   claude --model gpt-5.6-luna --effort medium
 ```
 
-Live Codex IDs are sent to the matching backend model. Built-in Claude/Fable/Opus/Sonnet/Haiku IDs are not Codex models, so recognized `claude-*` IDs require the explicitly configured `CODEX_AS_API_MODEL`; the proxy preserves the selected client name in the Anthropic response.
+Live Codex IDs are sent to the matching backend model. Built-in Claude/Fable/Opus/Sonnet/Haiku IDs are not Codex models, so recognized `claude-*` IDs use the configured Codex model or authenticated catalog default; the proxy preserves the selected client name in the Anthropic response.
 
-`ANTHROPIC_BASE_URL` applies to the whole Claude Code process. Therefore the built-in rows remain available in the picker, but they also pass through codex-as-api and use the explicitly configured Codex backend; the rows do not call Anthropic models in that process. To use an actual Anthropic model and GPT in parallel, keep the gateway variables out of global settings, start the GPT process with the inline command above, and start a second process normally:
+`ANTHROPIC_BASE_URL` applies to the whole Claude Code process. Therefore the built-in rows remain available in the picker, but they also pass through codex-as-api and use the configured or catalog-default Codex backend; the rows do not call Anthropic models in that process. To use an actual Anthropic model and GPT in parallel, keep the gateway variables out of global settings, start the GPT process with the inline command above, and start a second process normally:
 
 ```bash
 claude --model sonnet
@@ -831,7 +824,7 @@ If the gateway variables are already in `~/.claude/settings.json`, shell-level `
 
 Claude Code gateway discovery cannot expose raw `gpt-*` IDs because Claude Code filters discovered IDs to `claude*` and `anthropic*`. The official single custom-model option avoids a misleading facade ID. This integration is an Anthropic Messages-compatible bridge; Anthropic explicitly does not support routing Claude Code to non-Claude models through third-party gateways. See the official [model configuration](https://code.claude.com/docs/en/model-config), [gateway connection](https://code.claude.com/docs/en/llm-gateway-connect), and [gateway protocol](https://code.claude.com/docs/en/llm-gateway-protocol) references.
 
-The current bridge accepts Claude Code's exact no-op thinking cleanup (`clear_thinking_20251015` with `keep: "all"`). Context edits that would change history, task budgets, enabled beta tool fields such as `strict` or `defer_loading`, malformed output formats, and unsupported image source types return HTTP 400 because the Codex OAuth transport has no lossless equivalent. Valid base64 and URL image blocks plus `tool_result.is_error` are preserved during translation.
+The bridge accepts Claude Code's no-op thinking cleanup (`clear_thinking_20251015` with `keep: "all"`), validates and ignores boolean `eager_input_streaming`, and accepts `defer_loading: false`. Context edits that would change history, task budgets, enabled strict/deferred tool execution, malformed output formats, and unsupported image source types return HTTP 400. Valid base64 and URL image blocks plus `tool_result.is_error` are preserved during translation.
 
 ## Architecture
 

{codex_as_api-0.8.1 → codex_as_api-0.8.3}/README.md

@@ -250,11 +250,9 @@ it; continuation uses the complete provider Response items saved behind
 
 ### `POST /v1/messages`
 
-Claude Code compatibility endpoint using the Anthropic Messages shape. It supports streaming (`stream: true`) and non-streaming only for requests carrying one valid `x-claude-code-session-id` header. A live Codex model ID routes directly. A recognized `claude-*` facade ID requires an explicit `CODEX_AS_API_MODEL` or Codex config model that is present in the same fresh catalog; it is not silently routed to a default. Other unknown IDs fail. The response preserves the client-supplied model name.
+Anthropic Messages compatibility endpoint for any client, including Claude Code and Scheherazade. It supports streaming (`stream: true`) and non-streaming without a client-identification header. A live Codex model ID routes directly. A `claude-*` facade ID uses the configured Codex backend model, or the authenticated catalog default when no backend model is configured. Other unknown IDs fail. The response preserves the client-supplied model name.
 
-This compatibility endpoint is scoped to Claude Code requests. The proxy accepts
-and strips the non-forwarded `max_tokens` and `cache_control` compatibility
-fields only when one valid `x-claude-code-session-id` header is present.
+`max_tokens` is a required positive compatibility hint: the private Codex OAuth transport does not expose a matching output-token cap. Valid ephemeral `cache_control` hints are accepted and stripped for every client; their TTL and breakpoint semantics are not forwarded. An optional `x-claude-code-session-id` provides stable hashed cache affinity, not permission to use the endpoint. `metadata.user_id` is accepted as client metadata and is not forwarded.
 
 ```bash
 curl http://localhost:18080/v1/messages \
@@ -291,7 +289,7 @@ curl -N http://localhost:18080/v1/messages \
   }'
 ```
 
-Codex reasoning summaries are not Anthropic signed-thinking blocks. A non-streaming response exposes real upstream reasoning only through the top-level `codex_reasoning` proxy extension. A stream emits `event: codex_reasoning_delta` with `type: "codex_reasoning_delta"`. The proxy never fabricates `thinking`, `thinking_delta`, or `signature_delta` data.
+With `thinking.display: "summarized"` (the enabled/adaptive default), real Codex reasoning summaries are returned as unsigned Anthropic `thinking` blocks and streamed `thinking_delta` content, alongside the existing `codex_reasoning` / `codex_reasoning_delta` extensions. `display: "omitted"` and disabled thinking suppress reasoning output. No Anthropic signature is fabricated. Valid thinking blocks in replayed assistant history are checked and stripped before Codex input; ordinary text and tool calls are preserved.
 
 Hosted Anthropic `web_search` declarations are rejected with HTTP 400 on
 Messages, token-counting, and compact requests. OpenAI Responses cannot supply
@@ -311,10 +309,7 @@ the completion is nonterminal or final usage is absent; a stream that has
 already started emits an Anthropic `error` event and never emits a successful
 `message_stop`. The final response includes every required usage field, using
 `null` only where the Anthropic type permits it, plus required container,
-citation, context-management, and direct-caller fields. To preserve Claude
-Code's realtime behavior, `message_start` is sent immediately without guessed
-input-token counts; this narrow stream-start shape is Claude Code compatibility
-behavior, not generic Anthropic API parity.
+citation, context-management, and direct-caller fields. `message_start` is sent immediately with numeric zero counters in `message.usage`; these are provisional, not measured counts. The final `message_delta.usage` replaces them with authoritative cumulative totals, including disjoint cache buckets.
 
 Generated `tool_use` blocks with `caller: {"type":"direct"}` and empty
 assistant content arrays can be replayed through the request adapter. Malformed,
@@ -330,9 +325,9 @@ different jobs:
 | `client_metadata.session_id` | Forwarded to Codex, used as the default `prompt_cache_key`, and required when Codex metadata mode is enabled | Not used or forwarded |
 | `client_metadata.thread_id` | Codex metadata thread identity; defaults to `session_id` for a root request and preserves an explicit child thread | Not used or synthesized |
 | `prompt_cache_key` | Explicit value wins; otherwise a non-empty `client_metadata.session_id` is used; otherwise omitted | Optional proxy extension; explicit value wins, otherwise the Claude Code session header is hashed |
-| `x-claude-code-session-id` | Not used | Required for the non-forwarded `max_tokens` and `cache_control` compatibility fields; its exact value also supplies hashed cache affinity |
+| `x-claude-code-session-id` | Not used | Optional cache-affinity header; its exact value supplies a hashed default key |
 | `previous_response_id` | Resolves a known entry from the 256-chain process-local history and replays full input/output over HTTP; never forwarded | Non-null values return Anthropic-style HTTP 400 because normal Messages is stateless |
-| `cache_control` | Not an OpenAI Chat control | Accepted only with the Claude Code session header, validated, then stripped before Codex transport |
+| `cache_control` | Not an OpenAI Chat control | Accepted for every client, validated, then stripped before Codex transport |
 
 Anthropic `cache_control` is a cache-boundary annotation, not an identifier.
 This proxy accepts only `{"type":"ephemeral"}` with optional `ttl: "5m"` or
@@ -344,15 +339,13 @@ responses do not expose the Chat-only `response_id`. The custom
 `previous_response_id` support.
 
 The Anthropic type permits `cache_control: null`; the proxy treats that exact
-value as omission. A non-null cache-control object is validated in full and is
-accepted only on a Claude Code request.
+value as omission. A non-null cache-control object is validated in full for every client.
 
 ### `POST /v1/messages/count_tokens`
 
-Anthropic-compatible token counting helper. Codex OAuth does not expose a count-only endpoint equivalent to Anthropic's native API, so this route counts text locally and returns context-window metadata for the effective backend model. Normalized model-visible messages, tool calls, tool-result metadata, reasoning, and tool schemas are counted once. Request-envelope fields and the approved Claude Code `max_tokens` compatibility hint are excluded; other unsupported generation controls fail instead of becoming no-ops. Image inputs use a separate fixed estimate so inline base64 data is not counted as text.
+Anthropic-compatible token counting helper. Codex OAuth does not expose a count-only endpoint equivalent to Anthropic's native API, so this route counts text locally and returns context-window metadata for the effective backend model. Normalized model-visible messages, tool calls, tool-result metadata, reasoning, and tool schemas are counted once. Request-envelope fields and the `max_tokens` compatibility hint are excluded; other unsupported generation controls fail instead of becoming no-ops. Image inputs use a separate fixed estimate so inline base64 data is not counted as text.
 
-`max_tokens` and `cache_control` remain Claude Code-only compatibility hints on
-this route and require `x-claude-code-session-id` when present.
+`max_tokens` and `cache_control` are optional client-neutral compatibility hints on this route; no Claude Code header is required.
 
 Text estimation uses a bundled port of official `tiktoken` `o200k_base` `encode_ordinary`: the same Unicode pre-tokenization regex, byte-pair merge algorithm, and merge-rank data are implemented in Python, TypeScript, and Rust. It is a local estimator, not model metadata and not a substitute for a provider count API. The project does not depend on a `tiktoken` package or download encoding data at runtime. The last upstream synchronization check was **2026-07-14**, against [`tiktoken` 0.13.0 at `08a5f3b`](https://github.com/openai/tiktoken/tree/08a5f3b2c987ada4fc5aa1f16c643c203fa8acaa); the bundled rank file SHA-256 is `446a9538cb6c348e3516120d7c08b09f57c36495e2acfffe59a5bf8b0cfb1a2d`.
 
@@ -371,7 +364,7 @@ curl http://localhost:18080/v1/messages/count_tokens \
 
 ### `POST /v1/messages/compact`
 
-Anthropic-compatible alias for remote conversation compaction. Accepts Anthropic Messages-shaped bodies and returns compacted checkpoint content. Live GPT model IDs select the matching backend model, and Claude Code effort and Fast Mode controls use the same mappings as `/v1/messages`. Its required non-forwarded `max_tokens` and any `cache_control` hints require one valid `x-claude-code-session-id` header.
+Anthropic-compatible alias for remote conversation compaction. Accepts Anthropic Messages-shaped bodies and returns compacted checkpoint content. Live GPT model IDs select the matching backend model, and Claude Code effort and Fast Mode controls use the same mappings as `/v1/messages`. Its required non-forwarded `max_tokens` and any valid `cache_control` hints are accepted for every client; the optional Claude Code session header only supplies cache affinity.
 
 ### `POST /v1/images/generations`
 
@@ -511,7 +504,7 @@ Requests can instead use the Responses-shaped effort/context 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 adaptive or enabled thinking and supports `low`, `medium`, `high`, `xhigh`, and `max`. Call-level `thinking.disabled` takes precedence over ambient `output_config.effort` for representable client-side auxiliary calls such as WebFetch; hosted Anthropic WebSearch is rejected before transport because its lifecycle cannot be translated losslessly. The supported reasoning context and verbosity extensions are also available on `/v1/messages`, image generation, and inspection requests; Pro, non-null public cache policy/breakpoints, and any supplied `safety_identifier` fail explicitly on the private Codex provider.
+Anthropic `thinking` values map as `enabled → high` and `adaptive → medium`. Disabled thinking selects `none` when available, otherwise the lowest supported catalog effort, and suppresses reasoning output; it does not claim to eliminate a model's internal reasoning. `output_config.effort` takes precedence over adaptive or enabled thinking and supports `low`, `medium`, `high`, `xhigh`, and `max`. Call-level disabled thinking takes precedence over ambient `output_config.effort` for auxiliary calls such as WebFetch. Explicit unsupported effort requests still fail. Hosted Anthropic WebSearch is rejected because its lifecycle cannot be translated losslessly. The supported reasoning context and verbosity extensions are also available on `/v1/messages`, image generation, and inspection requests; Pro, non-null public cache policy/breakpoints, and any supplied `safety_identifier` fail explicitly on the private Codex provider.
 
 Anthropic's `JSONOutputFormat` carries a schema but no name. When Claude Code
 sends that official shape, the proxy follows pinned Codex 0.153.3 and supplies
@@ -785,9 +778,9 @@ ANTHROPIC_BASE_URL=http://127.0.0.1:18080 ANTHROPIC_AUTH_TOKEN=unused \
   claude --model gpt-5.6-luna --effort medium
 ```
 
-Live Codex IDs are sent to the matching backend model. Built-in Claude/Fable/Opus/Sonnet/Haiku IDs are not Codex models, so recognized `claude-*` IDs require the explicitly configured `CODEX_AS_API_MODEL`; the proxy preserves the selected client name in the Anthropic response.
+Live Codex IDs are sent to the matching backend model. Built-in Claude/Fable/Opus/Sonnet/Haiku IDs are not Codex models, so recognized `claude-*` IDs use the configured Codex model or authenticated catalog default; the proxy preserves the selected client name in the Anthropic response.
 
-`ANTHROPIC_BASE_URL` applies to the whole Claude Code process. Therefore the built-in rows remain available in the picker, but they also pass through codex-as-api and use the explicitly configured Codex backend; the rows do not call Anthropic models in that process. To use an actual Anthropic model and GPT in parallel, keep the gateway variables out of global settings, start the GPT process with the inline command above, and start a second process normally:
+`ANTHROPIC_BASE_URL` applies to the whole Claude Code process. Therefore the built-in rows remain available in the picker, but they also pass through codex-as-api and use the configured or catalog-default Codex backend; the rows do not call Anthropic models in that process. To use an actual Anthropic model and GPT in parallel, keep the gateway variables out of global settings, start the GPT process with the inline command above, and start a second process normally:
 
 ```bash
 claude --model sonnet
@@ -797,7 +790,7 @@ If the gateway variables are already in `~/.claude/settings.json`, shell-level `
 
 Claude Code gateway discovery cannot expose raw `gpt-*` IDs because Claude Code filters discovered IDs to `claude*` and `anthropic*`. The official single custom-model option avoids a misleading facade ID. This integration is an Anthropic Messages-compatible bridge; Anthropic explicitly does not support routing Claude Code to non-Claude models through third-party gateways. See the official [model configuration](https://code.claude.com/docs/en/model-config), [gateway connection](https://code.claude.com/docs/en/llm-gateway-connect), and [gateway protocol](https://code.claude.com/docs/en/llm-gateway-protocol) references.
 
-The current bridge accepts Claude Code's exact no-op thinking cleanup (`clear_thinking_20251015` with `keep: "all"`). Context edits that would change history, task budgets, enabled beta tool fields such as `strict` or `defer_loading`, malformed output formats, and unsupported image source types return HTTP 400 because the Codex OAuth transport has no lossless equivalent. Valid base64 and URL image blocks plus `tool_result.is_error` are preserved during translation.
+The bridge accepts Claude Code's no-op thinking cleanup (`clear_thinking_20251015` with `keep: "all"`), validates and ignores boolean `eager_input_streaming`, and accepts `defer_loading: false`. Context edits that would change history, task budgets, enabled strict/deferred tool execution, malformed output formats, and unsupported image source types return HTTP 400. Valid base64 and URL image blocks plus `tool_result.is_error` are preserved during translation.
 
 ## Architecture
 

{codex_as_api-0.8.1 → codex_as_api-0.8.3}/RELEASES.md

@@ -1,5 +1,50 @@
 # Release Notes
 
+## v0.8.3
+
+### Client-neutral Anthropic compatibility (all runtimes)
+
+- Remove Claude Code identity gates around valid required `max_tokens` and
+  ephemeral `cache_control` hints on Messages, counting and compact routes.
+  These are compatibility hints, not native Codex output caps or cache TTLs;
+  optional Claude session cache affinity remains available.
+- Include provisional zero usage in every initial streaming `message_start`,
+  followed by authoritative final usage with the 0.8.2 disjoint cache accounting.
+- Support summarized thinking as real unsigned thinking blocks/deltas, retaining
+  existing Codex reasoning extensions. Omitted and disabled thinking suppress
+  reasoning output; never fabricate an Anthropic signature.
+- Resolve disabled-derived effort to the model's lowest supported level when
+  `none` is unavailable; explicit effort selection remains capability-checked.
+- Validate and strip replayed assistant thinking history for multi-turn clients.
+  Accept standard `metadata.user_id` and boolean tool streaming hints without
+  inventing backend semantics, and use the live catalog default for unconfigured
+  `claude-*` facade routing.
+
+### Official test quality
+
+- Replace regex diagnostic assertions with literal returned-error checks and
+  remove source-presence, filesystem-permission and worker-liveness oracles.
+  Retain actual input/output, persistence-content and cancellation-state cases.
+- Repair stale client-gate expectations and positive controls, including valid
+  null cache hints, live-default Claude facade routing and mixed thinking/tool
+  replay. Validate all three runtimes with their standard regression runners.
+
+## v0.8.2
+
+### Hotfix: disjoint Anthropic cache usage (all runtimes)
+
+- Correct Anthropic Messages usage in streaming and non-streaming responses:
+  `input_tokens` now excludes both cache reads and reported cache creation,
+  which remain in their separate `cache_read_input_tokens` and
+  `cache_creation_input_tokens` counters. Previously, consumers adding those
+  counters counted cached input twice.
+- Keep OpenAI/Responses totals unchanged. Preserve unknown cache counters as
+  null; subtract only reported cache buckets. Reject impossible cache sums
+  exceeding the upstream input total instead of emitting negative/clamped usage.
+- Add no-cache, partial/full-cache, cache-write, invalid-total and HTTP pipeline
+  regressions across TypeScript, Python and Rust. Example: 100 total input,
+  50 cache read and 25 cache write becomes 25 uncached + 50 read + 25 write.
+
 ## v0.8.1
 
 ### Explicit Ultra Fast selection (all runtimes)

{codex_as_api-0.8.1 → codex_as_api-0.8.3}/pyproject.toml

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

{codex_as_api-0.8.1 → codex_as_api-0.8.3}/src/codex_as_api/__init__.py

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

{codex_as_api-0.8.1 → codex_as_api-0.8.3}/src/codex_as_api/anthropic_adapter.py

@@ -26,6 +26,7 @@ def anthropic_request_to_internal(
     max_tokens: int | None = None,
     output_format: dict[str, Any] | None = None,
     output_config: object = None,
+    metadata: object = None,
 ) -> tuple[
     list[Message], list[ToolSchema] | None, str | dict | None, list[str] | None, str | None, dict[str, Any] | None
 ]:
@@ -37,6 +38,7 @@ def anthropic_request_to_internal(
         raise ValueError("model must be a non-empty string")
     if not isinstance(messages, list) or not messages:
         raise ValueError("messages must be a non-empty array")
+    validate_anthropic_metadata(metadata)
     if stop_sequences is not None and (
         not isinstance(stop_sequences, list) or any(not isinstance(value, str) or not value for value in stop_sequences)
     ):
@@ -274,9 +276,28 @@ def _convert_assistant_message(content: object, out: list[Message]) -> None:
                     arguments=json.dumps(arguments, ensure_ascii=False, separators=(",", ":")),
                 )
             )
+        elif block_type == "thinking":
+            _reject_unknown_fields(
+                block,
+                {"type", "thinking", "signature"},
+                f"Anthropic assistant content block {index}",
+            )
+            thinking_text = block.get("thinking")
+            if not isinstance(thinking_text, str):
+                raise ValueError(f"Anthropic assistant thinking block {index} requires string thinking")
+            signature = block.get("signature")
+            if signature is not None and not isinstance(signature, str):
+                raise ValueError(f"Anthropic assistant thinking block {index} signature must be a string")
+        elif block_type == "redacted_thinking":
+            _reject_unknown_fields(
+                block,
+                {"type", "data"},
+                f"Anthropic assistant content block {index}",
+            )
+            data = block.get("data")
+            if not isinstance(data, str):
+                raise ValueError(f"Anthropic assistant redacted_thinking block {index} requires string data")
         elif block_type in {
-            "thinking",
-            "redacted_thinking",
             "server_tool_use",
             "web_search_tool_result",
         }:
@@ -309,11 +330,17 @@ def _convert_tools(tools: object) -> list[ToolSchema]:
         if "allowed_callers" in tool or "output_schema" in tool:
             raise ValueError(f"Anthropic tool {index} uses Programmatic Tool Calling fields that cannot be preserved")
         if "defer_loading" in tool:
-            raise ValueError(f"Anthropic tool {index} field defer_loading is not supported by the Codex OAuth backend")
+            defer_loading = tool.get("defer_loading")
+            if defer_loading is not None and not isinstance(defer_loading, bool):
+                raise ValueError(f"Anthropic tool {index} defer_loading must be a boolean")
+            if defer_loading is True:
+                raise ValueError(
+                    f"Anthropic tool {index} field defer_loading is not supported by the Codex OAuth backend"
+                )
         for field in ("eager_input_streaming",):
             value = tool.get(field)
-            if value is not None:
-                raise ValueError(f"Anthropic tool {index} field {field} is not supported by the Codex OAuth backend")
+            if value is not None and not isinstance(value, bool):
+                raise ValueError(f"Anthropic tool {index} {field} must be a boolean")
         name = tool.get("name")
         if not isinstance(name, str) or not name:
             raise ValueError(f"Anthropic tool {index} requires a non-empty name")
@@ -449,6 +476,33 @@ def anthropic_parallel_tool_calls(
     return not value
 
 
+def validate_anthropic_metadata(metadata: object) -> None:
+    if metadata is None:
+        return
+    if not isinstance(metadata, dict):
+        raise ValueError("metadata must be an object")
+    _reject_unknown_fields(metadata, {"user_id"}, "metadata")
+    user_id = metadata.get("user_id")
+    if user_id is not None and not isinstance(user_id, str):
+        raise ValueError("metadata.user_id must be a string")
+
+
+def resolve_anthropic_thinking_options(
+    thinking: dict[str, Any] | None,
+    max_tokens: int | None = None,
+) -> tuple[str, str | None, bool]:
+    """Return (thinking_display, reasoning_summary, thinking_disabled) for a thinking object."""
+    if thinking is None:
+        return "summarized", None, False
+    _convert_thinking(thinking, max_tokens)
+    thinking_type = thinking.get("type")
+    if thinking_type == "disabled":
+        return "omitted", "none", True
+    display = "omitted" if thinking.get("display") == "omitted" else "summarized"
+    reasoning_summary = "none" if display == "omitted" else "auto"
+    return display, reasoning_summary, False
+
+
 def _convert_thinking(thinking: dict[str, Any] | None, max_tokens: int | None) -> str | None:
     if thinking is None:
         return None
@@ -458,8 +512,8 @@ def _convert_thinking(thinking: dict[str, Any] | None, max_tokens: int | None) -
     if thinking_type == "enabled":
         _reject_unknown_fields(thinking, {"type", "budget_tokens", "display"}, "thinking")
         display = thinking.get("display")
-        if display is not None and display != "omitted":
-            raise ValueError("thinking.display must be 'omitted' when provided")
+        if display is not None and (not isinstance(display, str) or display not in {"summarized", "omitted"}):
+            raise ValueError("thinking.display must be 'summarized' or 'omitted' when provided")
         budget_tokens = thinking.get("budget_tokens")
         parsed_budget_tokens = as_js_safe_integer(budget_tokens)
         if parsed_budget_tokens is None or parsed_budget_tokens < 1024:
@@ -470,8 +524,8 @@ def _convert_thinking(thinking: dict[str, Any] | None, max_tokens: int | None) -
     if thinking_type == "adaptive":
         _reject_unknown_fields(thinking, {"type", "display"}, "thinking")
         display = thinking.get("display")
-        if display is not None and display != "omitted":
-            raise ValueError("thinking.display must be 'omitted' when provided")
+        if display is not None and (not isinstance(display, str) or display not in {"summarized", "omitted"}):
+            raise ValueError("thinking.display must be 'summarized' or 'omitted' when provided")
         return "medium"
     if thinking_type == "disabled":
         _reject_unknown_fields(thinking, {"type"}, "thinking")
@@ -648,11 +702,18 @@ def internal_response_to_anthropic(
     response: AssistantResponse,
     model: str,
     request_id: str,
+    *,
+    thinking_display: str = "summarized",
 ) -> dict[str, Any]:
+    if thinking_display not in {"summarized", "omitted"}:
+        raise ValueError("thinking_display must be 'summarized' or 'omitted'")
     content: list[dict[str, Any]] = []
 
     _reject_unrepresentable_response_events(response.raw)
 
+    if thinking_display == "summarized" and response.reasoning_content:
+        content.append({"type": "thinking", "thinking": response.reasoning_content})
+
     if response.content:
         content.append({"type": "text", "text": response.content, "citations": None})
 
@@ -688,7 +749,7 @@ def internal_response_to_anthropic(
         "stop_sequence": None,
         "usage": usage_dict,
     }
-    if response.reasoning_content:
+    if thinking_display == "summarized" and response.reasoning_content:
         result["codex_reasoning"] = response.reasoning_content
     return result
 
@@ -718,13 +779,23 @@ def _reject_unrepresentable_response_events(raw: dict | None) -> None:
         )
 
 
+def _uncached_input_tokens(total: int, cache_read: int | None, cache_write: int | None) -> int:
+    # OpenAI totals include cache buckets; Anthropic exposes disjoint counters.
+    cached = (cache_read or 0) + (cache_write or 0)
+    if cached > total:
+        raise ChatGPTOAuthProtocolError("usage cache tokens must not exceed input_tokens")
+    return total - cached
+
+
 def _anthropic_usage_from_internal(usage: Usage) -> dict[str, Any]:
     return {
         "cache_creation": None,
         "cache_creation_input_tokens": usage.cache_write_tokens,
         "cache_read_input_tokens": usage.cached_tokens,
         "inference_geo": None,
-        "input_tokens": usage.prompt_tokens,
+        "input_tokens": _uncached_input_tokens(
+            usage.prompt_tokens, usage.cached_tokens, usage.cache_write_tokens
+        ),
         "iterations": None,
         "output_tokens": usage.completion_tokens,
         "server_tool_use": None,
@@ -790,10 +861,14 @@ def anthropic_stream_adapter(
     event_stream: Iterator[dict[str, Any]],
     model: str,
     request_id: str,
+    *,
+    thinking_display: str = "summarized",
 ) -> Iterator[str]:
     """Convert provider chat_stream events into Anthropic SSE strings."""
+    if thinking_display not in {"summarized", "omitted"}:
+        raise ValueError("thinking_display must be 'summarized' or 'omitted'")
     yield _message_start_sse(model, request_id)
-    yield from _render_anthropic_stream_events(event_stream)
+    yield from _render_anthropic_stream_events(event_stream, thinking_display=thinking_display)
 
 
 def _message_start_sse(model: str, request_id: str) -> str:
@@ -811,6 +886,13 @@ def _message_start_sse(model: str, request_id: str) -> str:
                 "context_management": None,
                 "stop_reason": None,
                 "stop_sequence": None,
+                # Provisional; message_delta carries authoritative cumulative usage.
+                "usage": {
+                    "input_tokens": 0,
+                    "output_tokens": 0,
+                    "cache_read_input_tokens": 0,
+                    "cache_creation_input_tokens": 0,
+                },
             },
         },
     )
@@ -910,7 +992,7 @@ def _anthropic_usage_from_provider(usage: Any) -> dict[str, Any]:
     out: dict[str, Any] = {
         "cache_creation_input_tokens": cache_write,
         "cache_read_input_tokens": cache_read,
-        "input_tokens": input_tokens,
+        "input_tokens": _uncached_input_tokens(input_tokens, cache_read, cache_write),
         "iterations": None,
         "output_tokens": output_tokens,
         "server_tool_use": server_tool_use,
@@ -934,7 +1016,11 @@ def _validate_usage_counter_object(
             raise ChatGPTOAuthProtocolError(f"provider usage {field}.{name} must be a non-negative integer")
 
 
-def _render_anthropic_stream_events(events: Iterator[dict[str, Any]]) -> Iterator[str]:
+def _render_anthropic_stream_events(
+    events: Iterator[dict[str, Any]],
+    *,
+    thinking_display: str = "summarized",
+) -> Iterator[str]:
     block_index = 0
     current_block: str | None = None
     has_tool_calls = False
@@ -948,6 +1034,29 @@ def _render_anthropic_stream_events(events: Iterator[dict[str, Any]]) -> Iterato
             text = event.get("text")
             if not isinstance(text, str):
                 raise ChatGPTOAuthProtocolError(f"provider {typ} event requires string text")
+            if thinking_display == "omitted":
+                continue
+            if current_block != "thinking":
+                if current_block is not None:
+                    yield _sse("content_block_stop", {"type": "content_block_stop", "index": block_index})
+                    block_index += 1
+                yield _sse(
+                    "content_block_start",
+                    {
+                        "type": "content_block_start",
+                        "index": block_index,
+                        "content_block": {"type": "thinking", "thinking": ""},
+                    },
+                )
+                current_block = "thinking"
+            yield _sse(
+                "content_block_delta",
+                {
+                    "type": "content_block_delta",
+                    "index": block_index,
+                    "delta": {"type": "thinking_delta", "thinking": text},
+                },
+            )
             yield _sse(
                 "codex_reasoning_delta",
                 {

{codex_as_api-0.8.1 → codex_as_api-0.8.3}/src/codex_as_api/model_capabilities.py

@@ -289,11 +289,12 @@ def resolve_model(
     except ChatGPTOAuthInvalidRequestError as exc:
         raise ChatGPTOAuthCatalogUnavailableError("configured model is unusable") from exc
     if candidate is not None and anthropic_facade and candidate.startswith("claude-"):
-        if configured_model is None:
-            raise ChatGPTOAuthInvalidRequestError(
-                "claude-* facade models require CODEX_AS_API_MODEL or config.toml model"
-            )
-        return configured_capability(configured_model)
+        if configured_model is not None:
+            return configured_capability(configured_model)
+        capability = snapshot.default_model()
+        if not capability.slug.strip() or capability.slug != capability.slug.strip():
+            raise ChatGPTOAuthCatalogUnavailableError("default model publishes an unusable slug")
+        return capability
     if candidate is not None:
         return snapshot.model(candidate)
     if configured_model is not None: