Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Complete the direct protocol matrix (#1575)
Ali Khokharecaf236570ab
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.mdindex 3455fd1d..320eb004 100644--- a/ARCHITECTURE.md+++ b/ARCHITECTURE.md@@ -482,13 +482,15 @@ to a client that has already left. Non-inference routes bypass this machinery.`MessagesHandler` validates non-empty messages, resolves models, appliesClaude-only safety-classifier and local optimization policy, handles local webserver tools, then streams Anthropic SSE. `ResponsesHandler` owns streaming-only-OpenAI Responses validation and conversion for Codex clients. `TokenCountHandler`-owns Anthropic token counting. Shared provider execution lives in+OpenAI Responses validation for Codex clients and passes the concrete Responses+request into the shared executor. `TokenCountHandler` owns Anthropic token+counting. Shared provider execution lives in[application/execution.py](src/free_claude_code/application/execution.py). `ProviderExecutor` resolves the narrow-consumer-owned `ProviderPort`, synchronously preflights the primary upstream-request, emits trace events, counts input tokens, and returns an Anthropic SSE-iterator. It also owns application-level model fallback after provider-owned-retries are exhausted; providers do not select alternate models.+consumer-owned `ProviderPort`, synchronously preflights the concrete ingress+protocol, emits trace events, counts input tokens, and returns an SSE iterator+in that same public protocol. It also owns application-level model fallback+after provider-owned retries are exhausted; providers do not select alternate+models.It receives only a provider resolver and the few scalar collaborators it needs;it does not depend on FastAPI, provider implementations, or the full settingsobject. The executor also owns FCC's provider-progress deadline: every wait for@@ -533,13 +535,14 @@ non-2xx JSON for any terminal stream error, discarding incomplete content ratherthan presenting a partial success.The public response chain follows a transitive close-ownership rule. A response-owns its replay iterator; replay owns the active protocol adapter; each protocol-adapter owns its direct input; tracing owns the executor body; the executor body-owns the provider iterator; and the provider runner owns its upstream stream.-Each of these response-chain owners closes its direct input on normal completion,-failure, cancellation, and early consumer close. Failures from those explicit-cleanup calls are trace metadata and cannot replace an established wire outcome;-a generation lease is released only after the body chain has finished closing.+owns its prefetched replay iterator; replay owns the traced executor body;+tracing owns the provider-execution iterator; and the provider runner owns its+upstream stream. Provider-owned conversion and presentation iterators stay+inside their concrete transport chain and close their direct inputs. Each+response-chain owner closes its direct input on normal completion, failure,+cancellation, and early consumer close. Failures from those explicit cleanup+calls are trace metadata and cannot replace an established wire outcome; a+generation lease is released only after the body chain has finished closing.Ingress authentication, request validation, model routing, and deterministicpreflight failures remain ordinary HTTP errors and do not receive the terminal@@ -571,18 +574,20 @@ sequenceDiagramExec->>Lease: resolve providerLease->>Runtime: cached or new providerRuntime->>Provider: cached or new provider- Exec->>Provider: preflight_stream- Exec->>Provider: stream_response+ Exec->>Provider: preflight_messages+ Exec->>Provider: stream_messagesProvider-->>Client: Anthropic SSE eventsRoute->>Lease: release after complete body```OpenAI Responses uses the same provider execution primitive without importing-Claude-only message intercepts. `ResponsesHandler` delegates protocol work to-the `OpenAIResponsesAdapter` in-[src/free_claude_code/core/openai_responses/adapter.py](src/free_claude_code/core/openai_responses/adapter.py). The adapter-converts the Responses payload into an Anthropic Messages payload before-provider execution, then converts Anthropic SSE back to Responses SSE.+Claude-only message intercepts. `ResponsesHandler` calls+`ProviderExecutor.stream_responses`, and the concrete `OpenAIResponsesRequest`+remains a Responses request across the application boundary. The selected+provider transport then owns one explicit matrix cell: Messages-to-Chat,+Messages-to-Responses, Responses-to-Chat, or native Responses-to-Responses.+There is no compatibility facade and no Responses-to-Messages-to-Responses+round trip.## Model Routing@@ -782,11 +787,12 @@ state.model-list modules retain response parsing and construct that value directly;there is no provider-layer alias for the former owner.-[application/ports.py](src/free_claude_code/application/ports.py) defines the two provider operations consumed by request-execution: synchronous `preflight_stream()` and lazy `stream_response()`. API-handlers and application execution depend on that structural port, never on a-provider base class. Provider adapters implement it without registration or a-compatibility layer.+[application/ports.py](src/free_claude_code/application/ports.py) defines the+four protocol-specific provider operations consumed by request execution:+synchronous `preflight_messages()` and `preflight_responses()`, followed by+lazy `stream_messages()` and `stream_responses()`. API handlers and application+execution depend on that structural port, never on a provider base class.+Providers implement it without registration or a compatibility layer.[providers/base.py](src/free_claude_code/providers/base.py) defines provider-internal construction and lifecycle contracts:@@ -794,9 +800,10 @@ compatibility layer.limits, timeouts, proxy, and logging flags. It is a frozen internalvalue whose base URL has already been resolved from the catalog.- `BaseProvider`: the abstract implementation base for cleanup, explicit- preflight, `stream_response()`, and the sole provider catalog operation,- `list_model_infos()`. Providers return application-owned `ProviderModelInfo`- values directly; there is no parallel IDs-only catalog contract.+ Messages and Responses preflight/stream operations, and the sole provider+ catalog operation, `list_model_infos()`. Providers return application-owned+ `ProviderModelInfo` values directly; there is no parallel IDs-only catalog+ contract.Provider execution is organized around explicit protocol owners.[providers/openai_chat/](src/free_claude_code/providers/openai_chat/) implements the concrete@@ -893,14 +900,14 @@ client-specific recovery phrase.Providers call the OpenAI request policy for Anthropic-to-OpenAI conversion,reasoning replay selection, `extra_body`, and chat-completion field normalization.The SDK-free `OpenAIToolNameCodec` in-[core/anthropic/](src/free_claude_code/core/anthropic/) owns reversible-translation from client tool identities to OpenAI's portable function-name-grammar. OpenAI Chat and upstream Responses adapters apply that codec only to-their explicit declaration, forced-choice, and replay fields, then restore the-original identity before Anthropic tool state or schema validation. Valid names-remain unchanged, while deterministic aliases keep retries, replay, and-append-only prompt prefixes stable. This is target-protocol conversion, never a-provider or model capability switch.+[core/openai_tool_names.py](src/free_claude_code/core/openai_tool_names.py) owns+reversible translation from client tool identities to OpenAI's portable+function-name grammar. OpenAI Chat and upstream Responses converters apply that+codec only to their explicit declaration, forced-choice, and replay fields,+then restore the original identity before Anthropic tool state or schema+validation. Valid names remain unchanged, while deterministic aliases keep+retries, replay, and append-only prompt prefixes stable. This is target-protocol+conversion, never a provider or model capability switch.When an Anthropic request declares tools but omits `tool_choice`, the conversionboundary resolves Anthropic's implicit `auto` intent once. Both upstream OpenAIChat and OpenAI Responses encoders materialize that value explicitly, while@@ -1047,10 +1054,11 @@ streamed usage handling: it requestsproviders omit or reject optional usage metadata. Provider modules only own trueusage quirks: DeepSeek validates a complete hit/miss partition, maps misses toordinary input and hits to cache reads, and never reports a miss as an-Anthropic cache creation. The native Responses-to-Anthropic adapter likewise-partitions a valid cached-token detail from the upstream total. At the reverse-protocol boundary, the Anthropic-to-Responses adapter recombines those-disjoint input categories into its single `input_tokens` total.+Anthropic cache creation. The Messages-to-Responses presenter likewise+partitions a valid cached-token detail from the upstream total. The+Chat-to-Responses presenter recombines disjoint Chat input categories into its+single `input_tokens` total, while the native Responses relay preserves the+upstream usage object unchanged.### Adding A Provider@@ -1190,78 +1198,44 @@ same commit-state split but do not acquire provider retry semantics.[src/free_claude_code/core/openai_responses/](src/free_claude_code/core/openai_responses/) owns OpenAI Responses support:- the permissive `OpenAIResponsesRequest` ingress model used directly by the- FastAPI route and the protocol adapter;-- the `OpenAIResponsesAdapter` facade used by the API layer;-- streaming-only `/v1/responses` support for Codex/FCC workflows;-- Responses request conversion into Anthropic Messages payloads;-- Anthropic SSE conversion into Responses SSE;-- OpenAI-compatible error envelopes.+ FastAPI route, application executor, and provider ports;+- direct Responses-to-Chat request translation in `chat_request.py`;+- Messages-to-Responses request and stream translation in+ `provider_input.py` and `provider_stream.py`;+- native Responses request shaping and event relay in `native.py`;+- Responses event, block, tool-identity, reasoning, token-estimation, ID, and+ error-envelope helpers used by the transport-owned presenters.The package intentionally does not implement the full OpenAI Responses surface.FCC accepts omitted `stream` or `stream: true`; `stream: false` is rejected withan OpenAI-shaped client error because installed FCC/Codex workflows only need-streaming. Request conversion, stream transformation, Anthropic SSE parsing,-Responses SSE event formatting, output item construction, tool identity mapping,-reasoning mapping, ID generation, and error envelope construction each live-behind the adapter boundary. The concrete request object crosses that boundary-unchanged; nested Responses input and tool data stays permissive and is-interpreted by the conversion functions. `stream.py` is the public streaming-entrypoint;-[src/free_claude_code/core/openai_responses/streaming/](src/free_claude_code/core/openai_responses/streaming/) owns the-block-indexed Responses stream assembler. The package separates Anthropic SSE-dispatch, block state, output ledger ordering, block completion, SSE event-builders, and error mapping. API code should depend on the adapter, not on-those internal module owners directly. Responses output payloads stay-OpenAI-shaped. Canonical execution failures enter the assembler directly, so-Responses does not infer provider failure semantics by parsing an Anthropic-terminal error.-Post-start Responses failures are assembler-owned: the active-`ResponsesStreamAssembler` emits `response.failed` so the terminal event keeps-the same `response.id`, output ledger, and usage state as the earlier-`response.created`.-Provider completion reasons remain canonical until that same assembler chooses-the Responses terminal event. Anthropic `max_tokens` becomes-`response.incomplete` with `incomplete_details.reason=max_output_tokens` while-preserving partial output and usage; normal terminal reasons remain-`response.completed`.--Responses custom tools are also boundary-owned. The adapter accepts native-Responses `custom` tool declarations, represents them internally as Anthropic-tools with a single string `input` field, and restores `custom_tool_call`,-`custom_tool_call_output`, and `response.custom_tool_call_input.*` shapes at the-Responses edge. Text or grammar format metadata is preserved as model guidance;-FCC does not validate custom-tool grammars.--Client-facing Responses tool identity mapping is distinct from upstream wire-portability. Namespaces and custom-tool identities are restored at the public-Responses edge; the OpenAI tool-name codec operates beneath that mapping only-while the canonical Anthropic request crosses an OpenAI upstream transport.--Responses reasoning is handled as lossless protocol conversion before provider-policy. The adapter preserves `reasoning.effort` in Anthropic `output_config`;-the application reasoning boundary then interprets `none` as off and preserves-all other named efforts. It never translates OpenAI effort names into Anthropic-token budgets.-Application-resolved source controls remain on the immutable canonical request;-provider adapters consume the resolved `ReasoningPolicy` rather than parsing-those controls again. A target converter validates only the unrepresented-semantic remainder: it may omit an application-consumed control or an exact-no-op, but must reject active or unknown behavior before upstream I/O. For the-connected OpenAI Responses transport, `output_config.effort` is already-represented by the policy and an empty context edit or exact-`clear_thinking_20251015` edit with `keep: "all"` is inert. Structured-output-configuration and any active, malformed, or extended context edit remain-unsupported and fail preflight rather than being silently discarded.-Prior Responses `reasoning` input items replay plaintext `reasoning_text`, or-fallback `summary_text`, into assistant `reasoning_content`. Encrypted reasoning-input is ignored because the proxy cannot decrypt it.--Provider thinking output maps back to Responses reasoning in the same block-order the upstream Anthropic stream produced. Anthropic `thinking` blocks become-Responses `reasoning` output items and `response.reasoning_text.*` stream-events. Anthropic `redacted_thinking` becomes a Responses `reasoning` item with-`encrypted_content`; the opaque value is not exposed as visible text and FCC-does not synthesize reasoning summaries.+streaming. The application port exposes separate Messages and Responses+preflight/stream methods; providers choose the upstream transport without+changing the public request type. This produces exactly three translations:+Messages-to-Chat, Messages-to-Responses, and Responses-to-Chat. Native+Responses-to-Responses is an identity relay, not a fourth translation. FCC does+not maintain a universal canonical inference schema between these boundaries.++The direct Responses-to-Chat cell preserves text, images, function/custom tool+identity, call IDs, reasoning replay data, supported request options, and usage,+then writes one coherent Responses lifecycle from Chat stream semantics. The+Messages-to-Responses cell preserves the corresponding Anthropic semantics and+writes Anthropic SSE from Responses events. Native Responses forwarding keeps+nested request extensions and upstream response/item/call IDs, event order,+reasoning payloads, and exact usage; it rewrites only FCC-owned routing fields+such as the public model and enforces stateless streaming. Unsupported+cross-protocol semantics fail in the owning translator before upstream I/O.++Application-resolved reasoning controls remain on the immutable source request.+Provider adapters consume the resolved `ReasoningPolicy`; each cross-protocol+translator maps the replay material its target supports, while the native cell+passes Responses reasoning through unchanged. Tool-name flattening is likewise+limited to OpenAI-compatible cross-protocol boundaries and is reversed at the+public edge. Output presenters own provider-attempt event construction and+terminal failure framing. If an application-owned failure occurs after the+public stream commits, the API wire boundary closes that same public lifecycle;+providers continue to own HTTP classification, retry policy, admission, and+physical stream cleanup.Provider code should delegate protocol details to these modules. Avoid copyingconversion code into individual providers, and avoid provider-to-provider importsdiff --git a/e2e/conftest.py b/e2e/conftest.pyindex 58cf5836..4fcf7807 100644--- a/e2e/conftest.py+++ b/e2e/conftest.py@@ -17,6 +17,7 @@ from free_claude_code.config import env_migrations, pathsfrom free_claude_code.config.env_migrations import recognized_env_keysfrom free_claude_code.config.loader import clear_settings_cache, get_settingsfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.base import BaseProvider, ProviderConfigfrom free_claude_code.providers.runtime import ProviderRuntime@@ -49,7 +50,7 @@ class _ModelListingProvider(BaseProvider):self._model_infos = model_infosself._error = error- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -57,6 +58,14 @@ class _ModelListingProvider(BaseProvider):) -> None:return None+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ return None+async def cleanup(self) -> None:return None@@ -65,7 +74,7 @@ class _ModelListingProvider(BaseProvider):raise self._errorreturn self._model_infos- async def stream_response(+ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -77,6 +86,18 @@ class _ModelListingProvider(BaseProvider):if False:yield ""+ async def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> AsyncIterator[str]:+ if False:+ yield ""+def _close_manager(manager: ProviderRuntimeManager) -> None:"""Close async runtime ownership outside Playwright's active sync loop."""diff --git a/pyproject.toml b/pyproject.tomlindex 272f1c46..3947a249 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.14.8"+version = "5.14.9"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/smoke/capabilities.py b/smoke/capabilities.pyindex 0dcc1dc2..263d0f08 100644--- a/smoke/capabilities.py+++ b/smoke/capabilities.py@@ -73,7 +73,8 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = ("OpenAI-shaped error or conversion error",("tests/api/test_openai_responses.py",- "tests/core/openai_responses/test_sse.py",+ "tests/core/openai_responses/test_native.py",+ "tests/providers/test_openai_chat_stream_output.py","tests/cli/test_entrypoints.py","tests/cli/test_codex_model_catalog.py",),diff --git a/smoke/features.py b/smoke/features.pyindex b09993da..529b7626 100644--- a/smoke/features.py+++ b/smoke/features.py@@ -87,7 +87,8 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = ("tests/api/test_openai_responses.py","tests/cli/test_entrypoints.py","tests/cli/test_codex_model_catalog.py",- "tests/core/openai_responses/test_sse.py",+ "tests/core/openai_responses/test_native.py",+ "tests/providers/test_openai_chat_stream_output.py",),("test_probe_and_models_routes",),("test_provider_codex_responses_text_e2e",),diff --git a/smoke/lib/config.py b/smoke/lib/config.pyindex 55f61d55..e0fd043f 100644--- a/smoke/lib/config.py+++ b/smoke/lib/config.py@@ -71,7 +71,7 @@ PROVIDER_SMOKE_DEFAULT_MODELS: dict[str, str] = {"zai_api": "zai_api/glm-4.7-flash","gemini": "gemini/models/gemini-3.1-flash-lite","vertex": "vertex/google/gemini-3.5-flash",- "groq": "groq/llama-3.3-70b-versatile",+ "groq": "groq/openai/gpt-oss-20b","cline_pass": "cline_pass/cline-pass/deepseek-v4-flash","xai": "xai/grok-4.5","qwencloud": "qwencloud/qwen3.7-plus",diff --git a/src/free_claude_code/api/handlers/messages.py b/src/free_claude_code/api/handlers/messages.pyindex fcafd337..ba7b4347 100644--- a/src/free_claude_code/api/handlers/messages.py+++ b/src/free_claude_code/api/handlers/messages.py@@ -133,10 +133,8 @@ class MessagesHandler:if result is None:logger.debug("No optimization matched, routing to provider")result = _MessagesStreamResult(- self._provider_executor.stream(+ self._provider_executor.stream_messages(routed,- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload=routed.request.model_dump(),request_id=request_id,)diff --git a/src/free_claude_code/api/handlers/responses.py b/src/free_claude_code/api/handlers/responses.pyindex 84f0a988..f5f279ed 100644--- a/src/free_claude_code/api/handlers/responses.py+++ b/src/free_claude_code/api/handlers/responses.py@@ -6,7 +6,6 @@ from free_claude_code.api.request_errors import (http_status_for_unexpected_api_exception,log_unexpected_api_exception,ordinary_application_error_response,- require_non_empty_messages,)from free_claude_code.api.request_ids import new_request_idfrom free_claude_code.api.response_streams import (@@ -19,12 +18,12 @@ from free_claude_code.application.execution import ProviderExecutorfrom free_claude_code.application.ports import ProviderResolverfrom free_claude_code.application.routing import ModelRouterfrom free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.diagnostics import safe_exception_messagefrom free_claude_code.core.failures import ExecutionFailure, find_execution_failurefrom free_claude_code.core.openai_responses import (- OpenAIResponsesAdapter,+ OPENAI_RESPONSES_SSE_HEADERS,OpenAIResponsesRequest,+ openai_error_payload,openai_error_type_for_failure,openai_failure_payload,)@@ -39,13 +38,11 @@ class ResponsesHandler:provider_resolver: ProviderResolver,*,model_router: ModelRouter | None = None,- responses_adapter: OpenAIResponsesAdapter | None = None,provider_executor: ProviderExecutor | None = None,generation_id: int | None = None,) -> None:self._settings = settingsself._model_router = model_router or ModelRouter(settings)- self._responses_adapter = responses_adapter or OpenAIResponsesAdapter()self._provider_executor = provider_executor or ProviderExecutor(provider_resolver,progress_timeout_seconds=settings.provider_progress_timeout,@@ -63,40 +60,30 @@ class ResponsesHandler:raise InvalidRequestError("FCC /v1/responses supports streaming only; omit stream or set stream=true.")+ if not request_data.model.strip():+ raise InvalidRequestError("Responses request model must not be empty.")+ if (+ request_data.input is None+ or request_data.input == ""+ or request_data.input == []+ ):+ raise InvalidRequestError("Responses request input must not be empty.")try:- anthropic_payload = self._responses_adapter.to_anthropic_payload(- request_data- )- response_request = MessagesRequest(**anthropic_payload)- require_non_empty_messages(response_request.messages)- routed = self._model_router.resolve_messages_request(response_request)-- streamed = self._provider_executor.stream(+ routed = self._model_router.resolve_responses_request(request_data)+ streamed = self._provider_executor.stream_responses(routed,- wire_api="responses",- raw_log_label="FULL_RESPONSES_PAYLOAD",raw_log_payload=request_payload,request_id=request_id,)return await openai_responses_sse_streaming_response(- self._responses_adapter.iter_sse_from_anthropic(- streamed,- request_data,- on_post_start_terminal_failure=lambda exc: (- self._trace_post_start_terminal_failure(- exc,- request_id=request_id,- )- ),- ),- headers=self._responses_adapter.sse_headers,+ streamed,+ headers=OPENAI_RESPONSES_SSE_HEADERS,pre_start_error_response=lambda exc: self._pre_start_error_response(exc, request_id=request_id),+ request_id=request_id,)- except OpenAIResponsesAdapter.ConversionError as exc:- raise InvalidRequestError(str(exc)) from excexcept ApplicationError:raiseexcept ExecutionFailure as exc:@@ -112,7 +99,7 @@ class ResponsesHandler:)return JSONResponse(status_code=http_status_for_unexpected_api_exception(exc),- content=self._responses_adapter.error_payload(+ content=openai_error_payload(message=safe_exception_message(exc),error_type="api_error",),@@ -146,7 +133,7 @@ class ResponsesHandler:)return terminal_execution_error_response(status_code=status_code,- content=self._responses_adapter.error_payload(+ content=openai_error_payload(message=safe_exception_message(exc),error_type="api_error",),@@ -170,22 +157,3 @@ class ResponsesHandler:status_code=failure.status_code,content=openai_failure_payload(failure),)-- @staticmethod- def _trace_post_start_terminal_failure(- exc: BaseException,- *,- request_id: str,- ) -> None:- failure = find_execution_failure(exc)- trace_terminal_execution_error(- wire_api="responses",- request_id=request_id,- status_code=failure.status_code if failure is not None else 500,- error_type=(- openai_error_type_for_failure(failure)- if failure is not None- else "api_error"- ),- error=exc,- )diff --git a/src/free_claude_code/api/response_streams.py b/src/free_claude_code/api/response_streams.pyindex 0f4afa1d..136b469c 100644--- a/src/free_claude_code/api/response_streams.py+++ b/src/free_claude_code/api/response_streams.py@@ -24,12 +24,16 @@ from free_claude_code.core.async_iterators import try_close_async_iteratorfrom free_claude_code.core.diagnostics import safe_exception_messagefrom free_claude_code.core.failures import find_execution_failurefrom free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses import (+ committed_response_failure_frame,+ openai_error_type_for_failure,+)from free_claude_code.core.trace import close_stream_input, trace_eventTERMINAL_EXECUTION_ERROR_HEADERS = {"x-should-retry": "false"}PreStartErrorResponse = Callable[[BaseException], Response]-TerminalFrameEmitter = Callable[[BaseException], str]+TerminalFrameEmitter = Callable[[str, str, BaseException], str]TerminalFailureObserver = Callable[[BaseException], None]ReleaseResponseResource = Callable[[], Awaitable[None]]WireApi = Literal["messages", "responses"]@@ -281,6 +285,8 @@ class _PrefetchedStream(AsyncIterator[str]):terminal_failure_observer: TerminalFailureObserver | None,) -> None:self._first_chunk: str | None = first_chunk+ self._initial_chunk = first_chunk+ self._latest_chunk = first_chunkself._body = bodyself._terminal_frame = terminal_frameself._terminal_failure_observer = terminal_failure_observer@@ -298,7 +304,9 @@ class _PrefetchedStream(AsyncIterator[str]):self._first_chunk = Nonereturn first_chunktry:- return await anext(self._body)+ chunk = await anext(self._body)+ self._latest_chunk = chunk+ return chunkexcept StopAsyncIteration:self._done = Trueraise@@ -323,7 +331,7 @@ class _PrefetchedStream(AsyncIterator[str]):self._done = Trueif self._terminal_failure_observer is not None:self._terminal_failure_observer(exc)- return terminal_frame(exc)+ return terminal_frame(self._initial_chunk, self._latest_chunk, exc)async def anthropic_sse_streaming_response(@@ -345,7 +353,11 @@ async def anthropic_sse_streaming_response()-def _anthropic_terminal_frame(exc: BaseException) -> str:+def _anthropic_terminal_frame(+ _first_chunk: str,+ _latest_chunk: str,+ exc: BaseException,+) -> str:failure = find_execution_failure(exc)if failure is not None:return anthropic_terminal_failure_frame(failure)@@ -376,12 +388,35 @@ async def openai_responses_sse_streaming_response(*,headers: Mapping[str, str],pre_start_error_response: PreStartErrorResponse,+ request_id: str,) -> Response:"""Return a streaming response for OpenAI Responses-style SSE."""return await _first_chunk_streaming_response(body,headers=headers,pre_start_error_response=pre_start_error_response,- terminal_frame=None,- terminal_failure_observer=None,+ terminal_frame=committed_response_failure_frame,+ terminal_failure_observer=lambda exc: _trace_responses_terminal_failure(+ exc,+ request_id=request_id,+ ),+ )+++def _trace_responses_terminal_failure(+ exc: BaseException,+ *,+ request_id: str,+) -> None:+ failure = find_execution_failure(exc)+ trace_terminal_execution_error(+ wire_api="responses",+ request_id=request_id,+ status_code=failure.status_code if failure is not None else 500,+ error_type=(+ openai_error_type_for_failure(failure)+ if failure is not None+ else "api_error"+ ),+ error=exc,)diff --git a/src/free_claude_code/api/web_tools/automatic_search.py b/src/free_claude_code/api/web_tools/automatic_search.pyindex 4478afdd..87903043 100644--- a/src/free_claude_code/api/web_tools/automatic_search.py+++ b/src/free_claude_code/api/web_tools/automatic_search.py@@ -40,10 +40,8 @@ async def stream_automatic_web_search_response(request_id=request_id,model=routed.resolved.original_model,)- provider_stream = provider_executor.stream(+ provider_stream = provider_executor.stream_messages(translated,- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload=plan.request.model_dump(),request_id=request_id,)diff --git a/src/free_claude_code/application/execution.py b/src/free_claude_code/application/execution.pyindex 249f2848..76f98781 100644--- a/src/free_claude_code/application/execution.py+++ b/src/free_claude_code/application/execution.py@@ -16,6 +16,11 @@ from free_claude_code.core.anthropic import (get_token_count,)from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ estimate_responses_input_tokens,+)+from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.core.trace import (close_stream_input,trace_event,@@ -23,13 +28,20 @@ from free_claude_code.core.trace import ()from .ports import ProviderResolver-from .routing import ProviderModelTarget, RoutedMessagesRequest+from .routing import (+ ProviderModelTarget,+ ResolvedModelRoute,+ RoutedMessagesRequest,+ RoutedResponsesRequest,+)TokenCounter = Callable[[list[Message], str | list[SystemContent] | None, list[Tool] | None],int,]+ResponsesTokenCounter = Callable[[OpenAIResponsesRequest], int]WireApi = Literal["messages", "responses"]+CandidateStreamOpener = Callable[[int, ProviderModelTarget], AsyncIterator[str]]class ProviderExecutor:@@ -41,6 +53,7 @@ class ProviderExecutor:*,progress_timeout_seconds: float,token_counter: TokenCounter = get_token_count,+ responses_token_counter: ResponsesTokenCounter = estimate_responses_input_tokens,generation_id: int | None = None,log_raw_payloads: bool = False,) -> None:@@ -48,6 +61,7 @@ class ProviderExecutor:raise ValueError("progress_timeout_seconds must be finite and positive")self._provider_resolver = provider_resolverself._token_counter = token_counter+ self._responses_token_counter = responses_token_counterself._generation_id = generation_idself._log_raw_payloads = log_raw_payloadsself._progress_timeout_seconds = float(progress_timeout_seconds)@@ -140,26 +154,155 @@ class ProviderExecutor:fields["generation_id"] = self._generation_idtrace_event(**fields)- def stream(+ def stream_messages(self,routed: RoutedMessagesRequest,*,- wire_api: WireApi,- raw_log_label: str,raw_log_payload: object,request_id: str,) -> AsyncIterator[str]:- """Preflight synchronously, then return the traced provider stream."""+ """Preflight and execute one Anthropic Messages request."""+primary = routed.resolved.primaryprimary_provider = self._provider_resolver(primary.provider_id)primary_request = routed.request.model_copy(deep=True)- primary_provider.preflight_stream(+ primary_provider.preflight_messages(primary_request,reasoning=routed.reasoning,)- candidates = (primary, *routed.resolved.fallbacks)+ input_tokens = self._token_counter(+ routed.request.messages,+ routed.request.system,+ routed.request.tools,+ )++ def open_candidate(+ index: int,+ target: ProviderModelTarget,+ ) -> AsyncIterator[str]:+ provider = (+ primary_provider+ if index == 0+ else self._provider_resolver(target.provider_id)+ )+ request = (+ primary_request+ if index == 0+ else routed.request.model_copy(+ update={"model": target.provider_model},+ deep=True,+ )+ )+ if index > 0:+ provider.preflight_messages(request, reasoning=routed.reasoning)+ return provider.stream_messages(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=routed.resolved.original_model,+ reasoning=routed.reasoning,+ )++ return self._stream_candidates(+ resolved=routed.resolved,+ reasoning=routed.reasoning,+ wire_api="messages",+ raw_log_label="FULL_PAYLOAD",+ raw_log_payload=raw_log_payload,+ request_snapshot=anthropic_request_snapshot(routed.request),+ ingress_count_name="message_count",+ ingress_count=len(routed.request.messages),+ request_id=request_id,+ open_candidate=open_candidate,+ )++ def stream_responses(+ self,+ routed: RoutedResponsesRequest,+ *,+ raw_log_payload: object,+ request_id: str,+ ) -> AsyncIterator[str]:+ """Preflight and execute one native OpenAI Responses request."""++ primary = routed.resolved.primary+ primary_provider = self._provider_resolver(primary.provider_id)+ primary_request = routed.request.model_copy(deep=True)+ primary_provider.preflight_responses(+ primary_request,+ reasoning=routed.reasoning,+ )+ input_tokens = self._responses_token_counter(routed.request)++ def open_candidate(+ index: int,+ target: ProviderModelTarget,+ ) -> AsyncIterator[str]:+ provider = (+ primary_provider+ if index == 0+ else self._provider_resolver(target.provider_id)+ )+ request = (+ primary_request+ if index == 0+ else routed.request.model_copy(+ update={"model": target.provider_model},+ deep=True,+ )+ )+ if index > 0:+ provider.preflight_responses(request, reasoning=routed.reasoning)+ return provider.stream_responses(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=routed.resolved.original_model,+ reasoning=routed.reasoning,+ )- gateway_model = routed.resolved.original_model+ raw_input = routed.request.input+ input_item_count = (+ len(raw_input)+ if isinstance(raw_input, list)+ else int(raw_input is not None)+ )+ return self._stream_candidates(+ resolved=routed.resolved,+ reasoning=routed.reasoning,+ wire_api="responses",+ raw_log_label="FULL_RESPONSES_PAYLOAD",+ raw_log_payload=raw_log_payload,+ request_snapshot={+ "model": routed.request.model,+ "input_item_count": input_item_count,+ "tool_count": len(routed.request.tools or ()),+ },+ ingress_count_name="input_item_count",+ ingress_count=input_item_count,+ request_id=request_id,+ open_candidate=open_candidate,+ )++ def _stream_candidates(+ self,+ *,+ resolved: ResolvedModelRoute,+ reasoning: ReasoningPolicy,+ wire_api: WireApi,+ raw_log_label: str,+ raw_log_payload: object,+ request_snapshot: dict[str, object],+ ingress_count_name: str,+ ingress_count: int,+ request_id: str,+ open_candidate: CandidateStreamOpener,+ ) -> AsyncIterator[str]:+ """Run one protocol-blind candidate lifecycle after eager preflight."""++ primary = resolved.primary+ candidates = (primary, *resolved.fallbacks)+ gateway_model = resolved.original_modelroute_trace: dict[str, object] = {"stage": "routing","event": "free_claude_code.api.route.resolved",@@ -168,15 +311,13 @@ class ProviderExecutor:"provider_id": primary.provider_id,"provider_model": primary.provider_model,"provider_model_ref": primary.provider_model_ref,- "fallback_count": len(routed.resolved.fallbacks),+ "fallback_count": len(resolved.fallbacks),"gateway_model": gateway_model,- "reasoning_control": routed.reasoning.control.value,+ "reasoning_control": reasoning.control.value,"reasoning_effort": (- routed.reasoning.effort.value- if routed.reasoning.effort is not None- else None+ reasoning.effort.value if reasoning.effort is not None else None),- "reasoning_budget_tokens": routed.reasoning.budget_tokens,+ "reasoning_budget_tokens": reasoning.budget_tokens,}if wire_api == "responses":route_trace["wire_api"] = "responses"@@ -184,71 +325,42 @@ class ProviderExecutor:route_trace["generation_id"] = self._generation_idtrace_event(**route_trace)- request_snapshot = anthropic_request_snapshot(routed.request)request_snapshot["model"] = gateway_model- trace_event(- stage="ingress",- event=(+ ingress_trace: dict[str, object] = {+ "stage": "ingress",+ "event": ("free_claude_code.api.responses.request.received"if wire_api == "responses"else "free_claude_code.api.request.received"),- source="api",- message_count=len(routed.request.messages),- snapshot=request_snapshot,- request_id=request_id,+ "source": "api",+ "snapshot": request_snapshot,+ "request_id": request_id,+ ingress_count_name: ingress_count,+ }+ trace_event(+ **ingress_trace,)if self._log_raw_payloads:logger.debug(f"{raw_log_label} [{{}}]: {{}}", request_id, raw_log_payload)- input_tokens = self._token_counter(- routed.request.messages,- routed.request.system,- routed.request.tools,- )-async def provider_body() -> AsyncIterator[str]:loop = asyncio.get_running_loop()progress_deadline = loop.time() + self._progress_timeout_secondsfor index, target in enumerate(candidates):- provider = (- primary_provider- if index == 0- else self._provider_resolver(target.provider_id)- )- candidate_request = (- primary_request- if index == 0- else routed.request.model_copy(- update={"model": target.provider_model},- deep=True,- )- )- if index > 0:- provider.preflight_stream(- candidate_request,- reasoning=routed.reasoning,- )-provider_stream: AsyncIterator[str] | None = Nonecandidate_committed = Falsecandidate_failure: ExecutionFailure | None = Nonetry:try:- provider_stream = provider.stream_response(- candidate_request,- input_tokens=input_tokens,- request_id=request_id,- response_model=gateway_model,- reasoning=routed.reasoning,- )+ provider_stream = open_candidate(index, target)except ExecutionFailure as failure:candidate_failure = failureif provider_stream is None and candidate_failure is None:raise TypeError(- "provider stream_response must return an async iterator"+ "provider stream method must return an async iterator")while provider_stream is not None:if loop.time() >= progress_deadline:diff --git a/src/free_claude_code/application/ports.py b/src/free_claude_code/application/ports.pyindex 5d810b32..6c3affc4 100644--- a/src/free_claude_code/application/ports.py+++ b/src/free_claude_code/application/ports.py@@ -6,6 +6,7 @@ from typing import Protocolfrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequest+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom .model_metadata import ProviderModelInfo@@ -14,14 +15,14 @@ from .model_metadata import ProviderModelInfoclass ProviderPort(Protocol):"""Minimal provider capability required to execute one request."""- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,reasoning: ReasoningPolicy,) -> None: ...- def stream_response(+ def stream_messages(self,request: MessagesRequest,*,@@ -31,6 +32,23 @@ class ProviderPort(Protocol):reasoning: ReasoningPolicy,) -> AsyncIterator[str]: ...+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None: ...++ def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]: ...+ProviderResolver = Callable[[str], ProviderPort]diff --git a/src/free_claude_code/application/reasoning.py b/src/free_claude_code/application/reasoning.pyindex 14a5411b..aa3f7851 100644--- a/src/free_claude_code/application/reasoning.py+++ b/src/free_claude_code/application/reasoning.py@@ -4,6 +4,10 @@ from collections.abc import Mappingfrom free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.core.anthropic.models import MessagesRequest, ThinkingConfig+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ responses_reasoning_policy,+)from free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,@@ -17,13 +21,37 @@ def resolve_reasoning_policy() -> ReasoningPolicy:"""Apply one resolved configuration preference to the client request."""+ return _apply_reasoning_preference(+ client_reasoning_policy(request),+ preference,+ )+++def resolve_responses_reasoning_policy(+ request: OpenAIResponsesRequest,+ preference: ReasoningPreference,+) -> ReasoningPolicy:+ """Apply one resolved configuration preference to a Responses request."""++ return _apply_reasoning_preference(+ client_responses_reasoning_policy(request),+ preference,+ )+++def _apply_reasoning_preference(+ client_policy: ReasoningPolicy,+ preference: ReasoningPreference,+) -> ReasoningPolicy:+ """Apply FCC's route preference to already-parsed client intent."""+if preference is ReasoningPreference.INHERIT:raise ValueError("Reasoning preference must be resolved before application.")if preference is ReasoningPreference.OFF:return ReasoningPolicy.off()if preference is not ReasoningPreference.CLIENT:return ReasoningPolicy.on(effort=ReasoningEffort(preference.value))- return client_reasoning_policy(request)+ return client_policydef client_reasoning_policy(request: MessagesRequest) -> ReasoningPolicy:@@ -54,6 +82,14 @@ def client_reasoning_policy(request: MessagesRequest) -> ReasoningPolicy:)+def client_responses_reasoning_policy(+ request: OpenAIResponsesRequest,+) -> ReasoningPolicy:+ """Return the supported reasoning intent from one Responses request."""++ return responses_reasoning_policy(request.reasoning)++def _thinking_control(thinking: ThinkingConfig | None,*,diff --git a/src/free_claude_code/application/routing.py b/src/free_claude_code/application/routing.pyindex 37b6a85e..863b0806 100644--- a/src/free_claude_code/application/routing.py+++ b/src/free_claude_code/application/routing.py@@ -14,9 +14,10 @@ from free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequest, TokenCountRequestfrom free_claude_code.core.gateway_model_ids import decode_gateway_model_id+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicy-from .reasoning import resolve_reasoning_policy+from .reasoning import resolve_reasoning_policy, resolve_responses_reasoning_policy_ROUTE_SETTINGS = (("fable", "model_fable", "reasoning_fable"),@@ -52,6 +53,13 @@ class RoutedMessagesRequest:reasoning: ReasoningPolicy+@dataclass(frozen=True, slots=True)+class RoutedResponsesRequest:+ request: OpenAIResponsesRequest+ resolved: ResolvedModelRoute+ reasoning: ReasoningPolicy++@dataclass(frozen=True, slots=True)class RoutedTokenCountRequest:request: TokenCountRequest@@ -212,3 +220,21 @@ class ModelRouter:update={"model": resolved.primary.provider_model}, deep=True)return RoutedTokenCountRequest(request=routed, resolved=resolved)++ def resolve_responses_request(+ self,+ request: OpenAIResponsesRequest,+ ) -> RoutedResponsesRequest:+ """Route a Responses request without converting its protocol shape."""++ resolved = self.resolve(request.model)+ routed = request.model_copy(deep=True)+ routed.model = resolved.primary.provider_model+ return RoutedResponsesRequest(+ request=routed,+ resolved=resolved,+ reasoning=resolve_responses_reasoning_policy(+ routed,+ resolved.reasoning_preference,+ ),+ )diff --git a/src/free_claude_code/core/anthropic/__init__.py b/src/free_claude_code/core/anthropic/__init__.pyindex e812230c..c1a3160d 100644--- a/src/free_claude_code/core/anthropic/__init__.py+++ b/src/free_claude_code/core/anthropic/__init__.py@@ -35,7 +35,6 @@ from .models import (Tool,Usage,)-from .openai_tool_names import OpenAIToolNameCodecfrom .request_serialization import dump_messages_request, serialize_tool_result_contentfrom .request_snapshot import anthropic_request_snapshotfrom .sse_aggregation import aggregate_anthropic_sse_to_message@@ -72,7 +71,6 @@ __all__ = ["MessagesRequest","MessagesResponse","OpenAIConversionError",- "OpenAIToolNameCodec","ReasoningReplayMode","StreamBlockLedger","SystemContent",diff --git a/src/free_claude_code/core/anthropic/tools.py b/src/free_claude_code/core/anthropic/tools.pyindex 7513e07e..3b56ace5 100644--- a/src/free_claude_code/core/anthropic/tools.py+++ b/src/free_claude_code/core/anthropic/tools.py@@ -10,8 +10,8 @@ from typing import Anyfrom loguru import logger+from ..openai_tool_names import OpenAIToolNameCodecfrom .models import MessagesRequest-from .openai_tool_names import OpenAIToolNameCodecfrom .tool_schema import arguments_match_schema, coerce_text_argument_CONTROL_TOKEN_RE = re.compile(r"<\|[^|>]{1,80}\|>")@@ -43,11 +43,10 @@ class FunctionTagToolParser:"""Parse an exact terminal function-tag envelope into tool use."""def __init__(self, request: MessagesRequest):- self._tool_names = OpenAIToolNameCodec.from_request(request)- self._schemas: dict[str, dict[str, Any]] = {}+ schemas: dict[str, dict[str, Any]] = {}for tool in request.tools or ():if tool.name:- self._schemas[tool.name] = (+ schemas[tool.name] = (tool.input_schemaif tool.input_schema is not Noneelse {"type": "object"}@@ -56,9 +55,41 @@ class FunctionTagToolParser:tool_choice_type = (tool_choice.get("type") if isinstance(tool_choice, dict) else None)+ self._initialize(+ tool_names=OpenAIToolNameCodec.from_request(request),+ schemas=schemas,+ enabled=tool_choice_type != "none",+ )++ @classmethod+ def from_schemas(+ cls,+ *,+ tool_names: OpenAIToolNameCodec,+ schemas: Mapping[str, Mapping[str, Any]],+ enabled: bool,+ ) -> FunctionTagToolParser:+ """Build the parser from a protocol-neutral Chat tool contract."""+ parser = cls.__new__(cls)+ parser._initialize(+ tool_names=tool_names,+ schemas={name: dict(schema) for name, schema in schemas.items()},+ enabled=enabled,+ )+ return parser++ def _initialize(+ self,+ *,+ tool_names: OpenAIToolNameCodec,+ schemas: dict[str, dict[str, Any]],+ enabled: bool,+ ) -> None:+ self._tool_names = tool_names+ self._schemas = schemasself._state = (_FunctionTagState.SEARCHING- if self._schemas and tool_choice_type != "none"+ if self._schemas and enabledelse _FunctionTagState.DISABLED)self._parts: list[str] = []diff --git a/src/free_claude_code/core/openai_responses/__init__.py b/src/free_claude_code/core/openai_responses/__init__.pyindex 48c47383..ac1ea8e6 100644--- a/src/free_claude_code/core/openai_responses/__init__.py+++ b/src/free_claude_code/core/openai_responses/__init__.py@@ -1,24 +1,73 @@-"""OpenAI Responses protocol adapter."""+"""Public OpenAI Responses protocol boundary."""-from .adapter import OpenAIResponsesAdapter+from .chat_request import ResponsesChatRequest, build_responses_chat_requestfrom .errors import (ResponsesConversionError,+ openai_error_from_failure,openai_error_payload,openai_error_type_for_failure,openai_failure_payload,)+from .events import OPENAI_RESPONSES_SSE_HEADERS, committed_response_failure_frame+from .ids import (+ new_call_id,+ new_message_item_id,+ new_reasoning_item_id,+ new_response_id,+)from .models import OpenAIResponsesRequest+from .native import NativeResponsesRelay, build_native_responses_requestfrom .provider_input import build_responses_provider_request-from .provider_stream import ResponsesProviderStream, ResponsesStreamFailure+from .provider_stream import (+ ResponsesProviderStream,+ ResponsesStreamFailure,+ responses_stream_failure_from_event,+)+from .reasoning import responses_reasoning_config, responses_reasoning_policy+from .streaming.blocks import ReasoningBlockState, TextBlockState, ToolBlockState+from .streaming.completion import (+ ResponseBlockCompleter,+ reasoning_output_item,+ tool_item,+)+from .streaming.error_mapping import replay_unsafe_function_call_error+from .streaming.event_builders import ResponseEventBuilder+from .streaming.ledger import ResponsesOutputLedger+from .tokens import estimate_responses_input_tokens+from .tools import responses_tool_identity_from_anthropic_name__all__ = [- "OpenAIResponsesAdapter",+ "OPENAI_RESPONSES_SSE_HEADERS",+ "NativeResponsesRelay","OpenAIResponsesRequest",+ "ReasoningBlockState",+ "ResponseBlockCompleter",+ "ResponseEventBuilder",+ "ResponsesChatRequest","ResponsesConversionError",+ "ResponsesOutputLedger","ResponsesProviderStream","ResponsesStreamFailure",+ "TextBlockState",+ "ToolBlockState",+ "build_native_responses_request",+ "build_responses_chat_request","build_responses_provider_request",+ "committed_response_failure_frame",+ "estimate_responses_input_tokens",+ "new_call_id",+ "new_message_item_id",+ "new_reasoning_item_id",+ "new_response_id",+ "openai_error_from_failure","openai_error_payload","openai_error_type_for_failure","openai_failure_payload",+ "reasoning_output_item",+ "replay_unsafe_function_call_error",+ "responses_reasoning_config",+ "responses_reasoning_policy",+ "responses_stream_failure_from_event",+ "responses_tool_identity_from_anthropic_name",+ "tool_item",]diff --git a/src/free_claude_code/core/openai_responses/adapter.py b/src/free_claude_code/core/openai_responses/adapter.pydeleted file mode 100644index bb0e2ac5..00000000--- a/src/free_claude_code/core/openai_responses/adapter.py+++ /dev/null@@ -1,39 +0,0 @@-"""Facade for OpenAI Responses protocol adaptation."""--from collections.abc import AsyncIterable, AsyncIterator-from typing import Any, ClassVar--from .errors import ResponsesConversionError, openai_error_payload-from .events import OPENAI_RESPONSES_SSE_HEADERS-from .input import convert_request_to_anthropic_payload-from .models import OpenAIResponsesRequest-from .stream import (- PostStartTerminalFailureObserver,- iter_responses_sse_from_anthropic,-)---class OpenAIResponsesAdapter:- """Convert between OpenAI Responses and the proxy's Anthropic core path."""-- ConversionError: ClassVar[type[ResponsesConversionError]] = ResponsesConversionError- sse_headers: ClassVar[dict[str, str]] = OPENAI_RESPONSES_SSE_HEADERS-- def to_anthropic_payload(self, request: OpenAIResponsesRequest) -> dict[str, Any]:- return convert_request_to_anthropic_payload(request)-- def iter_sse_from_anthropic(- self,- chunks: AsyncIterable[Any],- request: OpenAIResponsesRequest,- *,- on_post_start_terminal_failure: PostStartTerminalFailureObserver | None = None,- ) -> AsyncIterator[str]:- return iter_responses_sse_from_anthropic(- chunks,- request,- on_post_start_terminal_failure=on_post_start_terminal_failure,- )-- def error_payload(self, *, message: str, error_type: str) -> dict[str, Any]:- return openai_error_payload(message=message, error_type=error_type)diff --git a/src/free_claude_code/core/openai_responses/anthropic_sse.py b/src/free_claude_code/core/openai_responses/anthropic_sse.pydeleted file mode 100644index 10f47943..00000000--- a/src/free_claude_code/core/openai_responses/anthropic_sse.py+++ /dev/null@@ -1,69 +0,0 @@-"""Anthropic SSE parsing used by the Responses stream adapter."""--import json-import sys-from collections.abc import AsyncIterable, AsyncIterator-from dataclasses import dataclass-from typing import Any--from free_claude_code.core.trace import close_stream_input---@dataclass(slots=True)-class AnthropicSseEvent:- event: str- data: dict[str, Any]---async def iter_sse_events(- chunks: AsyncIterable[Any],-) -> AsyncIterator[AnthropicSseEvent]:- buffer = ""- iterator = aiter(chunks)- try:- async for chunk in iterator:- if isinstance(chunk, bytes):- buffer += chunk.decode("utf-8", errors="replace")- else:- buffer += str(chunk)-- while "\n\n" in buffer:- raw, buffer = buffer.split("\n\n", 1)- event = parse_sse_event(raw)- if event is not None:- yield event-- if buffer.strip():- event = parse_sse_event(buffer)- if event is not None:- yield event- finally:- await close_stream_input(- iterator,- owner="openai_responses.anthropic_sse",- source="core",- preserved_error=sys.exception(),- )---def parse_sse_event(raw: str) -> AnthropicSseEvent | None:- event_type = ""- data_parts: list[str] = []- for line in raw.splitlines():- stripped = line.rstrip("\r")- if stripped.startswith("event:"):- event_type = stripped.split(":", 1)[1].strip()- elif stripped.startswith("data:"):- data_parts.append(stripped.split(":", 1)[1].strip())- if not event_type and not data_parts:- return None- data_text = "\n".join(data_parts)- if data_text == "[DONE]":- return None- try:- parsed = json.loads(data_text) if data_text else {}- except json.JSONDecodeError:- parsed = {"raw": data_text}- if not isinstance(parsed, dict):- parsed = {"value": parsed}- return AnthropicSseEvent(event=event_type, data=parsed)diff --git a/src/free_claude_code/core/openai_responses/chat_request.py b/src/free_claude_code/core/openai_responses/chat_request.pynew file mode 100644index 00000000..6a920f12--- /dev/null+++ b/src/free_claude_code/core/openai_responses/chat_request.py@@ -0,0 +1,688 @@+"""Direct OpenAI Responses-to-Chat Completions request translation."""++import json+from collections.abc import Mapping, Sequence+from dataclasses import dataclass, field++from free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec+from free_claude_code.core.trace import trace_event++from .errors import ResponsesConversionError+from .models import OpenAIResponsesRequest+from .reasoning import (+ combine_reasoning,+ encrypted_reasoning_from_item,+ reasoning_text_from_item,+)+from .tools import (+ call_id_from_item,+ custom_tool_input_text,+ optional_str,+ parse_arguments,+ required_str,+ responses_tool_name_to_anthropic_name,+)++_PASSIVE_TOOL_TYPES = frozenset(+ {+ "computer",+ "file_search",+ "image_generation",+ "local_shell",+ "mcp",+ "tool_search",+ "web_search",+ "web_search_preview",+ }+)+_CHAT_OPTION_FIELDS = (+ "frequency_penalty",+ "logit_bias",+ "logprobs",+ "n",+ "presence_penalty",+ "seed",+ "service_tier",+ "stop",+ "top_logprobs",+)+++@dataclass(frozen=True, slots=True)+class ResponsesChatRequest:+ """One translated Chat body and its reversible tool-name scope."""++ body: dict[str, object]+ tool_names: OpenAIToolNameCodec+ tool_schemas: dict[str, JsonObject]+ reserved_tool_ids: frozenset[str]+++@dataclass(slots=True)+class _PendingReasoning:+ text: str | None = None+ encrypted: list[str] = field(default_factory=list)++ def add(self, item: Mapping[str, JsonValue]) -> None:+ self.text = combine_reasoning(self.text, reasoning_text_from_item(item))+ if encrypted := encrypted_reasoning_from_item(item):+ self.encrypted.append(encrypted)++ @property+ def empty(self) -> bool:+ return self.text is None and not self.encrypted++ def take(self) -> tuple[str | None, list[str]]:+ text = self.text+ encrypted = list(self.encrypted)+ self.text = None+ self.encrypted.clear()+ return text, encrypted+++class _ResponsesChatInputBuilder:+ def __init__(+ self,+ *,+ reasoning_replay: ReasoningReplayMode,+ structured_reasoning_details: bool,+ ) -> None:+ self.system_parts: list[str] = []+ self.messages: list[dict[str, object]] = []+ self._reasoning_replay = reasoning_replay+ self._structured_reasoning_details = structured_reasoning_details+ self._pending_reasoning = _PendingReasoning()+ self._quarantined_call_ids: set[str] = set()++ def add(self, item: JsonValue) -> None:+ if isinstance(item, str):+ self._flush_reasoning()+ self.messages.append({"role": "user", "content": item})+ return+ if not isinstance(item, Mapping):+ return++ item_type = item.get("type")+ if item_type in (None, "message") or "role" in item:+ self._add_message(item)+ return+ if item_type == "reasoning":+ self._pending_reasoning.add(item)+ return+ if item_type in {"function_call", "custom_tool_call"}:+ self._add_tool_call(item, custom=item_type == "custom_tool_call")+ return+ if item_type in {"function_call_output", "custom_tool_call_output"}:+ self._add_tool_output(item, function=item_type == "function_call_output")+ return+ if item_type in {"input_text", "output_text", "text"}:+ self._flush_reasoning()+ self.messages.append({"role": "user", "content": _text_from_part(item)})+ return+ if item_type == "input_image":+ image = _image_part(item)+ if image is not None:+ self._flush_reasoning()+ self.messages.append({"role": "user", "content": [image]})++ def finish(self) -> tuple[list[str], list[dict[str, object]]]:+ self._flush_reasoning()+ return self.system_parts, self.messages++ def _add_message(self, item: Mapping[str, JsonValue]) -> None:+ role = required_str(item.get("role", "user"), "input.role")+ if role in {"developer", "system"}:+ text = _content_text(item.get("content"))+ if text:+ self.system_parts.append(text)+ return+ if role not in {"user", "assistant"}:+ raise ResponsesConversionError(+ f"Unsupported Responses message role: {role!r}"+ )++ if role == "user":+ self._flush_reasoning()+ content = _message_content(item.get("content"), allow_images=role == "user")+ message: dict[str, object] = {"role": role, "content": content}+ if role == "assistant":+ self._apply_pending_reasoning(message)+ if not content and len(message) == 2:+ return+ self.messages.append(message)++ def _add_tool_call(self, item: Mapping[str, JsonValue], *, custom: bool) -> None:+ call_id = call_id_from_item(item)+ name = _tool_identity_name(item)+ if custom:+ arguments = json.dumps(+ {"input": custom_tool_input_text(item.get("input"))},+ separators=(",", ":"),+ )+ else:+ raw_arguments = item.get("arguments")+ try:+ parse_arguments(raw_arguments)+ except ResponsesConversionError as exc:+ self._quarantined_call_ids.add(call_id)+ trace_event(+ stage="responses",+ event="responses.input.function_call_quarantined",+ source="openai_responses",+ call_id=call_id,+ error_type=type(exc).__name__,+ )+ return+ arguments = _arguments_text(raw_arguments)++ message: dict[str, object] | None = self._last_tool_call_message()+ if message is None:+ message = {"role": "assistant", "content": "", "tool_calls": []}+ self._apply_pending_reasoning(message)+ self.messages.append(message)+ elif not self._pending_reasoning.empty:+ self._apply_pending_reasoning(message)++ tool_calls = message.get("tool_calls")+ if not isinstance(tool_calls, list):+ raise AssertionError("assistant tool-call message must contain a list")+ tool_calls.append(+ {+ "id": call_id,+ "type": "function",+ "function": {"name": name, "arguments": arguments},+ }+ )++ def _add_tool_output(+ self, item: Mapping[str, JsonValue], *, function: bool+ ) -> None:+ call_id = call_id_from_item(item)+ if function and call_id in self._quarantined_call_ids:+ return+ if not self._pending_reasoning.empty:+ previous = self._last_tool_call_message()+ if previous is not None:+ self._apply_pending_reasoning(previous)+ else:+ self._flush_reasoning()+ self.messages.append(+ {+ "role": "tool",+ "tool_call_id": call_id,+ "content": _tool_output_text(item.get("output")),+ }+ )++ def _last_tool_call_message(self) -> dict[str, object] | None:+ if not self.messages:+ return None+ message = self.messages[-1]+ if message.get("role") != "assistant" or not isinstance(+ message.get("tool_calls"), list+ ):+ return None+ return message++ def _flush_reasoning(self) -> None:+ if self._pending_reasoning.empty:+ return+ message: dict[str, object] = {"role": "assistant", "content": ""}+ self._apply_pending_reasoning(message)+ if len(message) > 2 or message.get("content"):+ self.messages.append(message)++ def _apply_pending_reasoning(self, message: dict[str, object]) -> None:+ text, encrypted = self._pending_reasoning.take()+ if text is not None:+ _apply_reasoning_text(message, text, self._reasoning_replay)+ if encrypted and self._structured_reasoning_details:+ message["reasoning_details"] = [+ _encrypted_reasoning_detail(value) for value in encrypted+ ]+++def build_responses_chat_request(+ request: OpenAIResponsesRequest,+ *,+ reasoning_replay: ReasoningReplayMode,+ structured_reasoning_details: bool = False,+) -> ResponsesChatRequest:+ """Translate a Responses request directly into one Chat Completions body."""+ builder = _ResponsesChatInputBuilder(+ reasoning_replay=reasoning_replay,+ structured_reasoning_details=structured_reasoning_details,+ )+ if request.instructions:+ builder.system_parts.append(request.instructions)+ for item in _input_items(request.input):+ builder.add(item)+ system_parts, messages = builder.finish()+ if not messages:+ raise ResponsesConversionError(+ "Responses request must contain usable input for Chat Completions"+ )++ body: dict[str, object] = {"model": request.model, "messages": messages}+ if system_parts:+ messages.insert(+ 0,+ {"role": "system", "content": "\n\n".join(system_parts)},+ )++ tools, available_tool_names = _chat_tools(request.tools)+ if request.tool_choice != "none" and tools:+ body["tools"] = tools+ choice = _chat_tool_choice(request.tool_choice, available_tool_names)+ if choice is not None:+ body["tool_choice"] = choice++ if request.parallel_tool_calls is not None and tools:+ body["parallel_tool_calls"] = request.parallel_tool_calls+ if request.max_output_tokens is not None:+ body["max_tokens"] = request.max_output_tokens+ if request.temperature is not None:+ body["temperature"] = request.temperature+ if request.top_p is not None:+ body["top_p"] = request.top_p+ if request.metadata is not None:+ body["metadata"] = request.metadata++ extra = request.model_extra or {}+ for field_name in _CHAT_OPTION_FIELDS:+ value = extra.get(field_name)+ if value is not None:+ body[field_name] = value+ if response_format := _chat_response_format(extra.get("text")):+ body["response_format"] = response_format++ tool_schemas = _body_tool_schemas(body)+ reserved_tool_ids = frozenset(_body_tool_call_ids(body))+ tool_names = OpenAIToolNameCodec.from_names(_body_tool_names(body))+ return ResponsesChatRequest(+ body=body,+ tool_names=tool_names,+ tool_schemas=tool_schemas,+ reserved_tool_ids=reserved_tool_ids,+ )+++def _input_items(value: JsonValue) -> Sequence[JsonValue]:+ if value is None:+ return ()+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):+ return value+ return (value,)+++def _message_content(+ value: JsonValue, *, allow_images: bool+) -> str | list[dict[str, object]]:+ if isinstance(value, str):+ return value+ if not isinstance(value, Sequence) or isinstance(value, bytes | bytearray):+ if isinstance(value, Mapping):+ return _text_from_part(value)+ return ""++ parts: list[dict[str, object]] = []+ for part in value:+ if isinstance(part, str):+ parts.append({"type": "text", "text": part})+ continue+ if not isinstance(part, Mapping):+ continue+ part_type = part.get("type")+ if part_type in {"input_text", "output_text", "text", "refusal"} or (+ "text" in part+ ):+ parts.append({"type": "text", "text": _text_from_part(part)})+ continue+ if (+ allow_images+ and part_type == "input_image"+ and (image := _image_part(part)) is not None+ ):+ parts.append(image)++ if not parts:+ return ""+ if all(part.get("type") == "text" for part in parts):+ return "\n\n".join(str(part.get("text", "")) for part in parts)+ return parts+++def _content_text(value: JsonValue) -> str:+ content = _message_content(value, allow_images=False)+ if isinstance(content, str):+ return content+ return "\n\n".join(+ str(part.get("text", "")) for part in content if isinstance(part, Mapping)+ )+++def _text_from_part(part: Mapping[str, JsonValue]) -> str:+ for key in ("text", "input_text", "output_text", "refusal"):+ value = part.get(key)+ if isinstance(value, str):+ return value+ return ""+++def _image_part(part: Mapping[str, JsonValue]) -> dict[str, object] | None:+ source = part.get("image_url")+ if isinstance(source, str) and source:+ image_url: dict[str, object] = {"url": source}+ elif isinstance(source, Mapping):+ url = source.get("url")+ if not isinstance(url, str) or not url:+ return None+ image_url = {"url": url}+ source_detail = source.get("detail")+ if isinstance(source_detail, str):+ image_url["detail"] = source_detail+ else:+ return None+ detail = part.get("detail")+ if isinstance(detail, str):+ image_url["detail"] = detail+ return {"type": "image_url", "image_url": image_url}+++def _tool_identity_name(item: Mapping[str, JsonValue]) -> str:+ name = required_str(item.get("name"), f"{item.get('type')}.name")+ namespace = optional_str(item.get("namespace"))+ return responses_tool_name_to_anthropic_name(name, namespace=namespace)+++def _arguments_text(value: JsonValue) -> str:+ if isinstance(value, str):+ return value+ return json.dumps(value if value is not None else {}, separators=(",", ":"))+++def _tool_output_text(value: JsonValue) -> str:+ if value is None:+ return ""+ if isinstance(value, str):+ return value+ return json.dumps(value, separators=(",", ":"))+++def _apply_reasoning_text(+ message: dict[str, object], text: str, mode: ReasoningReplayMode+) -> None:+ if mode in {ReasoningReplayMode.REASONING_CONTENT, ReasoningReplayMode.REASONING}:+ message[mode.value] = text+ return+ if mode is not ReasoningReplayMode.THINK_TAGS:+ return+ replay = f"<think>\n{text}\n</think>"+ content = message.get("content")+ if isinstance(content, str) and content:+ message["content"] = f"{replay}\n\n{content}"+ else:+ message["content"] = replay+++def _encrypted_reasoning_detail(value: str) -> object:+ try:+ parsed = json.loads(value)+ except json.JSONDecodeError:+ parsed = None+ if isinstance(parsed, Mapping):+ return dict(parsed)+ if isinstance(parsed, list):+ return parsed+ return {"type": "reasoning.encrypted", "data": value}+++def _chat_tools(+ tools: list[JsonObject] | None,+) -> tuple[list[dict[str, object]], frozenset[str]]:+ converted: list[dict[str, object]] = []+ names: set[str] = set()+ for tool in tools or ():+ tool_type = tool.get("type")+ if tool_type == "function":+ converted_tool, name = _chat_function_tool(tool, namespace=None)+ _append_unique_chat_tool(converted, names, converted_tool, name)+ elif tool_type == "custom":+ converted_tool, name = _chat_custom_tool(tool, namespace=None)+ _append_unique_chat_tool(converted, names, converted_tool, name)+ elif tool_type == "namespace":+ namespace = required_str(tool.get("name"), "tool.namespace.name")+ nested = tool.get("tools")+ if not isinstance(nested, Sequence) or isinstance(+ nested, str | bytes | bytearray+ ):+ raise ResponsesConversionError(+ f"Responses namespace tool {namespace!r} tools must be a list"+ )+ for nested_tool in nested:+ if not isinstance(nested_tool, Mapping):+ continue+ nested_type = nested_tool.get("type")+ if nested_type == "function":+ converted_tool, name = _chat_function_tool(+ nested_tool, namespace=namespace+ )+ elif nested_type == "custom":+ converted_tool, name = _chat_custom_tool(+ nested_tool, namespace=namespace+ )+ else:+ continue+ _append_unique_chat_tool(converted, names, converted_tool, name)+ elif isinstance(tool_type, str) and tool_type in _PASSIVE_TOOL_TYPES:+ continue+ return converted, frozenset(names)+++def _append_unique_chat_tool(+ converted: list[dict[str, object]],+ names: set[str],+ tool: dict[str, object],+ name: str,+) -> None:+ if name in names:+ raise ResponsesConversionError(+ f"Responses tools map to the same Chat-compatible name {name!r}"+ )+ converted.append(tool)+ names.add(name)+++def _chat_function_tool(+ tool: Mapping[str, JsonValue], *, namespace: str | None+) -> tuple[dict[str, object], str]:+ nested = tool.get("function")+ source = nested if isinstance(nested, Mapping) else tool+ name = required_str(source.get("name"), "tool.name")+ wire_name = responses_tool_name_to_anthropic_name(name, namespace=namespace)+ parameters = source.get("parameters")+ if parameters is None:+ parameters = {"type": "object", "properties": {}}+ if not isinstance(parameters, Mapping):+ raise ResponsesConversionError(+ f"Responses tool {name!r} parameters must be an object"+ )+ function: dict[str, object] = {+ "name": wire_name,+ "parameters": dict(parameters),+ }+ if description := optional_str(source.get("description")):+ function["description"] = description+ strict = source.get("strict")+ if isinstance(strict, bool):+ function["strict"] = strict+ return {"type": "function", "function": function}, wire_name+++def _chat_custom_tool(+ tool: Mapping[str, JsonValue], *, namespace: str | None+) -> tuple[dict[str, object], str]:+ nested = tool.get("custom")+ source = nested if isinstance(nested, Mapping) else tool+ name = required_str(source.get("name"), "tool.name")+ wire_name = responses_tool_name_to_anthropic_name(name, namespace=namespace)+ function: dict[str, object] = {+ "name": wire_name,+ "parameters": {+ "type": "object",+ "properties": {+ "input": {+ "type": "string",+ "description": "Free-form input for the custom tool.",+ }+ },+ "required": ["input"],+ },+ }+ if description := _custom_tool_description(source):+ function["description"] = description+ return {"type": "function", "function": function}, wire_name+++def _custom_tool_description(source: Mapping[str, JsonValue]) -> str | None:+ parts: list[str] = []+ if description := optional_str(source.get("description")):+ parts.append(description)+ format_value = source.get("format")+ if isinstance(format_value, Mapping):+ format_type = optional_str(format_value.get("type"))+ if format_type == "text":+ parts.append("Custom tool input format: unconstrained text.")+ elif format_type == "grammar":+ syntax = optional_str(format_value.get("syntax"))+ definition = optional_str(format_value.get("definition"))+ guidance = "Custom tool input format: grammar"+ if syntax:+ guidance = f"{guidance} ({syntax})"+ guidance = f"{guidance}: {definition}" if definition else f"{guidance}."+ parts.append(guidance)+ return "\n\n".join(parts) if parts else None+++def _chat_tool_choice(+ value: JsonValue, available_names: frozenset[str]+) -> object | None:+ if not available_names:+ return None+ if value is None or value == "auto":+ return "auto"+ if value == "required":+ return "required"+ if value == "none":+ return None+ if not isinstance(value, Mapping):+ return None+ choice_type = value.get("type")+ if choice_type in {"auto", "any", "required"}:+ return "required" if choice_type in {"any", "required"} else "auto"+ if choice_type not in {"function", "custom", "tool"}:+ return None+ source = value.get("custom")+ choice = source if isinstance(source, Mapping) else value+ name = optional_str(choice.get("name"))+ if not name:+ return None+ namespace = optional_str(choice.get("namespace")) or optional_str(+ value.get("namespace")+ )+ wire_name = responses_tool_name_to_anthropic_name(name, namespace=namespace)+ if wire_name not in available_names:+ return None+ return {"type": "function", "function": {"name": wire_name}}+++def _chat_response_format(value: JsonValue) -> object | None:+ if not isinstance(value, Mapping):+ return None+ format_value = value.get("format")+ if not isinstance(format_value, Mapping):+ return None+ format_type = format_value.get("type")+ if format_type in {"text", "json_object"}:+ return {"type": format_type}+ if format_type != "json_schema":+ return None+ json_schema = {+ key: format_value[key]+ for key in ("name", "description", "schema", "strict")+ if key in format_value+ }+ return {"type": "json_schema", "json_schema": json_schema}+++def _body_tool_names(body: Mapping[str, object]) -> list[str]:+ names: list[str] = []+ tools = body.get("tools")+ if isinstance(tools, list):+ for tool in tools:+ if not isinstance(tool, Mapping):+ continue+ function = tool.get("function")+ if isinstance(function, Mapping) and isinstance(function.get("name"), str):+ names.append(function["name"])+ messages = body.get("messages")+ if isinstance(messages, list):+ for message in messages:+ if not isinstance(message, Mapping):+ continue+ calls = message.get("tool_calls")+ if not isinstance(calls, list):+ continue+ for call in calls:+ if not isinstance(call, Mapping):+ continue+ function = call.get("function")+ if isinstance(function, Mapping) and isinstance(+ function.get("name"), str+ ):+ names.append(function["name"])+ choice = body.get("tool_choice")+ if isinstance(choice, Mapping):+ function = choice.get("function")+ if isinstance(function, Mapping) and isinstance(function.get("name"), str):+ names.append(function["name"])+ return names+++def _body_tool_schemas(body: Mapping[str, object]) -> dict[str, JsonObject]:+ schemas: dict[str, JsonObject] = {}+ tools = body.get("tools")+ if not isinstance(tools, list):+ return schemas+ for tool in tools:+ if not isinstance(tool, Mapping):+ continue+ function = tool.get("function")+ if not isinstance(function, Mapping):+ continue+ name = function.get("name")+ parameters = function.get("parameters")+ if isinstance(name, str) and isinstance(parameters, Mapping):+ schemas[name] = dict(parameters)+ return schemas+++def _body_tool_call_ids(body: Mapping[str, object]) -> list[str]:+ call_ids: list[str] = []+ messages = body.get("messages")+ if not isinstance(messages, list):+ return call_ids+ for message in messages:+ if not isinstance(message, Mapping):+ continue+ calls = message.get("tool_calls")+ if not isinstance(calls, list):+ continue+ call_ids.extend(+ call["id"]+ for call in calls+ if isinstance(call, Mapping) and isinstance(call.get("id"), str)+ )+ return call_idsdiff --git a/src/free_claude_code/core/openai_responses/events.py b/src/free_claude_code/core/openai_responses/events.pyindex 0cbec427..75d8a330 100644--- a/src/free_claude_code/core/openai_responses/events.py+++ b/src/free_claude_code/core/openai_responses/events.py@@ -2,7 +2,14 @@import jsonfrom collections.abc import Mapping-from typing import Any+from copy import deepcopy+from typing import Any, cast++from free_claude_code.core.diagnostics import safe_exception_message+from free_claude_code.core.failures import find_execution_failure+from free_claude_code.core.json_types import JsonObject, JsonValue++from .errors import openai_error_from_failure, openai_error_payloadOPENAI_RESPONSES_SSE_HEADERS: dict[str, str] = {"X-Accel-Buffering": "no",@@ -15,3 +22,59 @@ def format_response_sse_event(event_type: str, data: Mapping[str, Any]) -> str:"""Format one OpenAI Responses SSE event."""return f"event: {event_type}\ndata: {json.dumps(data)}\n\n"+++def committed_response_failure_frame(+ first_chunk: str,+ latest_chunk: str,+ exc: BaseException,+) -> str:+ """Close an already-public Responses lifecycle after a boundary failure."""++ created = _response_event_payload(first_chunk)+ response_value = created.get("response") if created is not None else None+ if not isinstance(response_value, Mapping) or not isinstance(+ response_value.get("id"), str+ ):+ raise exc++ response = cast(JsonObject, deepcopy(dict(response_value)))+ failure = find_execution_failure(exc)+ if failure is not None:+ error = openai_error_from_failure(failure)+ else:+ error = openai_error_payload(+ message=safe_exception_message(exc),+ error_type="api_error",+ )["error"]+ response["status"] = "failed"+ response["error"] = cast(JsonValue, error)++ latest = _response_event_payload(latest_chunk)+ sequence_number = latest.get("sequence_number") if latest is not None else None+ next_sequence_number = (+ sequence_number + 1+ if isinstance(sequence_number, int) and not isinstance(sequence_number, bool)+ else 1+ )+ return format_response_sse_event(+ "response.failed",+ {+ "type": "response.failed",+ "sequence_number": next_sequence_number,+ "response": response,+ },+ )+++def _response_event_payload(chunk: str) -> JsonObject | None:+ for line in reversed(chunk.splitlines()):+ if not line.startswith("data:"):+ continue+ try:+ raw: object = json.loads(line.removeprefix("data:").lstrip())+ except json.JSONDecodeError:+ continue+ if isinstance(raw, Mapping):+ return cast(JsonObject, dict(raw))+ return Nonediff --git a/src/free_claude_code/core/openai_responses/input.py b/src/free_claude_code/core/openai_responses/input.pydeleted file mode 100644index d824c567..00000000--- a/src/free_claude_code/core/openai_responses/input.py+++ /dev/null@@ -1,415 +0,0 @@-"""Convert OpenAI Responses requests into Anthropic Messages payloads."""--from collections.abc import Mapping-from dataclasses import dataclass, field-from typing import Any--from free_claude_code.core.trace import trace_event--from .errors import ResponsesConversionError-from .models import OpenAIResponsesRequest-from .reasoning import (- combine_reasoning,- encrypted_reasoning_from_item,- reasoning_text_from_item,- responses_reasoning_to_output_config,-)-from .tools import (- call_id_from_item,- convert_tool_choice,- convert_tools,- custom_tool_input_to_anthropic,- optional_str,- parse_arguments,- required_str,- responses_tool_name_to_anthropic_name,-)---@dataclass(slots=True)-class _PendingReasoning:- text: str | None = None- encrypted: list[str] = field(default_factory=list)-- def add_item(self, item: Mapping[str, Any]) -> None:- self.text = combine_reasoning(self.text, reasoning_text_from_item(item))- if encrypted := encrypted_reasoning_from_item(item):- self.encrypted.append(encrypted)-- def take(self) -> tuple[str | None, list[dict[str, str]]]:- text = self.text- blocks = [- {"type": "redacted_thinking", "data": encrypted}- for encrypted in self.encrypted- ]- self.text = None- self.encrypted.clear()- return text, blocks---def convert_request_to_anthropic_payload(- request: OpenAIResponsesRequest,-) -> dict[str, Any]:- """Convert an OpenAI Responses request into an Anthropic Messages payload."""-- system_parts: list[str] = []- if instructions := request.instructions:- system_parts.append(instructions)-- messages: list[dict[str, Any]] = []- pending_reasoning = _PendingReasoning()- quarantined_function_call_ids: set[str] = set()- for item in _iter_input_items(request.input):- _append_input_item(- item,- messages=messages,- system_parts=system_parts,- pending_reasoning=pending_reasoning,- quarantined_function_call_ids=quarantined_function_call_ids,- )- _append_pending_reasoning(messages, pending_reasoning)-- if not messages:- raise ResponsesConversionError("Responses request input must contain a message")-- payload: dict[str, Any] = {- "model": required_str(request.model, "model"),- "messages": messages,- "stream": True,- }- if system_parts:- payload["system"] = "\n\n".join(system_parts)- if request.temperature is not None:- payload["temperature"] = request.temperature- if request.top_p is not None:- payload["top_p"] = request.top_p- if request.max_output_tokens is not None:- payload["max_tokens"] = request.max_output_tokens- if request.metadata is not None:- payload["metadata"] = request.metadata-- if output_config := responses_reasoning_to_output_config(request.reasoning):- payload["output_config"] = output_config-- raw_tool_choice = request.tool_choice- tools = convert_tools(request.tools)- if tools and raw_tool_choice != "none":- payload["tools"] = tools- tool_choice = convert_tool_choice(raw_tool_choice)- if tool_choice is not None:- payload["tool_choice"] = tool_choice-- return payload---def _append_input_item(- item: Any,- *,- messages: list[dict[str, Any]],- system_parts: list[str],- pending_reasoning: _PendingReasoning,- quarantined_function_call_ids: set[str],-) -> None:- if isinstance(item, str):- _append_pending_reasoning(messages, pending_reasoning)- messages.append({"role": "user", "content": item})- return- if not isinstance(item, dict):- raise ResponsesConversionError(- f"Unsupported Responses input item: {type(item).__name__}"- )-- item_type = item.get("type")- if item_type in (None, "message") or "role" in item:- role = required_str(item.get("role", "user"), "input.role")- if role == "assistant":- _append_message_item(- role,- item.get("content", ""),- messages,- system_parts,- reasoning_content=pending_reasoning,- )- return- _append_pending_reasoning(messages, pending_reasoning)- _append_message_item(role, item.get("content", ""), messages, system_parts)- return- if item_type in {"function_call", "custom_tool_call"}:- namespace = optional_str(item.get("namespace"))- field_name = f"{item_type}.name"- name = required_str(item.get("name"), field_name)- call_id = call_id_from_item(item)- if item_type == "custom_tool_call":- tool_input = custom_tool_input_to_anthropic(item.get("input"))- else:- try:- tool_input = parse_arguments(item.get("arguments"))- except ResponsesConversionError as exc:- quarantined_function_call_ids.add(call_id)- _trace_quarantined_function_call(call_id, exc)- return- tool_use = {- "type": "tool_use",- "id": call_id,- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),- "input": tool_input,- }- _append_tool_use_message(- messages,- tool_use,- reasoning_content=pending_reasoning,- )- return- if item_type in {"function_call_output", "custom_tool_call_output"}:- call_id = call_id_from_item(item)- if (- item_type == "function_call_output"- and call_id in quarantined_function_call_ids- ):- return- _append_pending_reasoning_before_tool_output(messages, pending_reasoning)- _append_tool_result_message(- messages,- {- "type": "tool_result",- "tool_use_id": call_id,- "content": item.get("output", ""),- },- )- return- if item_type == "reasoning":- pending_reasoning.add_item(item)- return- if item_type in {"input_text", "output_text", "text"}:- _append_pending_reasoning(messages, pending_reasoning)- messages.append({"role": "user", "content": _text_from_part(item)})- return-- raise ResponsesConversionError(- f"Unsupported Responses input item type: {item_type!r}"- )---def _trace_quarantined_function_call(- call_id: str, exc: ResponsesConversionError-) -> None:- trace_event(- stage="responses",- event="responses.input.function_call_quarantined",- source="openai_responses",- call_id=call_id,- error_type=type(exc).__name__,- )---def _append_message_item(- role: str,- content: Any,- messages: list[dict[str, Any]],- system_parts: list[str],- *,- reasoning_content: _PendingReasoning | None = None,-) -> None:- normalized_role = "system" if role == "developer" else role- if normalized_role == "system":- text = _content_as_text(content)- if text:- system_parts.append(text)- return- if normalized_role not in {"user", "assistant"}:- raise ResponsesConversionError(f"Unsupported Responses message role: {role!r}")- converted_content = _convert_message_content(content)- reasoning_text: str | None = None- reasoning_blocks: list[dict[str, str]] = []- if normalized_role == "assistant" and reasoning_content is not None:- reasoning_text, reasoning_blocks = reasoning_content.take()- if reasoning_blocks:- if isinstance(converted_content, str):- converted_blocks: list[dict[str, Any]] = list(reasoning_blocks)- if converted_content:- converted_blocks.append({"type": "text", "text": converted_content})- converted_content = converted_blocks- else:- converted_content = [*reasoning_blocks, *converted_content]- message = {- "role": normalized_role,- "content": converted_content,- }- if reasoning_text is not None:- message["reasoning_content"] = reasoning_text- messages.append(message)---def _append_pending_reasoning(- messages: list[dict[str, Any]], pending_reasoning: _PendingReasoning-) -> None:- reasoning_text, reasoning_blocks = pending_reasoning.take()- if reasoning_text is None and not reasoning_blocks:- return- message: dict[str, Any] = {- "role": "assistant",- "content": reasoning_blocks or "",- }- if reasoning_text is not None:- message["reasoning_content"] = reasoning_text- messages.append(message)---def _append_pending_reasoning_before_tool_output(- messages: list[dict[str, Any]], pending_reasoning: _PendingReasoning-) -> None:- if pending_reasoning.text is None and not pending_reasoning.encrypted:- return- message = _last_assistant_tool_use_message(messages)- if message is None:- _append_pending_reasoning(messages, pending_reasoning)- return- reasoning_text, reasoning_blocks = pending_reasoning.take()- if reasoning_text is not None:- _merge_message_reasoning(message, reasoning_text)- _prepend_reasoning_blocks(message, reasoning_blocks)---def _append_tool_use_message(- messages: list[dict[str, Any]],- tool_use: dict[str, Any],- *,- reasoning_content: _PendingReasoning,-) -> None:- message = _last_assistant_tool_use_message(messages)- if message is None:- message = {"role": "assistant", "content": []}- messages.append(message)- reasoning_text, reasoning_blocks = reasoning_content.take()- if reasoning_text is not None:- _merge_message_reasoning(message, reasoning_text)- _prepend_reasoning_blocks(message, reasoning_blocks)- content = message["content"]- if isinstance(content, list):- content.append(tool_use)---def _append_tool_result_message(- messages: list[dict[str, Any]],- tool_result: dict[str, Any],-) -> None:- message = _last_user_tool_result_message(messages)- if message is None:- message = {"role": "user", "content": []}- messages.append(message)- content = message["content"]- if isinstance(content, list):- content.append(tool_result)---def _last_assistant_tool_use_message(- messages: list[dict[str, Any]],-) -> dict[str, Any] | None:- if not messages:- return None- message = messages[-1]- if message.get("role") != "assistant":- return None- content = message.get("content")- if not isinstance(content, list) or not content:- return None- block_types = [- block.get("type") if isinstance(block, dict) else None for block in content- ]- if "tool_use" in block_types and all(- block_type in {"redacted_thinking", "thinking", "tool_use"}- for block_type in block_types- ):- return message- return None---def _last_user_tool_result_message(- messages: list[dict[str, Any]],-) -> dict[str, Any] | None:- if not messages:- return None- message = messages[-1]- if message.get("role") != "user":- return None- content = message.get("content")- if not isinstance(content, list) or not content:- return None- if all(- isinstance(block, dict) and block.get("type") == "tool_result"- for block in content- ):- return message- return None---def _merge_message_reasoning(message: dict[str, Any], reasoning: str) -> None:- existing = message.get("reasoning_content")- existing_reasoning = existing if isinstance(existing, str) else None- message["reasoning_content"] = combine_reasoning(existing_reasoning, reasoning)---def _prepend_reasoning_blocks(- message: dict[str, Any], blocks: list[dict[str, str]]-) -> None:- if not blocks:- return- content = message.get("content")- if isinstance(content, list):- content[:0] = blocks---def _iter_input_items(value: Any) -> list[Any]:- if value is None:- return []- if isinstance(value, list):- return value- return [value]---def _convert_message_content(content: Any) -> str | list[dict[str, Any]]:- if isinstance(content, str):- return content- if isinstance(content, list):- blocks: list[dict[str, Any]] = []- for part in content:- if isinstance(part, str):- blocks.append({"type": "text", "text": part})- continue- if not isinstance(part, dict):- raise ResponsesConversionError(- f"Unsupported Responses content part: {type(part).__name__}"- )- part_type = part.get("type")- if part_type in {"input_text", "output_text", "text"} or "text" in part:- blocks.append({"type": "text", "text": _text_from_part(part)})- continue- if part_type == "refusal":- blocks.append({"type": "text", "text": str(part.get("refusal", ""))})- continue- raise ResponsesConversionError(- f"Unsupported Responses content part type: {part_type!r}"- )- return blocks- if isinstance(content, dict):- return [{"type": "text", "text": _text_from_part(content)}]- raise ResponsesConversionError(- f"Unsupported Responses message content: {type(content).__name__}"- )---def _content_as_text(content: Any) -> str:- converted = _convert_message_content(content)- if isinstance(converted, str):- return converted- return "\n".join(str(block.get("text", "")) for block in converted)---def _text_from_part(part: Mapping[str, Any]) -> str:- if text := optional_str(part.get("text")):- return text- if text := optional_str(part.get("input_text")):- return text- if text := optional_str(part.get("output_text")):- return text- return ""diff --git a/src/free_claude_code/core/openai_responses/models.py b/src/free_claude_code/core/openai_responses/models.pyindex ec80b446..3bce877a 100644--- a/src/free_claude_code/core/openai_responses/models.py+++ b/src/free_claude_code/core/openai_responses/models.py@@ -1,9 +1,9 @@"""Pydantic models for OpenAI Responses-compatible ingress."""-from typing import Any-from pydantic import BaseModel, ConfigDict+from free_claude_code.core.json_types import JsonObject, JsonValue+class OpenAIResponsesRequest(BaseModel):"""Permissive subset of the OpenAI Responses API request shape."""@@ -11,16 +11,16 @@ class OpenAIResponsesRequest(BaseModel):model_config = ConfigDict(extra="allow")model: str- input: Any = None+ input: JsonValue = Noneinstructions: str | None = None- tools: list[dict[str, Any]] | None = None- tool_choice: Any = None+ tools: list[JsonObject] | None = None+ tool_choice: JsonValue = Noneparallel_tool_calls: bool | None = Nonestream: bool | None = Truetemperature: float | None = Nonetop_p: float | None = Nonemax_output_tokens: int | None = None- metadata: dict[str, Any] | None = None- reasoning: dict[str, Any] | None = None+ metadata: JsonObject | None = None+ reasoning: JsonObject | None = Noneprevious_response_id: str | None = Nonestore: bool | None = Nonediff --git a/src/free_claude_code/core/openai_responses/native.py b/src/free_claude_code/core/openai_responses/native.pynew file mode 100644index 00000000..5cd95512--- /dev/null+++ b/src/free_claude_code/core/openai_responses/native.py@@ -0,0 +1,126 @@+"""Native OpenAI Responses request and event handling."""++import uuid+from collections.abc import Mapping+from copy import deepcopy+from typing import cast++from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.core.reasoning import ReasoningPolicy++from .errors import openai_error_from_failure+from .events import format_response_sse_event+from .models import OpenAIResponsesRequest+from .reasoning import responses_reasoning_config, responses_reasoning_policy++_TERMINAL_EVENT_TYPES = frozenset(+ {"response.completed", "response.incomplete", "response.failed"}+)+++def build_native_responses_request(+ request: OpenAIResponsesRequest,+ *,+ model: str,+ reasoning: ReasoningPolicy,+) -> JsonObject:+ """Build the stateless upstream body without translating Responses input."""++ body = cast(+ JsonObject,+ request.model_dump(mode="json", exclude_none=True),+ )+ body["model"] = model+ body["stream"] = True+ body["store"] = False+ body.pop("previous_response_id", None)+ if reasoning != responses_reasoning_policy(request.reasoning):+ if reasoning_config := responses_reasoning_config(reasoning):+ body["reasoning"] = reasoning_config+ else:+ body.pop("reasoning", None)+ return body+++class NativeResponsesRelay:+ """Relay one native Responses lifecycle while retaining upstream identity."""++ def __init__(self, *, public_model: str) -> None:+ self._public_model = public_model+ self._response: JsonObject | None = None+ self._response_id: str | None = None+ self._terminal_type: str | None = None+ self._next_sequence_number = 0++ @property+ def response_id(self) -> str | None:+ return self._response_id++ @property+ def terminal_type(self) -> str | None:+ return self._terminal_type++ @property+ def completed(self) -> bool:+ return self._terminal_type is not None++ def feed(self, event_type: str, payload: Mapping[str, object]) -> str:+ """Format one upstream event after rewriting FCC-owned model metadata."""++ if self._terminal_type is not None:+ raise ValueError(+ f"Responses event {event_type!r} arrived after terminal "+ f"event {self._terminal_type!r}."+ )+ data = cast(JsonObject, deepcopy(dict(payload)))+ response = data.get("response")+ if isinstance(response, dict):+ response["model"] = self._public_model+ self._response = cast(JsonObject, deepcopy(response))+ response_id = response.get("id")+ if isinstance(response_id, str) and response_id:+ self._response_id = response_id+ sequence_number = data.get("sequence_number")+ if isinstance(sequence_number, int) and not isinstance(sequence_number, bool):+ self._next_sequence_number = max(+ self._next_sequence_number,+ sequence_number + 1,+ )+ if event_type in _TERMINAL_EVENT_TYPES:+ self._terminal_type = event_type+ return format_response_sse_event(event_type, data)++ def synthesize_failure(self, failure: ExecutionFailure) -> str:+ """Terminate one already-public truncated stream with a safe failure."""++ if self._terminal_type is not None:+ raise ValueError(+ f"Cannot synthesize failure after {self._terminal_type!r}."+ )+ response = (+ deepcopy(self._response)+ if self._response is not None+ else cast(+ JsonObject,+ {+ "id": self._response_id or f"resp_{uuid.uuid4().hex}",+ "object": "response",+ "output": [],+ },+ )+ )+ response["id"] = (+ self._response_id or response.get("id") or (f"resp_{uuid.uuid4().hex}")+ )+ response["model"] = self._public_model+ response["status"] = "failed"+ response["error"] = cast(JsonValue, openai_error_from_failure(failure))+ return self.feed(+ "response.failed",+ {+ "type": "response.failed",+ "sequence_number": self._next_sequence_number,+ "response": response,+ },+ )diff --git a/src/free_claude_code/core/openai_responses/provider_input.py b/src/free_claude_code/core/openai_responses/provider_input.pyindex f18030e5..13cd4034 100644--- a/src/free_claude_code/core/openai_responses/provider_input.py+++ b/src/free_claude_code/core/openai_responses/provider_input.py@@ -6,13 +6,14 @@ from typing import Anyfrom free_claude_code.core.anthropic.content import get_block_attr, get_block_typefrom free_claude_code.core.anthropic.conversion import resolve_anthropic_tool_choicefrom free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.anthropic.request_serialization import (serialize_tool_result_content,)-from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec+from free_claude_code.core.reasoning import ReasoningPolicyfrom .errors import ResponsesConversionError+from .reasoning import responses_reasoning_configdef build_responses_provider_request(@@ -78,7 +79,7 @@ def build_responses_provider_request(tool_choice = resolve_anthropic_tool_choice(request.tools, request.tool_choice)if tool_choice is not None:body["tool_choice"] = _tool_choice(tool_choice, tool_names=tool_names)- if reasoning_config := _reasoning_config(reasoning):+ if reasoning_config := responses_reasoning_config(reasoning):body["reasoning"] = reasoning_configreturn body@@ -340,13 +341,3 @@ def _tool_choice(raise ResponsesConversionError("Forced tool choice requires a tool name.")return {"type": "function", "name": tool_names.encode(name)}raise ResponsesConversionError(f"Unsupported tool_choice type {choice_type!r}.")---def _reasoning_config(reasoning: ReasoningPolicy) -> dict[str, str]:- if reasoning.control is ReasoningControl.OFF:- return {"effort": "none"}- if reasoning.effort is not None:- return {"effort": reasoning.effort.value, "summary": "auto"}- if reasoning.requests_reasoning:- return {"summary": "auto"}- return {}diff --git a/src/free_claude_code/core/openai_responses/provider_stream.py b/src/free_claude_code/core/openai_responses/provider_stream.pyindex 960c5411..eed75314 100644--- a/src/free_claude_code/core/openai_responses/provider_stream.py+++ b/src/free_claude_code/core/openai_responses/provider_stream.py@@ -3,17 +3,26 @@from dataclasses import dataclassfrom typing import Any-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.anthropic.streaming import AnthropicStreamLedger+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecclass ResponsesStreamFailure(RuntimeError):"""An upstream Responses stream reported a terminal failure."""- def __init__(self, message: str, *, code: str | None = None) -> None:+ def __init__(+ self,+ message: str,+ *,+ code: str | None = None,+ event_type: str | None = None,+ payload: dict[str, Any] | None = None,+ ) -> None:super().__init__(message)self.message = messageself.code = code+ self.event_type = event_type+ self.payload = payload@dataclass(slots=True)@@ -76,7 +85,7 @@ class ResponsesProviderStream:if event_type in {"response.completed", "response.incomplete"}:return self._finish(data, incomplete=event_type == "response.incomplete")if event_type in {"response.failed", "error", "response.error"}:- raise _stream_failure(data)+ raise responses_stream_failure_from_event(event_type, data)return []def _item_added(self, data: dict[str, Any]) -> list[str]:@@ -233,7 +242,12 @@ class ResponsesProviderStream:return events-def _stream_failure(data: dict[str, Any]) -> ResponsesStreamFailure:+def responses_stream_failure_from_event(+ event_type: str,+ data: dict[str, Any],+) -> ResponsesStreamFailure:+ """Retain one native failure event for provider-owned retry decisions."""+response = data.get("response")response = response if isinstance(response, dict) else {}error = response.get("error", data.get("error"))@@ -243,6 +257,8 @@ def _stream_failure(data: dict[str, Any]) -> ResponsesStreamFailure:return ResponsesStreamFailure(message if isinstance(message, str) and message else "OpenAI response failed.",code=code if isinstance(code, str) else None,+ event_type=event_type,+ payload=data,)diff --git a/src/free_claude_code/core/openai_responses/reasoning.py b/src/free_claude_code/core/openai_responses/reasoning.pyindex 5617a0e4..b40cadff 100644--- a/src/free_claude_code/core/openai_responses/reasoning.py+++ b/src/free_claude_code/core/openai_responses/reasoning.py@@ -3,6 +3,12 @@from collections.abc import Mappingfrom typing import Any+from free_claude_code.core.reasoning import (+ ReasoningControl,+ ReasoningEffort,+ ReasoningPolicy,+)+from .tools import optional_str@@ -48,6 +54,39 @@ def responses_reasoning_to_output_config(value: Any) -> dict[str, Any] | None:return None+def responses_reasoning_policy(value: object) -> ReasoningPolicy:+ """Parse the supported reasoning intent from a Responses request field."""++ if not isinstance(value, Mapping):+ return ReasoningPolicy.provider_default()+ raw_effort = value.get("effort")+ if not isinstance(raw_effort, str):+ return ReasoningPolicy.provider_default()+ normalized = raw_effort.strip().lower()+ if normalized == "none":+ return ReasoningPolicy.off()+ try:+ effort = ReasoningEffort(normalized)+ except ValueError:+ return ReasoningPolicy.provider_default()+ return ReasoningPolicy(+ control=ReasoningControl.DEFAULT,+ effort=effort,+ )+++def responses_reasoning_config(reasoning: ReasoningPolicy) -> dict[str, str]:+ """Encode resolved reasoning intent for an upstream Responses request."""++ if reasoning.control is ReasoningControl.OFF:+ return {"effort": "none"}+ if reasoning.effort is not None:+ return {"effort": reasoning.effort.value, "summary": "auto"}+ if reasoning.requests_reasoning:+ return {"summary": "auto"}+ return {}++def _text_parts_from_items(value: Any, *, item_type: str) -> list[str]:if not isinstance(value, list):return []diff --git a/src/free_claude_code/core/openai_responses/stream.py b/src/free_claude_code/core/openai_responses/stream.pydeleted file mode 100644index 833c31e1..00000000--- a/src/free_claude_code/core/openai_responses/stream.py+++ /dev/null@@ -1,92 +0,0 @@-"""Translate Anthropic SSE streams into OpenAI Responses SSE streams."""--import asyncio-import sys-from collections.abc import AsyncIterable, AsyncIterator, Callable-from typing import Any--from free_claude_code.core.diagnostics import safe_exception_message-from free_claude_code.core.failures import ExecutionFailure, find_execution_failure-from free_claude_code.core.trace import close_stream_input--from .anthropic_sse import iter_sse_events-from .models import OpenAIResponsesRequest-from .streaming import ResponsesStreamAssembler--PostStartTerminalFailureObserver = Callable[[BaseException], None]---async def iter_responses_sse_from_anthropic(- chunks: AsyncIterable[Any],- request: OpenAIResponsesRequest,- *,- on_post_start_terminal_failure: PostStartTerminalFailureObserver | None = None,-) -> AsyncIterator[str]:- """Yield Responses SSE events translated from an Anthropic SSE stream."""- assembler = ResponsesStreamAssembler(request)- emitted_any_chunk = False- events = iter_sse_events(chunks)- try:- async for event in events:- for chunk in assembler.process_anthropic_event(event):- yield chunk- emitted_any_chunk = True- if assembler.terminal:- return- for chunk in assembler.finish_if_needed():- yield chunk- emitted_any_chunk = True- except GeneratorExit:- raise- except asyncio.CancelledError:- raise- except ExecutionFailure as exc:- if not emitted_any_chunk:- raise- _observe_post_start_terminal_failure(on_post_start_terminal_failure, exc)- for chunk in assembler.fail_execution(exc):- yield chunk- except BaseExceptionGroup as exc:- if not emitted_any_chunk:- raise- failure = find_execution_failure(exc)- if failure is not None:- _observe_post_start_terminal_failure(- on_post_start_terminal_failure, failure- )- for chunk in assembler.fail_execution(failure):- yield chunk- else:- _observe_post_start_terminal_failure(on_post_start_terminal_failure, exc)- for chunk in assembler.fail_response(_unexpected_error_data(exc)):- yield chunk- except Exception as exc:- if not emitted_any_chunk:- raise- _observe_post_start_terminal_failure(on_post_start_terminal_failure, exc)- for chunk in assembler.fail_response(_unexpected_error_data(exc)):- yield chunk- finally:- await close_stream_input(- events,- owner="openai_responses.stream",- source="core",- preserved_error=sys.exception(),- )---def _observe_post_start_terminal_failure(- observer: PostStartTerminalFailureObserver | None,- exc: BaseException,-) -> None:- if observer is not None:- observer(exc)---def _unexpected_error_data(exc: BaseException) -> dict[str, dict[str, str]]:- return {- "error": {- "type": "api_error",- "message": safe_exception_message(exc),- }- }diff --git a/src/free_claude_code/core/openai_responses/streaming/__init__.py b/src/free_claude_code/core/openai_responses/streaming/__init__.pyindex fc3056aa..2cc9f143 100644--- a/src/free_claude_code/core/openai_responses/streaming/__init__.py+++ b/src/free_claude_code/core/openai_responses/streaming/__init__.py@@ -1,5 +1 @@-"""OpenAI Responses streaming assembly internals."""--from .assembler import ResponsesStreamAssembler--__all__ = ["ResponsesStreamAssembler"]+"""OpenAI Responses streaming primitives."""diff --git a/src/free_claude_code/core/openai_responses/streaming/assembler.py b/src/free_claude_code/core/openai_responses/streaming/assembler.pydeleted file mode 100644index 557c774a..00000000--- a/src/free_claude_code/core/openai_responses/streaming/assembler.py+++ /dev/null@@ -1,386 +0,0 @@-"""Anthropic SSE to OpenAI Responses stream assembly."""--import json-import time-import uuid-from collections.abc import Mapping-from typing import Any--from free_claude_code.core.failures import ExecutionFailure-from free_claude_code.core.trace import trace_event--from ..anthropic_sse import AnthropicSseEvent-from ..errors import ResponsesConversionError, openai_error_from_failure-from ..ids import (- new_call_id,- new_message_item_id,- new_reasoning_item_id,- new_response_id,-)-from ..models import OpenAIResponsesRequest-from ..tools import responses_tool_identity_from_anthropic_name-from .blocks import ReasoningBlockState, TextBlockState, ToolBlockState-from .completion import ResponseBlockCompleter, reasoning_output_item, tool_item-from .error_mapping import (- openai_error_from_anthropic_error,- replay_unsafe_function_call_error,-)-from .event_builders import ResponseEventBuilder-from .ledger import ResponsesOutputLedger---class ResponsesStreamAssembler:- """Assemble Responses SSE events from indexed Anthropic content blocks."""-- def __init__(self, request: OpenAIResponsesRequest) -> None:- self._request = request- self._response_id = new_response_id()- self._created_at = int(time.time())- self._ledger = ResponsesOutputLedger()- self._events = ResponseEventBuilder()- self._completer = ResponseBlockCompleter(- self._ledger,- events=self._events,- on_invalid_function_call=self._fail_invalid_function_call,- )- self._started = False- self._stop_reason: str | None = None- self._provisional_error: dict[str, Any] | None = None- self.terminal = False- self.final_response: dict[str, Any] | None = None-- def process_anthropic_event(self, event: AnthropicSseEvent) -> list[str]:- if self.terminal:- return []-- chunks = self._ensure_started()- if event.event == "content_block_start":- chunks.extend(self._handle_content_block_start(event.data))- elif event.event == "content_block_delta":- chunks.extend(self._handle_content_block_delta(event.data))- elif event.event == "content_block_stop":- chunks.extend(self._handle_content_block_stop(event.data))- elif event.event == "message_delta":- self._record_message_delta(event.data)- elif event.event == "message_stop":- chunks.extend(self.finish_response())- elif event.event == "error":- chunks.extend(self.fail_response(event.data))- return chunks-- def finish_if_needed(self) -> list[str]:- if self.terminal:- return []- chunks = self._ensure_started()- chunks.extend(self.finish_response())- return chunks-- def response_payload(- self,- *,- status: str,- error: dict[str, Any] | None = None,- incomplete_details: dict[str, str] | None = None,- ) -> dict[str, Any]:- return {- "id": self._response_id,- "object": "response",- "created_at": self._created_at,- "status": status,- "model": self._request.model,- "output": self._ledger.output(),- "parallel_tool_calls": (- True- if self._request.parallel_tool_calls is None- else self._request.parallel_tool_calls- ),- "tool_choice": (- "auto"- if self._request.tool_choice is None- else self._request.tool_choice- ),- "temperature": self._request.temperature,- "top_p": self._request.top_p,- "max_output_tokens": self._request.max_output_tokens,- "usage": self._ledger.usage(),- "error": error,- "incomplete_details": incomplete_details,- }-- def finish_response(self) -> list[str]:- chunks = self._flush_active_blocks()- if self.terminal:- return chunks- if self._provisional_error is not None:- chunks.extend(self._finish_failed_response(self._provisional_error))- return chunks- if self._stop_reason == "max_tokens":- chunks.extend(self._finish_incomplete_response())- return chunks- self.final_response = self.response_payload(status="completed")- chunks.append(self._events.response_completed(self.final_response))- self.terminal = True- return chunks-- def fail_response(self, data: Mapping[str, Any]) -> list[str]:- chunks = self._flush_active_blocks()- if self.terminal:- return chunks- error = openai_error_from_anthropic_error(data)- chunks.extend(self._finish_failed_response(error))- return chunks-- def fail_execution(self, failure: ExecutionFailure) -> list[str]:- """Finish the current response with a canonical execution failure."""- chunks = self._flush_active_blocks()- if self.terminal:- return chunks- chunks.extend(self._finish_failed_response(openai_error_from_failure(failure)))- return chunks-- def _finish_failed_response(self, error: dict[str, Any]) -> list[str]:- self._provisional_error = None- self.final_response = self.response_payload(status="failed", error=error)- self.terminal = True- return [self._events.response_failed(self.final_response)]-- def _finish_incomplete_response(self) -> list[str]:- self.final_response = self.response_payload(- status="incomplete",- incomplete_details={"reason": "max_output_tokens"},- )- self.terminal = True- return [self._events.response_incomplete(self.final_response)]-- def _ensure_started(self) -> list[str]:- if self._started:- return []- self._started = True- return [- self._events.response_created(self.response_payload(status="in_progress"))- ]-- def _handle_content_block_start(self, data: Mapping[str, Any]) -> list[str]:- block = data.get("content_block")- if not isinstance(block, dict):- return []- block_type = block.get("type")- index = _event_index(data)- if block_type == "text":- index = self._ledger.safe_text_index(index)- chunks, state = self._start_text_block(index)- if state is None:- return chunks- if text := _string_value(block.get("text")):- chunks.extend(self._emit_text_delta(state, text))- return chunks- if block_type == "thinking":- if index is None:- return []- chunks, state = self._start_reasoning_block(index)- if state is None:- return chunks- if text := _string_value(block.get("thinking")):- chunks.extend(self._emit_reasoning_delta(state, text))- return chunks- if block_type == "redacted_thinking":- if index is None:- return []- chunks, _state = self._start_reasoning_block(- index, encrypted_content=_string_value(block.get("data"))- )- return chunks- if block_type == "tool_use":- if index is None:- return []- return self._start_tool_block(index, block)- return []-- def _handle_content_block_delta(self, data: Mapping[str, Any]) -> list[str]:- delta = data.get("delta")- if not isinstance(delta, dict):- return []- delta_type = delta.get("type")- index = _event_index(data)- if delta_type == "text_delta":- index = self._ledger.safe_text_index(index)- state = self._ledger.active_block(index)- chunks: list[str] = []- if not isinstance(state, TextBlockState):- chunks, state = self._start_text_block(index)- if state is None:- return chunks- chunks.extend(- self._emit_text_delta(state, _string_value(delta.get("text")))- )- return chunks- if delta_type == "thinking_delta":- if index is None:- return []- state = self._ledger.active_block(index)- chunks = []- if not isinstance(state, ReasoningBlockState):- chunks, state = self._start_reasoning_block(index)- if state is None:- return chunks- chunks.extend(- self._emit_reasoning_delta(state, _string_value(delta.get("thinking")))- )- return chunks- if delta_type == "input_json_delta":- state = self._ledger.active_block(index) if index is not None else None- if isinstance(state, ToolBlockState):- state.argument_parts.append(_string_value(delta.get("partial_json")))- return []-- def _handle_content_block_stop(self, data: Mapping[str, Any]) -> list[str]:- index = _event_index(data)- if index is None:- return []- state = self._ledger.pop_active_block(index)- if state is None:- return []- return self._completer.complete_block(state)-- def _record_message_delta(self, data: Mapping[str, Any]) -> None:- self._ledger.record_usage_delta(data)- delta = data.get("delta")- if not isinstance(delta, Mapping):- return- stop_reason = delta.get("stop_reason")- if isinstance(stop_reason, str):- self._stop_reason = stop_reason-- def _start_text_block(self, index: int) -> tuple[list[str], TextBlockState | None]:- chunks = self._complete_existing_block(index)- if self.terminal:- return chunks, None- output_index = self._ledger.reserve_output_slot()- state = TextBlockState(- index=index,- output_index=output_index,- item_id=new_message_item_id(),- )- self._ledger.set_active_block(state)- item = {- "id": state.item_id,- "type": "message",- "status": "in_progress",- "role": "assistant",- "content": [],- }- chunks.extend(- [- self._events.output_item_added(output_index, item),- self._events.content_part_added(state.item_id, output_index),- ]- )- return chunks, state-- def _start_reasoning_block(- self, index: int, *, encrypted_content: str | None = None- ) -> tuple[list[str], ReasoningBlockState | None]:- chunks = self._complete_existing_block(index)- if self.terminal:- return chunks, None- output_index = self._ledger.reserve_output_slot()- state = ReasoningBlockState(- index=index,- output_index=output_index,- item_id=new_reasoning_item_id(),- encrypted_content=encrypted_content,- )- self._ledger.set_active_block(state)- chunks.append(- self._events.output_item_added(- output_index,- reasoning_output_item(state, status="in_progress"),- )- )- return chunks, state-- def _start_tool_block(self, index: int, block: Mapping[str, Any]) -> list[str]:- chunks = self._complete_existing_block(index)- if self.terminal:- return chunks- identity = responses_tool_identity_from_anthropic_name(- self._request.tools, _string_value(block.get("name"))- )- state = ToolBlockState(- index=index,- output_index=self._ledger.reserve_output_slot(),- item_id=f"{'ctc' if identity.kind == 'custom' else 'fc'}_"- f"{uuid.uuid4().hex[:24]}",- call_id=_string_value(block.get("id")) or new_call_id(),- kind=identity.kind,- name=identity.name,- namespace=identity.namespace,- )- initial_input = block.get("input")- if (identity.kind == "custom" and initial_input not in (None, {}, "")) or (- isinstance(initial_input, dict) and initial_input- ):- state.argument_parts.append(json.dumps(initial_input))- self._ledger.set_active_block(state)- chunks.append(- self._events.output_item_added(- state.output_index,- tool_item(state, status="in_progress"),- )- )- return chunks-- def _emit_text_delta(self, state: TextBlockState, text: str) -> list[str]:- if not text:- return []- state.text_parts.append(text)- return [self._events.output_text_delta(state.item_id, state.output_index, text)]-- def _emit_reasoning_delta(self, state: ReasoningBlockState, text: str) -> list[str]:- if not text:- return []- state.text_parts.append(text)- return [- self._events.reasoning_text_delta(state.item_id, state.output_index, text)- ]-- def _complete_existing_block(self, index: int) -> list[str]:- existing = self._ledger.pop_active_block(index)- if existing is None:- return []- return self._completer.complete_block(existing)-- def _flush_active_blocks(self) -> list[str]:- chunks: list[str] = []- for state in self._ledger.pop_active_blocks_by_output_order():- if self.terminal:- break- chunks.extend(self._completer.complete_block(state))- return chunks-- def _fail_invalid_function_call(- self, state: ToolBlockState, exc: ResponsesConversionError- ) -> list[str]:- trace_event(- stage="responses",- event="responses.output.function_call_invalid_arguments",- source="openai_responses",- call_id=state.call_id,- tool_name=state.name,- error_type=type(exc).__name__,- )- error = replay_unsafe_function_call_error()- if self._provisional_error is None:- self._provisional_error = error- return []---def _event_index(data: Mapping[str, Any]) -> int | None:- value = data.get("index")- return value if isinstance(value, int) else None---def _string_value(value: Any) -> str:- if value is None:- return ""- return value if isinstance(value, str) else str(value)diff --git a/src/free_claude_code/core/openai_responses/tokens.py b/src/free_claude_code/core/openai_responses/tokens.pynew file mode 100644index 00000000..3591d4b6--- /dev/null+++ b/src/free_claude_code/core/openai_responses/tokens.py@@ -0,0 +1,133 @@+"""Best-effort token estimates for native Responses requests."""++import json+from collections.abc import Iterator, Mapping, Sequence+from io import StringIO+from typing import NamedTuple++from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.token_estimation import estimate_text_tokens++from .models import OpenAIResponsesRequest++_MAX_ESTIMATE_CHARS_PER_FIELD = 1_000_000+++class _ValueStep(NamedTuple):+ value: JsonValue+++class _TextStep(NamedTuple):+ text: str+++class _QuotedStep(NamedTuple):+ text: str+++class _MappingStep(NamedTuple):+ items: Iterator[tuple[str, JsonValue]]+ first: bool+++class _SequenceStep(NamedTuple):+ items: Iterator[JsonValue]+ first: bool+++type _TraversalStep = (+ _ValueStep | _TextStep | _QuotedStep | _MappingStep | _SequenceStep+)+++def estimate_responses_input_tokens(request: OpenAIResponsesRequest) -> int:+ """Estimate only request fields that contribute model input tokens."""++ values: tuple[object, ...] = (+ request.instructions,+ request.input,+ request.tools,+ )+ total = 0+ for value in values:+ if value is None:+ continue+ if isinstance(value, str):+ text = value[:_MAX_ESTIMATE_CHARS_PER_FIELD]+ else:+ text = _bounded_json_text(value, limit=_MAX_ESTIMATE_CHARS_PER_FIELD)+ total += estimate_text_tokens(text)+ return total+++def _bounded_json_text(value: JsonValue, *, limit: int) -> str:+ """Serialize at most ``limit`` JSON-like characters without copying the rest."""++ output = StringIO()+ stack: list[_TraversalStep] = [_ValueStep(value)]+ while stack and output.tell() < limit:+ step = stack.pop()+ if isinstance(step, _TextStep):+ _write_bounded(output, step.text, limit=limit)+ continue+ if isinstance(step, _QuotedStep):+ remaining = limit - output.tell()+ if remaining > 0:+ encoded = json.dumps(step.text[:remaining], ensure_ascii=False)+ _write_bounded(output, encoded, limit=limit)+ continue+ if isinstance(step, _MappingStep):+ try:+ key, item = next(step.items)+ except StopIteration:+ _write_bounded(output, "}", limit=limit)+ else:+ stack.extend(+ (+ _MappingStep(step.items, False),+ _ValueStep(item),+ _TextStep(":"),+ _QuotedStep(key),+ )+ )+ if not step.first:+ stack.append(_TextStep(","))+ continue+ if isinstance(step, _SequenceStep):+ try:+ item = next(step.items)+ except StopIteration:+ _write_bounded(output, "]", limit=limit)+ else:+ stack.extend(+ (+ _SequenceStep(step.items, False),+ _ValueStep(item),+ )+ )+ if not step.first:+ stack.append(_TextStep(","))+ continue++ item = step.value+ if isinstance(item, str):+ stack.append(_QuotedStep(item))+ elif isinstance(item, Mapping):+ _write_bounded(output, "{", limit=limit)+ stack.append(_MappingStep(iter(item.items()), True))+ elif isinstance(item, Sequence):+ _write_bounded(output, "[", limit=limit)+ stack.append(_SequenceStep(iter(item), True))+ else:+ _write_bounded(+ output,+ json.dumps(item, ensure_ascii=False),+ limit=limit,+ )+ return output.getvalue()+++def _write_bounded(output: StringIO, text: str, *, limit: int) -> None:+ remaining = limit - output.tell()+ if remaining > 0:+ output.write(text[:remaining])diff --git a/src/free_claude_code/core/anthropic/openai_tool_names.py b/src/free_claude_code/core/openai_tool_names.pysimilarity index 69%rename from src/free_claude_code/core/anthropic/openai_tool_names.pyrename to src/free_claude_code/core/openai_tool_names.pyindex 9f1a2e5c..cd78f21c 100644--- a/src/free_claude_code/core/anthropic/openai_tool_names.py+++ b/src/free_claude_code/core/openai_tool_names.py@@ -1,12 +1,12 @@-"""Reversible tool names for Anthropic-to-OpenAI protocol conversion."""+"""Reversible tool names for OpenAI-compatible protocol boundaries."""import hashlibimport refrom collections.abc import Iterablefrom dataclasses import dataclass-from .content import get_block_attr, get_block_type-from .models import MessagesRequest+from .anthropic.content import get_block_attr, get_block_type+from .anthropic.models import MessagesRequestOPENAI_TOOL_NAME_MAX_LENGTH = 64_ALIAS_DIGEST_LENGTH = 16@@ -79,6 +79,60 @@ class OpenAIToolNameCodec:)+def encode_openai_chat_tool_names(+ body: dict[str, object], codec: OpenAIToolNameCodec+) -> None:+ """Encode canonical Chat tool-name locations at the provider boundary."""+ if not codec.has_aliases:+ return++ tools = body.get("tools")+ if isinstance(tools, list):+ for tool in tools:+ if not isinstance(tool, dict):+ continue+ function = tool.get("function")+ if not isinstance(function, dict):+ continue+ name = function.get("name")+ if isinstance(name, str):+ function["name"] = codec.encode(name)++ messages = body.get("messages")+ if isinstance(messages, list):+ for message in messages:+ if not isinstance(message, dict):+ continue+ tool_calls = message.get("tool_calls")+ if not isinstance(tool_calls, list):+ continue+ for tool_call in tool_calls:+ if not isinstance(tool_call, dict):+ continue+ function = tool_call.get("function")+ if not isinstance(function, dict):+ continue+ name = function.get("name")+ if isinstance(name, str):+ function["name"] = codec.encode(name)++ tool_choice = body.get("tool_choice")+ if not isinstance(tool_choice, dict):+ return+ function = tool_choice.get("function")+ if not isinstance(function, dict):+ return+ name = function.get("name")+ if not isinstance(name, str):+ return+ encoded = codec.encode(name)+ if encoded != name:+ body["tool_choice"] = {+ **tool_choice,+ "function": {**function, "name": encoded},+ }++def _request_tool_names(request: MessagesRequest) -> Iterable[str]:for tool in request.tools or ():yield tool.namediff --git a/src/free_claude_code/providers/base.py b/src/free_claude_code/providers/base.pyindex 4fd73c38..59c28a94 100644--- a/src/free_claude_code/providers/base.py+++ b/src/free_claude_code/providers/base.py@@ -12,6 +12,7 @@ from free_claude_code.core.diagnostics import (exception_cause_types,redacted_exception_traceback,)+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.core.trace import trace_event@@ -44,13 +45,22 @@ class BaseProvider(ABC):self._config = config@abstractmethod- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:- """Validate the upstream request before opening an SSE stream."""+ """Validate a Messages request before opening its SSE stream."""++ @abstractmethod+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ """Validate a Responses request before opening its SSE stream."""def _log_stream_transport_error(self,@@ -104,7 +114,7 @@ class BaseProvider(ABC):"""Return the model metadata currently advertised by this provider."""@abstractmethod- def stream_response(+ def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -114,3 +124,15 @@ class BaseProvider(ABC):reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""++ @abstractmethod+ def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> AsyncIterator[str]:+ """Stream response in OpenAI Responses SSE format."""diff --git a/src/free_claude_code/providers/cloudflare/client.py b/src/free_claude_code/providers/cloudflare/client.pyindex dafac98d..d9fbe367 100644--- a/src/free_claude_code/providers/cloudflare/client.py+++ b/src/free_claude_code/providers/cloudflare/client.py@@ -22,6 +22,7 @@ from free_claude_code.providers.model_listing import (extract_openai_model_infos,)from free_claude_code.providers.openai_chat import (+ ChatStreamOutput,ChatTemplateReasoning,OpenAIChatProfile,OpenAIChatProvider,@@ -131,14 +132,14 @@ class CloudflareProvider(OpenAIChatProvider):await maybe_await_aclose(response)def _handle_extra_reasoning(- self, delta: Any, ledger: Any, *, output_reasoning: bool+ self, delta: Any, output: ChatStreamOutput, *, output_reasoning: bool) -> Iterator[str]:"""Map Cloudflare's ``reasoning`` delta field to Anthropic thinking."""reasoning = _cloudflare_reasoning(delta)if not output_reasoning or not reasoning:return- yield from ledger.ensure_thinking_block()- yield ledger.emit_thinking_delta(reasoning)+ yield from output.ensure_reasoning_block()+ yield output.emit_reasoning_delta(reasoning)def _model_list_headers(self) -> dict[str, str]:if self._api_key is None:diff --git a/src/free_claude_code/providers/deepseek/client.py b/src/free_claude_code/providers/deepseek/client.pyindex 7f264fa1..d0f9a51f 100644--- a/src/free_claude_code/providers/deepseek/client.py+++ b/src/free_claude_code/providers/deepseek/client.py@@ -13,7 +13,11 @@ from free_claude_code.providers.openai_chat import (usage_int,)-from .compat import DEEPSEEK_REQUEST_POLICY, build_deepseek_request_body+from .compat import (+ DEEPSEEK_REQUEST_POLICY,+ build_deepseek_request_body,+ finalize_deepseek_chat_body,+)_PROFILE = OpenAIChatProfile(DEEPSEEK_REQUEST_POLICY,@@ -44,6 +48,16 @@ class DeepSeekProvider(OpenAIChatProvider):reasoning=reasoning,)+ def _finalize_chat_body(+ self,+ body: dict[str, Any],+ *,+ reasoning: ReasoningPolicy,+ ) -> dict[str, Any]:+ """Apply DeepSeek policy after either client-protocol translation."""+ finalize_deepseek_chat_body(body, reasoning)+ return body+def _anthropic_usage_fields(self, usage_info: Any) -> dict[str, int]:cache_hit_tokens = usage_int(usage_info, "prompt_cache_hit_tokens")cache_miss_tokens = usage_int(usage_info, "prompt_cache_miss_tokens")diff --git a/src/free_claude_code/providers/deepseek/compat.py b/src/free_claude_code/providers/deepseek/compat.pyindex f62503ff..b8913872 100644--- a/src/free_claude_code/providers/deepseek/compat.py+++ b/src/free_claude_code/providers/deepseek/compat.py@@ -75,8 +75,6 @@ def build_deepseek_request_body(data["messages"], allow_attachments=vision_capable)_validate_deepseek_request_dict(data, allow_attachments=vision_capable)- _downgrade_forced_tool_choice(data)-has_tool_history = _has_tool_history(data)has_replayable_tool_thinking = _all_tool_calls_have_replayable_thinking(data)unsafe_tool_followup = has_tool_history and not has_replayable_tool_thinking@@ -119,10 +117,12 @@ def build_deepseek_request_body(sanitized_request,reasoning=effective_reasoning,policy=DEEPSEEK_REQUEST_POLICY,- postprocessors=(_apply_deepseek_chat_extras,),+ postprocessors=(+ lambda body, _request, _policy: finalize_deepseek_chat_body(+ body, effective_reasoning+ ),+ ),)- if "max_tokens" not in body or body.get("max_tokens") is None:- body["max_tokens"] = ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENSlogger.debug("DEEPSEEK_REQUEST: build done model={} msgs={} tools={}",@@ -133,6 +133,76 @@ def build_deepseek_request_body(return body+def finalize_deepseek_chat_body(+ body: dict[str, Any], reasoning: ReasoningPolicy+) -> None:+ """Apply source-independent DeepSeek policy to one Chat body."""+ effective_reasoning = reasoning+ if reasoning.control is not ReasoningControl.OFF:+ has_tool_history = _has_chat_tool_history(body)+ has_replayable_tool_thinking = _all_chat_tool_calls_have_reasoning(body)+ if has_tool_history and not has_replayable_tool_thinking:+ _remove_deepseek_thinking_hints(body)+ effective_reasoning = ReasoningPolicy.off()++ _downgrade_chat_forced_tool_choice(body)+ _apply_deepseek_chat_extras(body, effective_reasoning)+ if body.get("max_tokens") is None:+ body["max_tokens"] = ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+++def _has_chat_tool_history(body: Mapping[str, Any]) -> bool:+ messages = body.get("messages")+ if not isinstance(messages, list):+ return False+ return any(+ isinstance(message, Mapping)+ and (+ message.get("role") == "tool"+ or (+ message.get("role") == "assistant"+ and isinstance(message.get("tool_calls"), list)+ and bool(message["tool_calls"])+ )+ )+ for message in messages+ )+++def _all_chat_tool_calls_have_reasoning(body: Mapping[str, Any]) -> bool:+ messages = body.get("messages")+ if not isinstance(messages, list):+ return False+ found_tool_call = False+ for message in messages:+ if (+ not isinstance(message, Mapping)+ or message.get("role") != "assistant"+ or not isinstance(message.get("tool_calls"), list)+ or not message["tool_calls"]+ ):+ continue+ found_tool_call = True+ if "reasoning_content" not in message and "reasoning" not in message:+ return False+ return found_tool_call+++def _downgrade_chat_forced_tool_choice(body: dict[str, Any]) -> None:+ tool_choice = body.get("tool_choice")+ if not isinstance(tool_choice, dict) or tool_choice.get("type") != "function":+ return+ function = tool_choice.get("function")+ if not isinstance(function, dict) or not isinstance(function.get("name"), str):+ return+ logger.debug(+ "DEEPSEEK_REQUEST: downgrading forced tool_choice to auto for unsupported "+ "native request shape tool={}",+ function["name"],+ )+ body["tool_choice"] = "auto"++def sanitize_deepseek_messages_for_openai(messages: Any) -> Any:"""Keep only DeepSeek-required reasoning history on assistant tool calls."""if not isinstance(messages, list):@@ -461,25 +531,7 @@ def _normalize_tool_result_content(messages: Any) -> Any:return normalized-def _downgrade_forced_tool_choice(data: dict[str, Any]) -> None:- tool_choice = data.get("tool_choice")- if not isinstance(tool_choice, dict):- return- if tool_choice.get("type") != "tool" or not isinstance(- tool_choice.get("name"), str- ):- return- logger.debug(- "DEEPSEEK_REQUEST: downgrading forced tool_choice to auto for unsupported "- "native request shape tool={}",- tool_choice["name"],- )- data["tool_choice"] = {"type": "auto"}---def _apply_deepseek_chat_extras(- body: dict[str, Any], _request_data: MessagesRequest, policy: ReasoningPolicy-) -> None:+def _apply_deepseek_chat_extras(body: dict[str, Any], policy: ReasoningPolicy) -> None:extra_body = body.setdefault("extra_body", {})if not isinstance(extra_body, dict):returndiff --git a/src/free_claude_code/providers/google_openai/provider.py b/src/free_claude_code/providers/google_openai/provider.pyindex 09a71fe8..b9b1b2cf 100644--- a/src/free_claude_code/providers/google_openai/provider.py+++ b/src/free_claude_code/providers/google_openai/provider.py@@ -4,18 +4,13 @@ from collections.abc import Mappingfrom copy import deepcopyfrom typing import Any-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.reasoning import (- DEFAULT_REASONING_POLICY,- ReasoningPolicy,-)+from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfigfrom free_claude_code.providers.openai_chat import (OpenAIAsyncCredentialProvider,OpenAIChatProfile,OpenAIChatProvider,- build_openai_chat_request_body,)from .thought_signatures import apply_google_thought_signatures@@ -57,21 +52,14 @@ class GoogleOpenAIProvider(OpenAIChatProvider):)self._tool_call_extra_content_by_id[tool_call_id] = deepcopy(extra_content)- def _build_request_body(+ def _finalize_chat_body(self,- request: MessagesRequest,+ body: dict[str, Any],*,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ reasoning: ReasoningPolicy,) -> dict[str, Any]:- return build_openai_chat_request_body(- request,- reasoning=reasoning,- policy=self._profile.request_policy,- postprocessors=(- lambda body, _request_data, _policy: apply_google_thought_signatures(- body,- tool_call_extra_content_by_id=(self._tool_call_extra_content_by_id),- ),- *self._profile.request_postprocessors,- ),+ apply_google_thought_signatures(+ body,+ tool_call_extra_content_by_id=self._tool_call_extra_content_by_id,)+ return bodydiff --git a/src/free_claude_code/providers/groq/client.py b/src/free_claude_code/providers/groq/client.pyindex 83aa9973..e48e9766 100644--- a/src/free_claude_code/providers/groq/client.py+++ b/src/free_claude_code/providers/groq/client.py@@ -10,9 +10,7 @@ import openaifrom loguru import loggerfrom free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import (- DEFAULT_REASONING_POLICY,ReasoningEffort,ReasoningPolicy,)@@ -97,13 +95,12 @@ class GroqProvider(OpenAIChatProvider):super().__init__(config, profile=_PROFILE, admission=admission)self._model_reasoning_vocabularies: dict[str, frozenset[str]] = {}- def _build_request_body(+ def _finalize_chat_body(self,- request: MessagesRequest,+ body: dict[str, Any],*,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ reasoning: ReasoningPolicy,) -> dict[str, Any]:- body = super()._build_request_body(request, reasoning=reasoning)model = body.get("model")if not isinstance(model, str):return bodydiff --git a/src/free_claude_code/providers/lmstudio/client.py b/src/free_claude_code/providers/lmstudio/client.pyindex c2e83fda..62ad330e 100644--- a/src/free_claude_code/providers/lmstudio/client.py+++ b/src/free_claude_code/providers/lmstudio/client.py@@ -18,6 +18,10 @@ from loguru import loggerfrom free_claude_code.core.anthropic import ReasoningReplayMode, get_token_countfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ estimate_responses_input_tokens,+)from free_claude_code.core.reasoning import (DEFAULT_REASONING_POLICY,ReasoningEffort,@@ -76,24 +80,30 @@ class LMStudioProvider(OpenAIChatProvider):)self._loaded_context_cache: tuple[float, int | None] = (0.0, None)- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:- super().preflight_stream(request, reasoning=reasoning)- self._preflight_context_budget(request)+ super().preflight_messages(request, reasoning=reasoning)+ self._preflight_context_budget(+ get_token_count(request.messages, request.system, request.tools)+ )++ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ super().preflight_responses(request, reasoning=reasoning)+ self._preflight_context_budget(estimate_responses_input_tokens(request))- def _preflight_context_budget(self, request: MessagesRequest) -> None:+ def _preflight_context_budget(self, estimate: int) -> None:loaded_context = self._loaded_context_length()if loaded_context is None:return- estimate = get_token_count(- request.messages,- request.system,- request.tools,- )# The estimate is cl100k-based and undercounts local tokenizers# (observed ~8% low vs devstral); a request above 90% of the loaded# context is already past where client-side compaction should havediff --git a/src/free_claude_code/providers/mistral/client.py b/src/free_claude_code/providers/mistral/client.pyindex d0e7b93e..db16d4be 100644--- a/src/free_claude_code/providers/mistral/client.py+++ b/src/free_claude_code/providers/mistral/client.py@@ -6,8 +6,7 @@ from typing import Anyfrom loguru import loggerfrom free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy+from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfigfrom free_claude_code.providers.openai_chat import (@@ -15,7 +14,6 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,- build_openai_chat_request_body,)from .reasoning import (@@ -44,17 +42,12 @@ class MistralProvider(OpenAIChatProvider):admission=admission,)- def _build_request_body(+ def _finalize_chat_body(self,- request: MessagesRequest,+ body: dict[str, Any],*,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ reasoning: ReasoningPolicy,) -> dict:- body = build_openai_chat_request_body(- request,- reasoning=reasoning,- policy=_REQUEST_POLICY,- )apply_mistral_reasoning_request_shape(body, reasoning=reasoning)return bodydiff --git a/src/free_claude_code/providers/nvidia_nim/client.py b/src/free_claude_code/providers/nvidia_nim/client.pyindex a658540c..ac571528 100644--- a/src/free_claude_code/providers/nvidia_nim/client.py+++ b/src/free_claude_code/providers/nvidia_nim/client.py@@ -25,7 +25,11 @@ from free_claude_code.providers.openai_chat import ()from .native_tool_stream import normalize_nim_native_tool_stream-from .request_options import NIM_REQUEST_POLICY, build_nim_request_body+from .request_options import (+ NIM_REQUEST_POLICY,+ apply_nim_request_options,+ build_nim_request_body,+)from .retry import (clone_body_without_chat_template,clone_body_without_reasoning_budget,@@ -77,6 +81,16 @@ class NvidiaNimProvider(OpenAIChatProvider):reasoning=reasoning,)+ def _finalize_chat_body(+ self,+ body: dict[str, Any],+ *,+ reasoning: ReasoningPolicy,+ ) -> dict[str, Any]:+ """Apply NIM policy after either client-protocol translation."""+ apply_nim_request_options(body, reasoning, nim=self._nim_settings)+ return body+def _prepare_create_body(self, body: dict[str, Any]) -> dict[str, Any]:"""Strip private request metadata before calling NVIDIA NIM."""return body_without_nim_tool_argument_aliases(body)diff --git a/src/free_claude_code/providers/nvidia_nim/request_options.py b/src/free_claude_code/providers/nvidia_nim/request_options.pyindex bbc4894d..ea43cf79 100644--- a/src/free_claude_code/providers/nvidia_nim/request_options.py+++ b/src/free_claude_code/providers/nvidia_nim/request_options.py@@ -29,7 +29,7 @@ def build_nim_request_body(reasoning=reasoning,policy=NIM_REQUEST_POLICY,postprocessors=(- lambda body, request, policy: apply_nim_request_options(+ lambda body, request, policy: _apply_nim_messages_request_options(body,request,policy,@@ -39,17 +39,31 @@ def build_nim_request_body()-def apply_nim_request_options(+def _apply_nim_messages_request_options(body: dict[str, Any],request_data: MessagesRequest,reasoning: ReasoningPolicy,*,nim: NimSettings,) -> None:- """Apply NIM schema repairs and configured request defaults."""+ """Copy Messages-only fields, then apply the common NIM finalizer."""+ extra_body = deepcopy(request_data.extra_body or {})+ _set_extra(extra_body, "top_k", request_data.top_k, ignore_value=-1)+ if extra_body:+ body["extra_body"] = extra_body+ apply_nim_request_options(body, reasoning, nim=nim)+++def apply_nim_request_options(+ body: dict[str, Any],+ reasoning: ReasoningPolicy,+ *,+ nim: NimSettings,+) -> None:+ """Apply source-independent NIM policy to one Chat body."""sanitize_nim_tool_schemas(body)- max_tokens = body.get("max_tokens") or request_data.max_tokens+ max_tokens = body.get("max_tokens")if max_tokens is None:max_tokens = nim.max_tokenselif nim.max_tokens:@@ -72,10 +86,10 @@ def apply_nim_request_options(body["parallel_tool_calls"] = nim.parallel_tool_calls- extra_body: dict[str, Any] = {}- request_extra = request_data.extra_body- if request_extra:- extra_body.update(deepcopy(request_extra))+ request_extra = body.get("extra_body")+ extra_body: dict[str, Any] = (+ deepcopy(request_extra) if isinstance(request_extra, dict) else {}+ )for key in ("reasoning","reasoning_budget",@@ -101,9 +115,7 @@ def apply_nim_request_options(if enabled and (budget := reasoning.numeric_budget_tokens) is not None:chat_template_kwargs["reasoning_budget"] = budget- req_top_k = request_data.top_k- top_k = req_top_k if req_top_k is not None else nim.top_k- _set_extra(extra_body, "top_k", top_k, ignore_value=-1)+ _set_extra(extra_body, "top_k", nim.top_k, ignore_value=-1)_set_extra(extra_body, "min_p", nim.min_p, ignore_value=0.0)_set_extra(extra_body, "repetition_penalty", nim.repetition_penalty, ignore_value=1.0diff --git a/src/free_claude_code/providers/openai_chat/__init__.py b/src/free_claude_code/providers/openai_chat/__init__.pyindex fcf8b146..a6e81991 100644--- a/src/free_claude_code/providers/openai_chat/__init__.py+++ b/src/free_claude_code/providers/openai_chat/__init__.py@@ -17,7 +17,12 @@ from .reasoning import (ReasoningObject,)from .reasoning_details import apply_reasoning_details_replay-from .request_policy import OpenAIChatRequestPolicy, build_openai_chat_request_body+from .request_policy import (+ OpenAIChatRequestPolicy,+ apply_openai_chat_body_policy,+ build_openai_chat_request_body,+)+from .stream_output import ChatStreamOutputfrom .usage import usage_int@@ -43,6 +48,7 @@ def create_openai_chat_provider(__all__ = ["NO_REASONING","OPENAI_CHAT_PROFILES",+ "ChatStreamOutput","ChatTemplateReasoning","NamedEffortReasoning","OpenAIAsyncCredentialProvider",@@ -50,6 +56,7 @@ __all__ = ["OpenAIChatProvider","OpenAIChatRequestPolicy","ReasoningObject",+ "apply_openai_chat_body_policy","apply_reasoning_details_replay","build_openai_chat_request_body","create_openai_chat_provider",diff --git a/src/free_claude_code/providers/openai_chat/profiles.py b/src/free_claude_code/providers/openai_chat/profiles.pyindex d40aa51a..49d8be05 100644--- a/src/free_claude_code/providers/openai_chat/profiles.py+++ b/src/free_claude_code/providers/openai_chat/profiles.py@@ -141,6 +141,14 @@ class OpenAIChatProfile:_request: MessagesRequest,policy: ReasoningPolicy,) -> None:+ self.apply_reasoning_to_body(body, policy)++ def apply_reasoning_to_body(+ self,+ body: dict[str, Any],+ policy: ReasoningPolicy,+ ) -> None:+ """Encode resolved reasoning policy after either client translation."""self.reasoning.encode(body, policy)@propertydiff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.pyindex 7683ed4b..545ff8cb 100644--- a/src/free_claude_code/providers/openai_chat/provider.py+++ b/src/free_claude_code/providers/openai_chat/provider.py@@ -14,15 +14,15 @@ from openai import AsyncOpenAI, DefaultAsyncHttpx2Clientfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import (+ ContentBlockToolUse,ContentType,FunctionTagToolParser,HeuristicToolParser,- OpenAIToolNameCodec,ThinkTagParser,)from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.streaming import (- AnthropicStreamLedger,+ ToolSchema,accept_tool_json_repair,continuation_suffix,make_response_recovery_body,@@ -33,6 +33,15 @@ from free_claude_code.core.anthropic.streaming import (tool_schemas_by_name,)from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ ResponsesChatRequest,+ build_responses_chat_request,+)+from free_claude_code.core.openai_tool_names import (+ OpenAIToolNameCodec,+ encode_openai_chat_tool_names,+)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.core.trace import provider_chat_body_snapshot, trace_eventfrom free_claude_code.providers.admission import (@@ -69,26 +78,34 @@ from free_claude_code.providers.stream_recovery import (from .output_cap import clamp_output_tokens, parse_output_token_capfrom .profiles import OpenAIChatProfilefrom .reasoning_details import StructuredReasoningStream-from .request_policy import build_openai_chat_request_body+from .request_policy import (+ apply_openai_chat_body_policy,+ build_openai_chat_request_body,+)+from .stream_output import (+ AnthropicChatStreamOutput,+ ChatStreamOutput,+ ChatStreamUsage,+ ResponsesChatStreamOutput,+)from .tool_calls import (CompletedOpenAIToolCall,OpenAIToolCallAssembler,OpenAIToolCallCollector,- all_emitted_tools_complete,- has_committed_sse_output,- iter_heuristic_tool_use_sse,- started_tool_states,+ iter_heuristic_tool_use_events,tool_call_extra_content,)from .usage import (clone_without_stream_usage,is_stream_usage_rejection,+ nested_usage_int,request_stream_usage,usage_int,)OpenAIAsyncCredentialProvider = Callable[[], Awaitable[str]]-_ExtraReasoningEvents = Callable[[Any, AnthropicStreamLedger], Iterator[str]]+_ExtraReasoningEvents = Callable[[Any, ChatStreamOutput], Iterator[str]]+_ChatOutputFactory = Callable[[], ChatStreamOutput]@dataclass(frozen=True, slots=True)@@ -99,15 +116,15 @@ class _CollectedRecoveryOutput:def _iter_visible_text_events(- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,text: str,) -> Iterator[str]:- yield from ledger.ensure_text_block()- yield ledger.emit_text_delta(text)+ yield from output.ensure_text_block()+ yield output.emit_text_delta(text)def _iter_text_parser_events(- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,parser: HeuristicToolParser,text: str,*,@@ -116,24 +133,24 @@ def _iter_text_parser_events("""Route visible text through the established heuristic tool parser."""filtered_text, detected_tools = parser.feed(text)if filtered_text:- yield from _iter_visible_text_events(ledger, filtered_text)+ yield from _iter_visible_text_events(output, filtered_text)for tool_use in detected_tools:- yield from iter_heuristic_tool_use_sse(- ledger,+ yield from iter_heuristic_tool_use_events(+ output,tool_use,tool_names=tool_names,)def _iter_text_tool_use_events(- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,tool_uses: tuple[dict[str, Any], ...] | list[dict[str, Any]],*,tool_names: OpenAIToolNameCodec,) -> Iterator[str]:for tool_use in tool_uses:- yield from iter_heuristic_tool_use_sse(- ledger,+ yield from iter_heuristic_tool_use_events(+ output,tool_use,tool_names=tool_names,)@@ -160,31 +177,49 @@ class _OpenAIChatFailureResolution:failure: ExecutionFailure | None = None+def _reserved_anthropic_tool_ids(request: MessagesRequest) -> frozenset[str]:+ """Return prior tool-use IDs that generated output must not reuse."""+ return frozenset(+ block.id+ for message in request.messages+ if isinstance(message.content, list)+ for block in message.content+ if isinstance(block, ContentBlockToolUse) and block.id.strip()+ )++class _OpenAIChatStreamAssembler:"""Own one discardable OpenAI-chat replay epoch."""def __init__(self,*,- request: MessagesRequest,- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,profile: OpenAIChatProfile,provider_name: str,output_reasoning: bool,tool_names: OpenAIToolNameCodec,+ tool_schemas: dict[str, ToolSchema],+ tool_choice_enabled: bool,tool_calls: OpenAIToolCallAssembler,extra_reasoning_events: _ExtraReasoningEvents,) -> None:- self._request = request- self._ledger = ledger+ self._output = outputself._profile = profileself._provider_name = provider_nameself._output_reasoning = output_reasoningself._tool_names = tool_names+ self._tool_schemas = tool_schemasself._tool_calls = tool_callsself._extra_reasoning_events = extra_reasoning_eventsself._think_parser = ThinkTagParser()- self._function_tag_parser = FunctionTagToolParser(request)+ self._function_tag_parser = FunctionTagToolParser.from_schemas(+ tool_names=tool_names,+ schemas={+ name: schema.input_schema for name, schema in tool_schemas.items()+ },+ enabled=tool_choice_enabled,+ )self._heuristic_parser = HeuristicToolParser()self._structured_reasoning = (StructuredReasoningStream()@@ -203,8 +238,8 @@ class _OpenAIChatStreamAssembler:self._completed = False@property- def ledger(self) -> AnthropicStreamLedger:- return self._ledger+ def output(self) -> ChatStreamOutput:+ return self._output@propertydef usage_info(self) -> Any:@@ -218,14 +253,14 @@ class _OpenAIChatStreamAssembler:@propertydef generated_output(self) -> bool:- return has_committed_sse_output(self._ledger)+ return self._output.committed_output@propertydef complete_tool_salvageable(self) -> bool:return (self.generated_output- and self._ledger.has_emitted_tool_block()- and all_emitted_tools_complete(self._ledger, self._request)+ and self._output.has_emitted_tool_block()+ and self._output.can_salvage_tool_use(self._tool_schemas))@property@@ -236,13 +271,13 @@ class _OpenAIChatStreamAssembler:self, tool_call: CompletedOpenAIToolCall) -> Iterator[str]:"""Emit one buffered recovery call through this attempt's ID scope."""- yield from self._tool_calls.process_tool_call(tool_call, self._ledger)+ yield from self._tool_calls.process_tool_call(tool_call, self._output)def start_events(self) -> Iterator[str]:if self._started:returnself._started = True- yield self._ledger.message_start()+ yield from self._output.start_events()def bind_tool_argument_aliases(self, aliases: dict[str, dict[str, str]]) -> None:if self._aliases_bound:@@ -279,41 +314,41 @@ class _OpenAIChatStreamAssembler:if self._structured_reasoning is not None:yield from self._structured_reasoning.events(delta,- self._ledger,+ self._output,native_reasoning=reasoning,)elif reasoning is not None:- yield from self._ledger.ensure_thinking_block()+ yield from self._output.ensure_reasoning_block()if reasoning:- yield self._ledger.emit_thinking_delta(reasoning)+ yield self._output.emit_reasoning_delta(reasoning)- yield from self._extra_reasoning_events(delta, self._ledger)+ yield from self._extra_reasoning_events(delta, self._output)native_tool_calls = delta.tool_callsif native_tool_calls:released_text = self._function_tag_parser.disable()if released_text:- yield from _iter_visible_text_events(self._ledger, released_text)+ yield from _iter_visible_text_events(self._output, released_text)if delta.content:for part in self._think_parser.feed(delta.content):if part.type == ContentType.THINKING:if not self._output_reasoning:continue- yield from self._ledger.ensure_thinking_block()- yield self._ledger.emit_thinking_delta(part.content)+ yield from self._output.ensure_reasoning_block()+ yield self._output.emit_reasoning_delta(part.content)else:safe_text = self._function_tag_parser.feed(part.content)if safe_text:yield from _iter_text_parser_events(- self._ledger,+ self._output,self._heuristic_parser,safe_text,tool_names=self._tool_names,)if native_tool_calls:- yield from self._ledger.close_content_blocks()+ yield from self._output.close_content_blocks()for tool_call in native_tool_calls:extra_content = tool_call_extra_content(tool_call)tool_call_info = {@@ -328,7 +363,7 @@ class _OpenAIChatStreamAssembler:tool_call_info["extra_content"] = extra_contentyield from self._tool_calls.process_tool_call(tool_call_info,- self._ledger,+ self._output,tool_names=self._tool_names,tool_name_buffers=self._tool_name_buffers,tool_argument_aliases=self._tool_argument_aliases,@@ -354,13 +389,13 @@ class _OpenAIChatStreamAssembler:if remaining:if remaining.type == ContentType.THINKING:if self._output_reasoning:- yield from self._ledger.ensure_thinking_block()- yield self._ledger.emit_thinking_delta(remaining.content)+ yield from self._output.ensure_reasoning_block()+ yield self._output.emit_reasoning_delta(remaining.content)else:safe_text = self._function_tag_parser.feed(remaining.content)if safe_text:yield from _iter_text_parser_events(- self._ledger,+ self._output,self._heuristic_parser,safe_text,tool_names=self._tool_names,@@ -368,14 +403,14 @@ class _OpenAIChatStreamAssembler:fallback_text, function_tag_tools = self._function_tag_parser.finish()if fallback_text:- yield from _iter_visible_text_events(self._ledger, fallback_text)+ yield from _iter_visible_text_events(self._output, fallback_text)yield from _iter_text_tool_use_events(- self._ledger,+ self._output,function_tag_tools,tool_names=self._tool_names,)yield from _iter_text_tool_use_events(- self._ledger,+ self._output,self._heuristic_parser.flush(),tool_names=self._tool_names,)@@ -386,44 +421,40 @@ class _OpenAIChatStreamAssembler:raise RuntimeError("stream completion cannot be prepared")yield from self._tool_calls.flush_tool_name_buffers(- self._ledger,+ self._output,tool_names=self._tool_names,tool_name_buffers=self._tool_name_buffers,tool_argument_aliases=self._tool_argument_aliases,tool_argument_alias_buffers=self._tool_argument_alias_buffers,)- has_emitted_tool = self._ledger.has_emitted_tool_block()- has_content_blocks = (- self._ledger.blocks.text_index != -1- or self._ledger.blocks.thinking_index != -1- or has_emitted_tool- )+ has_emitted_tool = self._output.has_emitted_tool_block()+ has_content_blocks = self._output.has_content_block()if not has_content_blocks or (not has_emitted_tool- and not self._ledger.accumulated_text.strip()- and self._ledger.accumulated_reasoning.strip()+ and not self._output.accumulated_text.strip()+ and self._output.accumulated_reasoning.strip()):- yield from self._ledger.ensure_text_block()- yield self._ledger.emit_text_delta(" ")+ yield from self._output.ensure_text_block()+ yield self._output.emit_text_delta(" ")yield from self._tool_calls.flush_tool_argument_alias_buffers(- self._ledger,+ self._output,self._tool_argument_aliases,self._tool_argument_alias_buffers,)- yield from self._tool_calls.flush_task_arg_buffers(self._ledger)- yield from self._ledger.close_all_blocks()+ yield from self._tool_calls.flush_task_arg_buffers(self._output)+ yield from self._output.close_all_blocks()completion = usage_int(self._usage_info, "completion_tokens")output_tokens = (completionif isinstance(completion, int)- else self._ledger.estimate_output_tokens()+ else self._output.estimate_output_tokens())provider_input = usage_int(self._usage_info, "prompt_tokens")input_tokens = (- provider_input if provider_input is not None else self._ledger.input_tokens+ provider_input if provider_input is not None else self._output.input_tokens)self._completion = _OpenAIChatCompletion(finish_reason=self._finish_reason,@@ -432,17 +463,14 @@ class _OpenAIChatStreamAssembler:provider_input_tokens=provider_input,)- def terminal_events(self, *, usage_fields: dict[str, int]) -> Iterator[str]:+ def terminal_events(self, *, usage: ChatStreamUsage) -> Iterator[str]:if self._completed:returncompletion = self.completion- yield self._ledger.message_delta(- self._ledger.final_stop_reason(map_stop_reason(completion.finish_reason)),- completion.output_tokens,- input_tokens=completion.input_tokens,- usage_fields=usage_fields,+ yield from self._output.finish_success(+ stop_reason=map_stop_reason(completion.finish_reason),+ usage=usage,)- yield self._ledger.message_stop()self._completed = True@@ -604,14 +632,48 @@ class OpenAIChatProvider(BaseProvider):reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict[str, Any]:"""Build a provider request from the immutable profile."""- return build_openai_chat_request_body(+ body = build_openai_chat_request_body(request,reasoning=reasoning,policy=self._profile.request_policy,postprocessors=self._profile.request_postprocessors,)+ return self._finalize_chat_body(body, reasoning=reasoning)++ def _build_responses_request_body(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> ResponsesChatRequest:+ """Build a Chat body directly from Responses ingress."""+ translated = build_responses_chat_request(+ request,+ reasoning_replay=self._profile.request_policy.reasoning_replay,+ structured_reasoning_details=self._profile.structured_reasoning_details,+ )+ body = translated.body+ apply_openai_chat_body_policy(body, self._profile.request_policy)+ self._profile.apply_reasoning_to_body(body, reasoning)+ body = self._finalize_chat_body(body, reasoning=reasoning)+ encode_openai_chat_tool_names(body, translated.tool_names)+ return ResponsesChatRequest(+ body=body,+ tool_names=translated.tool_names,+ tool_schemas=translated.tool_schemas,+ reserved_tool_ids=translated.reserved_tool_ids,+ )- def preflight_stream(+ def _finalize_chat_body(+ self,+ body: dict[str, Any],+ *,+ reasoning: ReasoningPolicy,+ ) -> dict[str, Any]:+ """Apply provider behavior that is independent of client protocol."""+ return body++ def preflight_messages(self,request: MessagesRequest,*,@@ -620,8 +682,17 @@ class OpenAIChatProvider(BaseProvider):"""Validate OpenAI-chat request conversion before streaming."""self._build_request_body(request, reasoning=reasoning)+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ """Validate direct Responses-to-Chat conversion before streaming."""+ self._build_responses_request_body(request, reasoning=reasoning)+def _handle_extra_reasoning(- self, delta: Any, ledger: AnthropicStreamLedger, *, output_reasoning: bool+ self, delta: Any, output: ChatStreamOutput, *, output_reasoning: bool) -> Iterator[str]:"""Hook for provider-specific reasoning."""return iter(())@@ -769,7 +840,7 @@ class OpenAIChatProvider(BaseProvider):)return clamped- def stream_response(+ def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -779,12 +850,60 @@ class OpenAIChatProvider(BaseProvider):reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""+ body = self._build_request_body(request, reasoning=reasoning)+ tool_names = OpenAIToolNameCodec.from_request(request)+ message_id = f"msg_{uuid.uuid4()}"+ runner = _OpenAIChatStreamRunner(+ self,+ body=body,+ tool_names=tool_names,+ tool_schemas=tool_schemas_by_name(request),+ reserved_tool_ids=_reserved_anthropic_tool_ids(request),+ output_factory=lambda: AnthropicChatStreamOutput(+ message_id=message_id,+ model=request.model if response_model is None else response_model,+ input_tokens=input_tokens,+ log_raw_events=self._config.log_raw_sse_events,+ ),+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=(+ request.model if response_model is None else response_model+ ),+ reasoning=reasoning,+ )+ return runner.run()++ def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> AsyncIterator[str]:+ """Stream a Chat upstream directly as OpenAI Responses SSE."""+ translated = self._build_responses_request_body(request, reasoning=reasoning)+ public_model = request.model if response_model is None else response_model+ tool_schemas = {+ name: ToolSchema(name=name, input_schema=schema)+ for name, schema in translated.tool_schemas.items()+ }runner = _OpenAIChatStreamRunner(self,- request=request,+ body=translated.body,+ tool_names=translated.tool_names,+ tool_schemas=tool_schemas,+ reserved_tool_ids=translated.reserved_tool_ids,+ output_factory=lambda: ResponsesChatStreamOutput(+ request,+ input_tokens=input_tokens,+ response_model=public_model,+ ),input_tokens=input_tokens,request_id=request_id,- response_model=response_model,+ response_model=public_model,reasoning=reasoning,)return runner.run()@@ -797,22 +916,27 @@ class _OpenAIChatStreamRunner:self,provider: OpenAIChatProvider,*,- request: MessagesRequest,+ body: dict[str, Any],+ tool_names: OpenAIToolNameCodec,+ tool_schemas: dict[str, ToolSchema],+ reserved_tool_ids: frozenset[str],+ output_factory: _ChatOutputFactory,input_tokens: int,request_id: str | None,- response_model: str | None,+ response_model: str,reasoning: ReasoningPolicy,) -> None:self._provider = provider- self._request = request+ self._body = body+ self._tool_names = tool_names+ self._tool_schemas = tool_schemas+ self._reserved_tool_ids = reserved_tool_ids+ self._output_factory = output_factoryself._input_tokens = input_tokensself._request_id = request_id- self._response_model = (- request.model if response_model is None else response_model- )+ self._response_model = response_modelself._reasoning = reasoning- self._tool_names = OpenAIToolNameCodec.from_request(request)- self._message_id = f"msg_{uuid.uuid4()}"+ self._terminal_failure: ExecutionFailure | None = Noneasync def run(self) -> AsyncIterator[str]:"""Convert the upstream OpenAI-chat stream into Anthropic SSE."""@@ -829,7 +953,10 @@ class _OpenAIChatStreamRunner:execution.fail(error)raiseelse:- execution.succeed()+ if self._terminal_failure is None:+ execution.succeed()+ else:+ execution.fail(self._terminal_failure)finally:await maybe_await_aclose(provider_stream)execution.abandon()@@ -846,10 +973,7 @@ class _OpenAIChatStreamRunner:def hold_event(event: str) -> Iterator[str]:yield from recovery.push(event)- body = self._provider._build_request_body(- self._request,- reasoning=self._reasoning,- )+ body = self._bodyrequest_stream_usage(body)output_reasoning = self._reasoning.output_enabledtrace_event(@@ -868,9 +992,6 @@ class _OpenAIChatStreamRunner:while True:assembler = self._new_stream_assembler(output_reasoning=output_reasoning)- for event in assembler.start_events():- for out_event in hold_event(event):- yield out_eventscope: ProviderAttemptScope | None = Nonetry:stream, body, attempt = await self._provider._create_stream(@@ -890,6 +1011,9 @@ class _OpenAIChatStreamRunner:async for chunk in stream:if not scope.attempt.accepted:await scope.attempt.accept()+ for event in assembler.start_events():+ for out_event in hold_event(event):+ yield out_eventfor event in assembler.feed(chunk):for out_event in hold_event(event):yield out_event@@ -916,6 +1040,7 @@ class _OpenAIChatStreamRunner:for event in resolution.events:yield eventif resolution.outcome is _OpenAIChatFailureOutcome.COMPLETE:+ self._terminal_failure = resolution.failurereturnif resolution.failure is None:raise AssertionError(@@ -952,9 +1077,30 @@ class _OpenAIChatStreamRunner:prompt_tokens=completion.input_tokens,prompt_tokens_estimate=self._input_tokens,)- for event in assembler.terminal_events(- usage_fields=self._provider._anthropic_usage_fields(assembler.usage_info)- ):+ usage = ChatStreamUsage(+ input_tokens=completion.input_tokens,+ output_tokens=completion.output_tokens,+ cached_tokens=(+ nested_usage_int(+ assembler.usage_info,+ "prompt_tokens_details",+ "cached_tokens",+ )+ or 0+ ),+ reasoning_tokens=(+ nested_usage_int(+ assembler.usage_info,+ "completion_tokens_details",+ "reasoning_tokens",+ )+ or 0+ ),+ anthropic_fields=self._provider._anthropic_usage_fields(+ assembler.usage_info+ ),+ )+ for event in assembler.terminal_events(usage=usage):for out_event in hold_event(event):yield out_eventfor event in recovery.flush():@@ -1080,7 +1226,15 @@ class _OpenAIChatStreamRunner:outcome=_OpenAIChatFailureOutcome.RAISE,failure=failure,)- failure_events.extend(assembler.ledger.close_unclosed_blocks())+ output = assembler.output+ if output.consumes_terminal_failure:+ failure_events.extend(output.finish_failure(failure))+ return _OpenAIChatFailureResolution(+ outcome=_OpenAIChatFailureOutcome.COMPLETE,+ events=tuple(failure_events),+ failure=failure,+ )+ failure_events.extend(output.close_unclosed_blocks())return _OpenAIChatFailureResolution(outcome=_OpenAIChatFailureOutcome.RAISE,events=tuple(failure_events),@@ -1139,7 +1293,7 @@ class _OpenAIChatStreamRunner:tool_calls.add(tool_call)completed_tool_calls = tool_calls.completed_calls(- self._request,+ self._tool_schemas,tool_names=self._tool_names,tool_argument_aliases=self._provider._tool_argument_aliases(accepted_body@@ -1199,12 +1353,12 @@ class _OpenAIChatStreamRunner:execution: ProviderExecution,) -> list[str] | None:"""Build terminal recovery events when the interrupted stream permits it."""- ledger = assembler.ledger- if ledger.has_emitted_tool_block():- if not all_emitted_tools_complete(ledger, self._request):+ output = assembler.output+ if output.has_emitted_tool_block():+ if not output.can_salvage_tool_use(self._tool_schemas):repair_events = await self._repair_tool_args(body=body,- ledger=ledger,+ output=output,tool_argument_alias_buffers=tool_argument_alias_buffers,execution=execution,)@@ -1213,14 +1367,15 @@ class _OpenAIChatStreamRunner:else:repair_events = []events = list(repair_events)- events.extend(ledger.close_all_blocks())- events.append(- ledger.message_delta(- ledger.final_stop_reason("end_turn"),- ledger.estimate_output_tokens(),+ events.extend(+ output.finish_success(+ stop_reason="end_turn",+ usage=ChatStreamUsage(+ input_tokens=self._input_tokens,+ output_tokens=output.estimate_output_tokens(),+ ),))- events.append(ledger.message_stop())trace_event(stage="provider",event="provider.recovery.tool_salvaged",@@ -1230,8 +1385,8 @@ class _OpenAIChatStreamRunner:)return events- partial_text = ledger.accumulated_text- partial_thinking = ledger.accumulated_reasoning+ partial_text = output.accumulated_text+ partial_thinking = output.accumulated_reasoningif not partial_text and not partial_thinking:return None@@ -1257,24 +1412,26 @@ class _OpenAIChatStreamRunner:thinking_suffix = continuation_suffix(partial_thinking, recovered.thinking)events: list[str] = []if thinking_suffix:- events.extend(ledger.ensure_thinking_block())- events.append(ledger.emit_thinking_delta(thinking_suffix))+ events.extend(output.ensure_reasoning_block())+ events.append(output.emit_reasoning_delta(thinking_suffix))if text_suffix:- events.extend(ledger.ensure_text_block())- events.append(ledger.emit_text_delta(text_suffix))+ events.extend(output.ensure_text_block())+ events.append(output.emit_text_delta(text_suffix))if recovered.tool_calls:- events.extend(ledger.close_content_blocks())+ events.extend(output.close_content_blocks())for tool_call in recovered.tool_calls:events.extend(assembler.recovered_tool_call_events(tool_call))if not events:return None- events.extend(ledger.close_all_blocks())- events.append(- ledger.message_delta(- ledger.final_stop_reason("end_turn"), ledger.estimate_output_tokens()+ events.extend(+ output.finish_success(+ stop_reason="end_turn",+ usage=ChatStreamUsage(+ input_tokens=self._input_tokens,+ output_tokens=output.estimate_output_tokens(),+ ),))- events.append(ledger.message_stop())trace_event(stage="provider",event="provider.recovery.continued",@@ -1288,14 +1445,14 @@ class _OpenAIChatStreamRunner:self,*,body: dict[str, Any],- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,tool_argument_alias_buffers: Mapping[int, str],execution: ProviderExecution,) -> list[str] | None:- schemas = tool_schemas_by_name(self._request)+ schemas = self._tool_schemasevents: list[str] = []- for tool_index, state in started_tool_states(ledger):- block = ledger.tool_block_for_tool_index(tool_index)+ for tool_index, state in output.started_tool_states():+ block = output.tool_block_for_tool_index(tool_index)emitted_prefix = block.content if block is not None else ""repair_prefix = emitted_prefixif not repair_prefix and state.name == "Task" and state.task_arg_buffer:@@ -1307,7 +1464,7 @@ class _OpenAIChatStreamRunner:is not None):if not emitted_prefix and repair_prefix:- events.append(ledger.emit_tool_delta(tool_index, repair_prefix))+ events.append(output.emit_tool_delta(tool_index, repair_prefix))continueschema = schemas.get(state.name)@@ -1350,8 +1507,8 @@ class _OpenAIChatStreamRunner:accepted_suffix if emitted_prefix else repair_prefix + accepted_suffix)if to_emit:- events.append(ledger.emit_tool_delta(tool_index, to_emit))- if not all_emitted_tools_complete(ledger, self._request):+ events.append(output.emit_tool_delta(tool_index, to_emit))+ if not output.can_salvage_tool_use(schemas):return Nonereturn events@@ -1359,28 +1516,27 @@ class _OpenAIChatStreamRunner:self, *, output_reasoning: bool) -> _OpenAIChatStreamAssembler:def extra_reasoning_events(- delta: Any, ledger: AnthropicStreamLedger+ delta: Any, output: ChatStreamOutput) -> Iterator[str]:yield from self._provider._handle_extra_reasoning(delta,- ledger,+ output,output_reasoning=output_reasoning,)return _OpenAIChatStreamAssembler(- request=self._request,- ledger=AnthropicStreamLedger(- self._message_id,- self._response_model,- self._input_tokens,- log_raw_events=self._provider._config.log_raw_sse_events,- ),+ output=self._output_factory(),profile=self._provider._profile,provider_name=self._provider._provider_name,output_reasoning=output_reasoning,tool_names=self._tool_names,+ tool_schemas=self._tool_schemas,+ tool_choice_enabled=(+ bool(self._body.get("tools"))+ and self._body.get("tool_choice") != "none"+ ),tool_calls=OpenAIToolCallAssembler(- request=self._request,+ reserved_tool_ids=self._reserved_tool_ids,record_extra_content=self._provider._record_tool_call_extra_content,),extra_reasoning_events=extra_reasoning_events,diff --git a/src/free_claude_code/providers/openai_chat/reasoning_details.py b/src/free_claude_code/providers/openai_chat/reasoning_details.pyindex fa7852cb..ff194289 100644--- a/src/free_claude_code/providers/openai_chat/reasoning_details.py+++ b/src/free_claude_code/providers/openai_chat/reasoning_details.py@@ -8,9 +8,10 @@ from free_claude_code.core.anthropic import (is_synthetic_openai_tool_turn_boundary,)from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.streaming import AnthropicStreamLedgerfrom free_claude_code.core.reasoning import ReasoningPolicy+from .stream_output import ChatStreamOutput+def apply_reasoning_details_replay(body: dict[str, Any], request: MessagesRequest, _policy: ReasoningPolicy@@ -51,7 +52,7 @@ class StructuredReasoningStream:def events(self,delta: Any,- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,*,native_reasoning: str | None,) -> Iterator[str]:@@ -64,26 +65,19 @@ class StructuredReasoningStream:self._text_source = "details"if self._text_source == "native" and native_reasoning:- yield from ledger.ensure_thinking_block()- yield ledger.emit_thinking_delta(native_reasoning)+ yield from output.ensure_reasoning_block()+ yield output.emit_reasoning_delta(native_reasoning)for detail in details:if self._text_source == "details":text = _reasoning_detail_text(detail)if text:- yield from ledger.ensure_thinking_block()- yield ledger.emit_thinking_delta(text)+ yield from output.ensure_reasoning_block()+ yield output.emit_reasoning_delta(text)preserved = _preserved_reasoning_detail(detail)if preserved:- yield from ledger.close_content_blocks()- index = ledger.blocks.allocate_index()- yield ledger.content_block_start(- index,- "redacted_thinking",- data=preserved,- )- yield ledger.content_block_stop(index)+ yield from output.emit_opaque_reasoning(preserved)def _reasoning_details(delta: Any) -> Sequence[Any]:diff --git a/src/free_claude_code/providers/openai_chat/request_policy.py b/src/free_claude_code/providers/openai_chat/request_policy.pyindex 5cf584df..4dba4ef4 100644--- a/src/free_claude_code/providers/openai_chat/request_policy.py+++ b/src/free_claude_code/providers/openai_chat/request_policy.py@@ -9,12 +9,15 @@ from loguru import loggerfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.core.anthropic import (- OpenAIToolNameCodec,ReasoningReplayMode,build_base_request_body,)from free_claude_code.core.anthropic.conversion import OpenAIConversionErrorfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.openai_tool_names import (+ OpenAIToolNameCodec,+ encode_openai_chat_tool_names,+)from free_claude_code.core.reasoning import ReasoningPolicyMaxTokensField = Literal["max_tokens", "max_completion_tokens"]@@ -76,12 +79,12 @@ def build_openai_chat_request_body(raise InvalidRequestError(str(exc)) from excbody["extra_body"] = extra_body- _apply_common_openai_chat_policy(body, policy)+ apply_openai_chat_body_policy(body, policy)for postprocess in postprocessors:postprocess(body, request_data, reasoning)- _encode_openai_tool_names(body, OpenAIToolNameCodec.from_request(request_data))+ encode_openai_chat_tool_names(body, OpenAIToolNameCodec.from_request(request_data))logger.debug("{}_REQUEST: conversion done model={} msgs={} tools={}",@@ -93,62 +96,10 @@ def build_openai_chat_request_body(return body-def _encode_openai_tool_names(body: dict[str, Any], codec: OpenAIToolNameCodec) -> None:- """Encode only canonical OpenAI Chat tool-name locations."""- if not codec.has_aliases:- return-- tools = body.get("tools")- if isinstance(tools, list):- for tool in tools:- if not isinstance(tool, dict):- continue- function = tool.get("function")- if not isinstance(function, dict):- continue- name = function.get("name")- if isinstance(name, str):- function["name"] = codec.encode(name)-- messages = body.get("messages")- if isinstance(messages, list):- for message in messages:- if not isinstance(message, dict):- continue- tool_calls = message.get("tool_calls")- if not isinstance(tool_calls, list):- continue- for tool_call in tool_calls:- if not isinstance(tool_call, dict):- continue- function = tool_call.get("function")- if not isinstance(function, dict):- continue- name = function.get("name")- if isinstance(name, str):- function["name"] = codec.encode(name)-- tool_choice = body.get("tool_choice")- if not isinstance(tool_choice, dict):- return- function = tool_choice.get("function")- if not isinstance(function, dict):- return- name = function.get("name")- if not isinstance(name, str):- return- encoded = codec.encode(name)- if encoded == name:- return- body["tool_choice"] = {- **tool_choice,- "function": {**function, "name": encoded},- }---def _apply_common_openai_chat_policy(+def apply_openai_chat_body_policy(body: dict[str, Any], policy: OpenAIChatRequestPolicy) -> None:+ """Apply source-independent Chat Completions body policy."""if policy.strip_message_names:_strip_message_names(body.get("messages"))diff --git a/src/free_claude_code/providers/openai_chat/stream_output.py b/src/free_claude_code/providers/openai_chat/stream_output.pynew file mode 100644index 00000000..6f4e4579--- /dev/null+++ b/src/free_claude_code/providers/openai_chat/stream_output.py@@ -0,0 +1,700 @@+"""Chat-source output writers for Anthropic Messages and OpenAI Responses."""++import hashlib+import json+import time+import uuid+from abc import ABC, abstractmethod+from collections.abc import Mapping+from dataclasses import dataclass, field++from loguru import logger++from free_claude_code.core.anthropic.streaming import (+ AnthropicStreamLedger,+ ToolSchema,+ parse_complete_tool_input,+)+from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ ReasoningBlockState,+ ResponseBlockCompleter,+ ResponseEventBuilder,+ ResponsesConversionError,+ ResponsesOutputLedger,+ TextBlockState,+ ToolBlockState,+ new_call_id,+ new_message_item_id,+ new_reasoning_item_id,+ new_response_id,+ openai_error_from_failure,+ reasoning_output_item,+ replay_unsafe_function_call_error,+ responses_tool_identity_from_anthropic_name,+ tool_item,+)+from free_claude_code.core.token_estimation import estimate_text_tokens+from free_claude_code.core.trace import trace_event+++@dataclass(frozen=True, slots=True)+class ChatStreamUsage:+ """Final Chat usage normalized for either client wire protocol."""++ input_tokens: int+ output_tokens: int+ cached_tokens: int = 0+ reasoning_tokens: int = 0+ anthropic_fields: Mapping[str, int] = field(default_factory=dict)+++@dataclass(slots=True)+class ChatToolState:+ """Chat parser state for one streamed tool call."""++ tool_id: str = ""+ name: str = ""+ extra_content: JsonObject | None = None+ started: bool = False+ open: bool = False+ task_arg_buffer: str = ""+ task_args_emitted: bool = False+ pre_start_args: str = ""+ argument_parts: list[str] = field(default_factory=list)++ @property+ def content(self) -> str:+ return "".join(self.argument_parts)+++class ChatStreamOutput(ABC):+ """Source-specific semantic output boundary for one Chat stream epoch."""++ consumes_terminal_failure = False++ def __init__(self, *, input_tokens: int) -> None:+ self.input_tokens = input_tokens+ self.tool_states: dict[int, ChatToolState] = {}+ self._text_parts: list[str] = []+ self._reasoning_parts: list[str] = []+ self._text_started = False+ self._reasoning_started = False+ self._content_started = False+ self._terminal = False++ @property+ def committed_output(self) -> bool:+ return self._content_started++ @property+ def accumulated_text(self) -> str:+ return "".join(self._text_parts)++ @property+ def accumulated_reasoning(self) -> str:+ return "".join(self._reasoning_parts)++ def start_events(self) -> list[str]:+ return self._start_events()++ def ensure_reasoning_block(self) -> list[str]:+ events: list[str] = []+ if self._text_started:+ events.extend(self._stop_text_block())+ self._text_started = False+ if not self._reasoning_started:+ events.extend(self._start_reasoning_block())+ self._reasoning_started = True+ self._content_started = True+ return events++ def emit_reasoning_delta(self, content: str) -> str:+ self._reasoning_parts.append(content)+ return self._emit_reasoning_delta(content)++ def emit_opaque_reasoning(self, data: str) -> list[str]:+ events = self.close_content_blocks()+ events.extend(self._emit_opaque_reasoning(data))+ if data:+ self._content_started = True+ return events++ def ensure_text_block(self) -> list[str]:+ events: list[str] = []+ if self._reasoning_started:+ events.extend(self._stop_reasoning_block())+ self._reasoning_started = False+ if not self._text_started:+ events.extend(self._start_text_block())+ self._text_started = True+ self._content_started = True+ return events++ def emit_text_delta(self, content: str) -> str:+ self._text_parts.append(content)+ return self._emit_text_delta(content)++ def close_content_blocks(self) -> list[str]:+ events: list[str] = []+ if self._reasoning_started:+ events.extend(self._stop_reasoning_block())+ self._reasoning_started = False+ if self._text_started:+ events.extend(self._stop_text_block())+ self._text_started = False+ return events++ def ensure_tool_state(self, tool_index: int) -> ChatToolState:+ return self.tool_states.setdefault(tool_index, ChatToolState())++ def set_tool_extra_content(+ self, tool_index: int, extra_content: JsonObject | None+ ) -> None:+ if extra_content:+ self.ensure_tool_state(tool_index).extra_content = extra_content++ def register_tool_name(self, tool_index: int, name: str) -> None:+ state = self.ensure_tool_state(tool_index)+ previous = state.name+ if not previous or name.startswith(previous):+ state.name = name+ elif not previous.startswith(name):+ state.name = previous + name++ def start_tool_block(+ self,+ tool_index: int,+ tool_id: str,+ name: str,+ *,+ extra_content: JsonObject | None = None,+ ) -> str:+ state = self.ensure_tool_state(tool_index)+ state.tool_id = tool_id+ state.name = name+ if extra_content:+ state.extra_content = extra_content+ state.started = True+ state.open = True+ self._content_started = True+ return self._start_tool_block(tool_index, state)++ def emit_tool_delta(self, tool_index: int, partial_json: str) -> str:+ state = self.tool_states[tool_index]+ state.argument_parts.append(partial_json)+ return self._emit_tool_delta(tool_index, state, partial_json)++ def stop_tool_block(self, tool_index: int) -> list[str]:+ state = self.tool_states[tool_index]+ if not state.open:+ return []+ state.open = False+ return self._stop_tool_block(tool_index, state)++ def close_all_blocks(self) -> list[str]:+ events = self.close_content_blocks()+ for tool_index, state in self.tool_states.items():+ if state.open:+ events.extend(self.stop_tool_block(tool_index))+ return events++ def close_unclosed_blocks(self) -> list[str]:+ return self.close_all_blocks()++ def has_emitted_tool_block(self) -> bool:+ return any(state.started for state in self.tool_states.values())++ def has_content_block(self) -> bool:+ return self._content_started++ def final_stop_reason(self, fallback: str) -> str:+ return "tool_use" if self.has_emitted_tool_block() else fallback++ def tool_block_for_tool_index(self, tool_index: int) -> ChatToolState | None:+ state = self.tool_states.get(tool_index)+ return state if state is not None and state.started else None++ def started_tool_states(self) -> list[tuple[int, ChatToolState]]:+ return [+ (tool_index, state)+ for tool_index, state in self.tool_states.items()+ if state.started+ ]++ def can_salvage_tool_use(self, schemas: dict[str, ToolSchema]) -> bool:+ states = [state for state in self.tool_states.values() if state.started]+ return bool(states) and all(+ state.tool_id+ and state.name+ and parse_complete_tool_input(state.content, state.name, schemas)+ is not None+ for state in states+ )++ def buffer_task_args(+ self, tool_index: int, arguments: str+ ) -> dict[str, object] | None:+ state = self.tool_states.get(tool_index)+ if state is None or state.task_args_emitted:+ return None+ state.task_arg_buffer += arguments+ try:+ parsed = json.loads(state.task_arg_buffer)+ except json.JSONDecodeError:+ return None+ if not isinstance(parsed, dict):+ return None+ _normalize_task_args(parsed)+ state.task_args_emitted = True+ state.task_arg_buffer = ""+ return parsed++ def flush_task_arg_buffers(self) -> list[tuple[int, str]]:+ results: list[tuple[int, str]] = []+ for tool_index, state in self.tool_states.items():+ if not state.task_arg_buffer or state.task_args_emitted:+ continue+ output = "{}"+ try:+ parsed = json.loads(state.task_arg_buffer)+ if isinstance(parsed, dict):+ _normalize_task_args(parsed)+ output = json.dumps(parsed)+ except (json.JSONDecodeError, TypeError, ValueError) as exc:+ digest = hashlib.sha256(+ state.task_arg_buffer.encode("utf-8", errors="replace")+ ).hexdigest()[:16]+ logger.warning(+ "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",+ state.tool_id or "unknown",+ len(state.task_arg_buffer),+ digest,+ exc,+ )+ state.task_args_emitted = True+ state.task_arg_buffer = ""+ results.append((tool_index, output))+ return results++ def estimate_output_tokens(self) -> int:+ tool_tokens = sum(+ estimate_text_tokens(state.name) + estimate_text_tokens(state.content) + 15+ for state in self.tool_states.values()+ if state.started+ )+ block_count = (+ (1 if self.accumulated_reasoning else 0)+ + (1 if self.accumulated_text else 0)+ + sum(1 for state in self.tool_states.values() if state.started)+ )+ return (+ estimate_text_tokens(self.accumulated_text)+ + estimate_text_tokens(self.accumulated_reasoning)+ + tool_tokens+ + (block_count * 4)+ )++ def finish_success(self, *, stop_reason: str, usage: ChatStreamUsage) -> list[str]:+ if self._terminal:+ return []+ events = self.close_all_blocks()+ events.extend(self._finish_success(stop_reason=stop_reason, usage=usage))+ self._terminal = True+ return events++ def finish_failure(self, failure: ExecutionFailure) -> list[str]:+ if self._terminal:+ return []+ events = self.close_unclosed_blocks()+ events.extend(self._finish_failure(failure))+ self._terminal = True+ return events++ @abstractmethod+ def _start_events(self) -> list[str]: ...++ @abstractmethod+ def _start_reasoning_block(self) -> list[str]: ...++ @abstractmethod+ def _emit_reasoning_delta(self, content: str) -> str: ...++ @abstractmethod+ def _emit_opaque_reasoning(self, data: str) -> list[str]: ...++ @abstractmethod+ def _stop_reasoning_block(self) -> list[str]: ...++ @abstractmethod+ def _start_text_block(self) -> list[str]: ...++ @abstractmethod+ def _emit_text_delta(self, content: str) -> str: ...++ @abstractmethod+ def _stop_text_block(self) -> list[str]: ...++ @abstractmethod+ def _start_tool_block(self, tool_index: int, state: ChatToolState) -> str: ...++ @abstractmethod+ def _emit_tool_delta(+ self, tool_index: int, state: ChatToolState, partial_json: str+ ) -> str: ...++ @abstractmethod+ def _stop_tool_block(self, tool_index: int, state: ChatToolState) -> list[str]: ...++ @abstractmethod+ def _finish_success(+ self, *, stop_reason: str, usage: ChatStreamUsage+ ) -> list[str]: ...++ @abstractmethod+ def _finish_failure(self, failure: ExecutionFailure) -> list[str]: ...+++class AnthropicChatStreamOutput(ChatStreamOutput):+ """Anthropic SSE writer preserving the established Chat provider wire."""++ def __init__(+ self,+ *,+ message_id: str,+ model: str,+ input_tokens: int,+ log_raw_events: bool = False,+ ) -> None:+ super().__init__(input_tokens=input_tokens)+ self._ledger = AnthropicStreamLedger(+ message_id,+ model,+ input_tokens,+ log_raw_events=log_raw_events,+ )++ def close_unclosed_blocks(self) -> list[str]:+ events = list(self._ledger.close_unclosed_blocks())+ self._text_started = False+ self._reasoning_started = False+ for state in self.tool_states.values():+ state.open = False+ return events++ def _start_events(self) -> list[str]:+ return [self._ledger.message_start()]++ def _start_reasoning_block(self) -> list[str]:+ return [self._ledger.start_thinking_block()]++ def _emit_reasoning_delta(self, content: str) -> str:+ return self._ledger.emit_thinking_delta(content)++ def _emit_opaque_reasoning(self, data: str) -> list[str]:+ index = self._ledger.blocks.allocate_index()+ return [+ self._ledger.content_block_start(index, "redacted_thinking", data=data),+ self._ledger.content_block_stop(index),+ ]++ def _stop_reasoning_block(self) -> list[str]:+ return [self._ledger.stop_thinking_block()]++ def _start_text_block(self) -> list[str]:+ return [self._ledger.start_text_block()]++ def _emit_text_delta(self, content: str) -> str:+ return self._ledger.emit_text_delta(content)++ def _stop_text_block(self) -> list[str]:+ return [self._ledger.stop_text_block()]++ def _start_tool_block(self, tool_index: int, state: ChatToolState) -> str:+ return self._ledger.start_tool_block(+ tool_index,+ state.tool_id,+ state.name,+ extra_content=state.extra_content,+ )++ def _emit_tool_delta(+ self, tool_index: int, state: ChatToolState, partial_json: str+ ) -> str:+ return self._ledger.emit_tool_delta(tool_index, partial_json)++ def _stop_tool_block(self, tool_index: int, state: ChatToolState) -> list[str]:+ return [self._ledger.stop_tool_block(tool_index)]++ def _finish_success(self, *, stop_reason: str, usage: ChatStreamUsage) -> list[str]:+ return [+ self._ledger.message_delta(+ self.final_stop_reason(stop_reason),+ usage.output_tokens,+ input_tokens=usage.input_tokens,+ usage_fields=usage.anthropic_fields,+ ),+ self._ledger.message_stop(),+ ]++ def _finish_failure(self, failure: ExecutionFailure) -> list[str]:+ return []+++class ResponsesChatStreamOutput(ChatStreamOutput):+ """Direct Chat-to-Responses writer with one coherent Responses lifecycle."""++ consumes_terminal_failure = True++ def __init__(+ self,+ request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ response_model: str | None = None,+ ) -> None:+ super().__init__(input_tokens=input_tokens)+ self._request = request+ self._response_model = response_model or request.model+ self._response_id = new_response_id()+ self._created_at = int(time.time())+ self._ledger = ResponsesOutputLedger()+ self._events = ResponseEventBuilder()+ self._completer = ResponseBlockCompleter(+ self._ledger,+ events=self._events,+ on_invalid_function_call=self._fail_invalid_function_call,+ )+ self._text_state: TextBlockState | None = None+ self._reasoning_state: ReasoningBlockState | None = None+ self._tool_output_states: dict[int, ToolBlockState] = {}+ self._usage: dict[str, object] | None = None+ self._provisional_error: dict[str, object] | None = None+ self._started = False++ def _response_payload(+ self,+ *,+ status: str,+ error: Mapping[str, object] | None = None,+ incomplete_details: Mapping[str, str] | None = None,+ ) -> dict[str, object]:+ return {+ "id": self._response_id,+ "object": "response",+ "created_at": self._created_at,+ "status": status,+ "model": self._response_model,+ "output": self._ledger.output(),+ "parallel_tool_calls": (+ True+ if self._request.parallel_tool_calls is None+ else self._request.parallel_tool_calls+ ),+ "tool_choice": (+ "auto"+ if self._request.tool_choice is None+ else self._request.tool_choice+ ),+ "temperature": self._request.temperature,+ "top_p": self._request.top_p,+ "max_output_tokens": self._request.max_output_tokens,+ "usage": self._usage,+ "error": dict(error) if error is not None else None,+ "incomplete_details": (+ dict(incomplete_details) if incomplete_details is not None else None+ ),+ }++ def _start_events(self) -> list[str]:+ if self._started:+ return []+ self._started = True+ return [+ self._events.response_created(self._response_payload(status="in_progress"))+ ]++ def _start_reasoning_block(self) -> list[str]:+ output_index = self._ledger.reserve_output_slot()+ state = ReasoningBlockState(+ index=output_index,+ output_index=output_index,+ item_id=new_reasoning_item_id(),+ )+ self._reasoning_state = state+ self._ledger.set_active_block(state)+ return [+ self._events.output_item_added(+ output_index,+ reasoning_output_item(state, status="in_progress"),+ )+ ]++ def _emit_reasoning_delta(self, content: str) -> str:+ state = self._reasoning_state+ if state is None or not content:+ return ""+ state.text_parts.append(content)+ return self._events.reasoning_text_delta(+ state.item_id, state.output_index, content+ )++ def _emit_opaque_reasoning(self, data: str) -> list[str]:+ output_index = self._ledger.reserve_output_slot()+ state = ReasoningBlockState(+ index=output_index,+ output_index=output_index,+ item_id=new_reasoning_item_id(),+ encrypted_content=data,+ )+ self._ledger.set_active_block(state)+ events = [+ self._events.output_item_added(+ output_index,+ reasoning_output_item(state, status="in_progress"),+ )+ ]+ self._ledger.pop_active_block(state.index)+ events.extend(self._completer.complete_block(state))+ return events++ def _stop_reasoning_block(self) -> list[str]:+ state = self._reasoning_state+ self._reasoning_state = None+ if state is None:+ return []+ self._ledger.pop_active_block(state.index)+ return self._completer.complete_block(state)++ def _start_text_block(self) -> list[str]:+ output_index = self._ledger.reserve_output_slot()+ state = TextBlockState(+ index=output_index,+ output_index=output_index,+ item_id=new_message_item_id(),+ )+ self._text_state = state+ self._ledger.set_active_block(state)+ item = {+ "id": state.item_id,+ "type": "message",+ "status": "in_progress",+ "role": "assistant",+ "content": [],+ }+ return [+ self._events.output_item_added(output_index, item),+ self._events.content_part_added(state.item_id, output_index),+ ]++ def _emit_text_delta(self, content: str) -> str:+ state = self._text_state+ if state is None or not content:+ return ""+ state.text_parts.append(content)+ return self._events.output_text_delta(+ state.item_id, state.output_index, content+ )++ def _stop_text_block(self) -> list[str]:+ state = self._text_state+ self._text_state = None+ if state is None:+ return []+ self._ledger.pop_active_block(state.index)+ return self._completer.complete_block(state)++ def _start_tool_block(self, tool_index: int, state: ChatToolState) -> str:+ identity = responses_tool_identity_from_anthropic_name(+ self._request.tools, state.name+ )+ output_index = self._ledger.reserve_output_slot()+ output_state = ToolBlockState(+ index=output_index,+ output_index=output_index,+ item_id=f"{'ctc' if identity.kind == 'custom' else 'fc'}_"+ f"{uuid.uuid4().hex[:24]}",+ call_id=state.tool_id or new_call_id(),+ kind=identity.kind,+ name=identity.name,+ namespace=identity.namespace,+ )+ self._tool_output_states[tool_index] = output_state+ self._ledger.set_active_block(output_state)+ return self._events.output_item_added(+ output_index,+ tool_item(output_state, status="in_progress"),+ )++ def _emit_tool_delta(+ self, tool_index: int, state: ChatToolState, partial_json: str+ ) -> str:+ output_state = self._tool_output_states.get(tool_index)+ if output_state is not None:+ output_state.argument_parts.append(partial_json)+ return ""++ def _stop_tool_block(self, tool_index: int, state: ChatToolState) -> list[str]:+ output_state = self._tool_output_states.get(tool_index)+ if output_state is None:+ return []+ self._ledger.pop_active_block(output_state.index)+ return self._completer.complete_block(output_state)++ def _finish_success(self, *, stop_reason: str, usage: ChatStreamUsage) -> list[str]:+ self._usage = _responses_usage(usage)+ if self._provisional_error is not None:+ response = self._response_payload(+ status="failed",+ error=self._provisional_error,+ )+ return [self._events.response_failed(response)]+ if stop_reason in {"length", "max_tokens"}:+ response = self._response_payload(+ status="incomplete",+ incomplete_details={"reason": "max_output_tokens"},+ )+ return [self._events.response_incomplete(response)]+ response = self._response_payload(status="completed")+ return [self._events.response_completed(response)]++ def _finish_failure(self, failure: ExecutionFailure) -> list[str]:+ response = self._response_payload(+ status="failed",+ error=openai_error_from_failure(failure),+ )+ return [self._events.response_failed(response)]++ def _fail_invalid_function_call(+ self, state: ToolBlockState, exc: ResponsesConversionError+ ) -> list[str]:+ trace_event(+ stage="responses",+ event="responses.output.function_call_invalid_arguments",+ source="openai_responses",+ call_id=state.call_id,+ tool_name=state.name,+ error_type=type(exc).__name__,+ )+ if self._provisional_error is None:+ self._provisional_error = replay_unsafe_function_call_error()+ return []+++def _responses_usage(usage: ChatStreamUsage) -> dict[str, object]:+ cached_tokens = max(0, min(usage.cached_tokens, usage.input_tokens))+ reasoning_tokens = max(0, min(usage.reasoning_tokens, usage.output_tokens))+ return {+ "input_tokens": usage.input_tokens,+ "input_tokens_details": {"cached_tokens": cached_tokens},+ "output_tokens": usage.output_tokens,+ "output_tokens_details": {"reasoning_tokens": reasoning_tokens},+ "total_tokens": usage.input_tokens + usage.output_tokens,+ }+++def _normalize_task_args(arguments: dict[str, object]) -> None:+ if arguments.get("run_in_background") is not False:+ arguments["run_in_background"] = Falsediff --git a/src/free_claude_code/providers/openai_chat/tool_calls.py b/src/free_claude_code/providers/openai_chat/tool_calls.pyindex 63a78814..498d0ea8 100644--- a/src/free_claude_code/providers/openai_chat/tool_calls.py+++ b/src/free_claude_code/providers/openai_chat/tool_calls.py@@ -2,21 +2,18 @@import jsonimport uuid-from collections.abc import Callable, Iterator, Mapping+from collections.abc import Callable, Iterable, Iterator, Mappingfrom dataclasses import dataclass, fieldfrom typing import Any, NotRequired, TypedDict-from free_claude_code.core.anthropic import OpenAIToolNameCodec-from free_claude_code.core.anthropic.models import (- ContentBlockToolUse,- MessagesRequest,-)from free_claude_code.core.anthropic.streaming import (- AnthropicStreamLedger,+ ToolSchema,parse_complete_tool_input,- tool_schemas_by_name,)from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec++from .stream_output import ChatStreamOutputRecordToolExtraContent = Callable[[str, dict[str, Any]], None]@@ -79,13 +76,12 @@ class OpenAIToolCallCollector:def completed_calls(self,- request: MessagesRequest,+ schemas: dict[str, ToolSchema],*,tool_names: OpenAIToolNameCodec | None = None,tool_argument_aliases: dict[str, dict[str, str]] | None = None,) -> tuple[CompletedOpenAIToolCall, ...] | None:"""Return complete schema-valid calls, or None when output is incomplete."""- schemas = tool_schemas_by_name(request)completed: list[CompletedOpenAIToolCall] = []for index in sorted(self._calls):state = self._calls[index]@@ -121,8 +117,8 @@ class OpenAIToolCallCollector:return tuple(completed)-def iter_heuristic_tool_use_sse(- ledger: AnthropicStreamLedger,+def iter_heuristic_tool_use_events(+ output: ChatStreamOutput,tool_use: dict[str, Any],*,tool_names: OpenAIToolNameCodec | None = None,@@ -137,20 +133,17 @@ def iter_heuristic_tool_use_sse(task_input = tool_use["input"]if task_input.get("run_in_background") is not False:task_input["run_in_background"] = False- yield from ledger.close_content_blocks()- block_idx = ledger.blocks.allocate_index()- yield ledger.content_block_start(- block_idx,- "tool_use",- id=tool_use["id"],- name=tool_use["name"],- )- yield ledger.content_block_delta(- block_idx,- "input_json_delta",- json.dumps(tool_use["input"]),+ yield from output.close_content_blocks()+ tool_index = len(output.tool_states)+ output.ensure_tool_state(tool_index)+ output.register_tool_name(tool_index, str(tool_use["name"]))+ yield output.start_tool_block(+ tool_index,+ str(tool_use["id"]),+ str(tool_use["name"]),)- yield ledger.content_block_stop(block_idx)+ yield output.emit_tool_delta(tool_index, json.dumps(tool_use["input"]))+ yield from output.stop_tool_block(tool_index)def tool_call_extra_content(tool_call: Any) -> dict[str, Any] | None:@@ -178,66 +171,35 @@ def tool_call_extra_content(tool_call: Any) -> dict[str, Any] | None:return None-def has_committed_sse_output(ledger: AnthropicStreamLedger) -> bool:- """Return whether any assistant content escaped the builder."""- return (- ledger.blocks.text_index != -1- or ledger.blocks.thinking_index != -1- or ledger.has_emitted_tool_block()- )---def started_tool_states(ledger: AnthropicStreamLedger) -> list[tuple[int, Any]]:- """Return started tool states in stream order."""- return [- (tool_index, state)- for tool_index, state in ledger.blocks.tool_states.items()- if state.started- ]---def all_emitted_tools_complete(- ledger: AnthropicStreamLedger, request: MessagesRequest-) -> bool:- """Return whether every emitted tool block has schema-valid input."""- return ledger.can_salvage_tool_use(tool_schemas_by_name(request))--class OpenAIToolCallAssembler:"""Assemble OpenAI tool-call deltas into Anthropic SSE tool blocks."""def __init__(self,*,- request: MessagesRequest,+ reserved_tool_ids: Iterable[str],record_extra_content: RecordToolExtraContent | None = None,) -> None:self._record_extra_content = record_extra_content- self._reserved_tool_ids = {- block.id- for message in request.messages- if isinstance(message.content, list)- for block in message.content- if isinstance(block, ContentBlockToolUse) and block.id.strip()- }+ self._reserved_tool_ids = {tool_id for tool_id in reserved_tool_ids if tool_id}self._candidate_tool_ids: dict[int, str] = {}self._public_tool_ids: dict[int, str] = {}def process_tool_call(self,tc: Mapping[str, Any],- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,*,tool_names: OpenAIToolNameCodec | None = None,tool_name_buffers: dict[int, str] | None = None,tool_argument_aliases: dict[str, dict[str, str]] | None = None,tool_argument_alias_buffers: dict[int, str] | None = None,) -> Iterator[str]:- """Process a single tool-call delta and yield Anthropic SSE events."""+ """Process one tool-call delta and yield client-protocol events."""raw_index = tc.get("index", 0)tc_index = raw_index if isinstance(raw_index, int) else 0if tc_index < 0:- tc_index = len(ledger.blocks.tool_states)+ tc_index = len(output.tool_states)fn_delta = tc.get("function", {})incoming_name = fn_delta.get("name")@@ -245,7 +207,7 @@ class OpenAIToolCallAssembler:candidate_id = tc.get("id")if candidate_id is not None:- ledger.blocks.ensure_tool_state(tc_index)+ output.ensure_tool_state(tc_index)if (tc_index not in self._public_tool_idsand isinstance(candidate_id, str)@@ -260,7 +222,7 @@ class OpenAIToolCallAssembler:else None)if extra_content:- ledger.blocks.set_tool_extra_content(tc_index, extra_content)+ output.set_tool_extra_content(tc_index, extra_content)if isinstance(incoming_name, str) and incoming_name:resolved_name = _decode_streamed_tool_name(@@ -270,9 +232,9 @@ class OpenAIToolCallAssembler:buffers=tool_name_buffers,)if resolved_name is not None:- ledger.blocks.register_tool_name(tc_index, resolved_name)+ output.register_tool_name(tc_index, resolved_name)- state = ledger.blocks.tool_states.get(tc_index)+ state = output.tool_states.get(tc_index)resolved_name = (state.name if state else "") or ""if not state or not state.started:@@ -283,37 +245,37 @@ class OpenAIToolCallAssembler:start_extra_content = state.extra_content if state else extra_contentif start_extra_content:self._record_tool_call_extra_content(tool_id, start_extra_content)- yield ledger.start_tool_block(+ yield output.start_tool_block(tc_index,tool_id,display_name,extra_content=start_extra_content,)- state = ledger.blocks.tool_states[tc_index]+ state = output.tool_states[tc_index]if state.pre_start_args:pre = state.pre_start_argsstate.pre_start_args = ""yield from self._emit_tool_arg_delta(- ledger,+ output,tc_index,pre,tool_argument_aliases=tool_argument_aliases,tool_argument_alias_buffers=tool_argument_alias_buffers,)- state = ledger.blocks.tool_states.get(tc_index)+ state = output.tool_states.get(tc_index)if state is not None and state.tool_id and extra_content:self._record_tool_call_extra_content(state.tool_id, extra_content)if not arguments:returnif state is None or not state.started:- state = ledger.blocks.ensure_tool_state(tc_index)+ state = output.ensure_tool_state(tc_index)if not (resolved_name or "").strip():state.pre_start_args += argumentsreturnyield from self._emit_tool_arg_delta(- ledger,+ output,tc_index,arguments,tool_argument_aliases=tool_argument_aliases,@@ -337,14 +299,14 @@ class OpenAIToolCallAssembler:self._public_tool_ids[tool_index] = public_idreturn public_id- def flush_task_arg_buffers(self, ledger: AnthropicStreamLedger) -> Iterator[str]:+ def flush_task_arg_buffers(self, output: ChatStreamOutput) -> Iterator[str]:"""Emit buffered Task args as a single JSON delta."""- for tool_index, out in ledger.blocks.flush_task_arg_buffers():- yield ledger.emit_tool_delta(tool_index, out)+ for tool_index, out in output.flush_task_arg_buffers():+ yield output.emit_tool_delta(tool_index, out)def flush_tool_name_buffers(self,- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,*,tool_names: OpenAIToolNameCodec,tool_name_buffers: dict[int, str],@@ -359,7 +321,7 @@ class OpenAIToolCallAssembler:"index": tool_index,"function": {"name": name, "arguments": ""},},- ledger,+ output,tool_names=tool_names,tool_argument_aliases=tool_argument_aliases,tool_argument_alias_buffers=tool_argument_alias_buffers,@@ -367,7 +329,7 @@ class OpenAIToolCallAssembler:def flush_tool_argument_alias_buffers(self,- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,tool_argument_aliases: dict[str, dict[str, str]],tool_argument_alias_buffers: dict[int, str],) -> Iterator[str]:@@ -376,14 +338,14 @@ class OpenAIToolCallAssembler:if not buffered_args:tool_argument_alias_buffers.pop(tool_index, None)continue- state = ledger.blocks.tool_states.get(tool_index)+ state = output.tool_states.get(tool_index)if state is None or state.name == "Task":continuealiases = tool_argument_aliases.get(state.name, {})if not aliases:continuerestored = self._restore_aliased_tool_arguments(buffered_args, aliases)- yield ledger.emit_tool_delta(+ yield output.emit_tool_delta(tool_index,restored if restored is not None else buffered_args,)@@ -391,7 +353,7 @@ class OpenAIToolCallAssembler:def _emit_tool_arg_delta(self,- ledger: AnthropicStreamLedger,+ output: ChatStreamOutput,tc_index: int,args: str,*,@@ -401,13 +363,13 @@ class OpenAIToolCallAssembler:"""Emit one argument fragment for a started tool block."""if not args:return- state = ledger.blocks.tool_states.get(tc_index)+ state = output.tool_states.get(tc_index)if state is None:returnif state.name == "Task":- parsed = ledger.blocks.buffer_task_args(tc_index, args)+ parsed = output.buffer_task_args(tc_index, args)if parsed is not None:- yield ledger.emit_tool_delta(tc_index, json.dumps(parsed))+ yield output.emit_tool_delta(tc_index, json.dumps(parsed))returnaliases = (tool_argument_aliases.get(state.name, {}) if tool_argument_aliases else {}@@ -416,7 +378,7 @@ class OpenAIToolCallAssembler:if tool_argument_alias_buffers is None:restored = self._restore_aliased_tool_arguments(args, aliases)if restored is not None:- yield ledger.emit_tool_delta(tc_index, restored)+ yield output.emit_tool_delta(tc_index, restored)returnbuffered_args = tool_argument_alias_buffers.get(tc_index, "") + args@@ -425,9 +387,9 @@ class OpenAIToolCallAssembler:tool_argument_alias_buffers[tc_index] = buffered_argsreturntool_argument_alias_buffers.pop(tc_index, None)- yield ledger.emit_tool_delta(tc_index, restored)+ yield output.emit_tool_delta(tc_index, restored)return- yield ledger.emit_tool_delta(tc_index, args)+ yield output.emit_tool_delta(tc_index, args)def _restore_aliased_tool_arguments(self, argument_json: str, aliases: dict[str, str]diff --git a/src/free_claude_code/providers/openai_chat/usage.py b/src/free_claude_code/providers/openai_chat/usage.pyindex 4be8dff1..d0220e6a 100644--- a/src/free_claude_code/providers/openai_chat/usage.py+++ b/src/free_claude_code/providers/openai_chat/usage.py@@ -73,6 +73,25 @@ def usage_int(usage_info: Any, key: str) -> int | None:return value if isinstance(value, int) and not isinstance(value, bool) else None+def nested_usage_int(usage_info: Any, parent: str, key: str) -> int | None:+ """Extract one nested integer from SDK usage objects or plain mappings."""+ if usage_info is None:+ return None+ if isinstance(usage_info, Mapping):+ details = usage_info.get(parent)+ else:+ details = getattr(usage_info, parent, None)+ if details is None:+ extra = getattr(usage_info, "model_extra", None)+ if isinstance(extra, Mapping):+ details = extra.get(parent)+ if isinstance(details, Mapping):+ value = details.get(key)+ else:+ value = getattr(details, key, None)+ return value if isinstance(value, int) and not isinstance(value, bool) else None++def _is_bad_request_like(error: Exception) -> bool:if isinstance(error, openai.BadRequestError):return Truediff --git a/src/free_claude_code/providers/openai_codex/provider.py b/src/free_claude_code/providers/openai_codex/provider.pyindex 9bc69b17..cc02e3c3 100644--- a/src/free_claude_code/providers/openai_codex/provider.py+++ b/src/free_claude_code/providers/openai_codex/provider.py@@ -13,19 +13,23 @@ import httpxfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.diagnostics import (ERROR_DETAIL_DISPLAY_CAP_BYTES,attach_upstream_error_body,extract_upstream_error_detail,)from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,ResponsesConversionError,ResponsesProviderStream,ResponsesStreamFailure,+ build_native_responses_request,build_responses_provider_request,+ responses_stream_failure_from_event,)+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.reasoning import (DEFAULT_REASONING_POLICY,ReasoningPolicy,@@ -44,6 +48,12 @@ from free_claude_code.providers.failure_policy import (is_retryable_stream_error,)from free_claude_code.providers.http import ProviderAttemptScope, maybe_await_aclose+from free_claude_code.providers.openai_responses.presentation import (+ MessagesResponsesPresenter,+ NativeResponsesPresenter,+ ResponsesExecutionOutcome,+ ResponsesPresenterFactory,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -93,7 +103,7 @@ class OpenAICodexProvider(BaseProvider):)self._owns_client = client is None- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -103,6 +113,15 @@ class OpenAICodexProvider(BaseProvider):self._build_body(request, reasoning=reasoning)+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ """Validate one native Responses request before upstream I/O."""+ self._build_native_body(request, reasoning=reasoning)+async def cleanup(self) -> None:"""Close only provider-owned transport resources."""@@ -172,7 +191,7 @@ class OpenAICodexProvider(BaseProvider):execution.abandon()raise RuntimeError("OpenAI model discovery ended without an attempt outcome")- def stream_response(+ def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -185,12 +204,42 @@ class OpenAICodexProvider(BaseProvider):tool_names = OpenAIToolNameCodec.from_request(request)body = self._build_body(request, reasoning=reasoning)+ message_id = f"msg_{uuid.uuid4()}"return self._run_stream(body,- input_tokens=input_tokens,request_id=request_id,response_model=response_model or request.model,- tool_names=tool_names,+ presenter_factory=lambda: MessagesResponsesPresenter(+ ResponsesProviderStream(+ message_id=message_id,+ model=response_model or request.model,+ input_tokens=input_tokens,+ log_raw_events=self._config.log_raw_sse_events,+ tool_names=tool_names,+ )+ ),+ )++ def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> AsyncIterator[str]:+ """Relay the private Codex Responses stream as native Responses SSE."""+ del input_tokens+ body = self._build_native_body(request, reasoning=reasoning)+ public_model = response_model or request.model+ return self._run_stream(+ body,+ request_id=request_id,+ response_model=public_model,+ presenter_factory=lambda: NativeResponsesPresenter(+ public_model=public_model+ ),)@staticmethod@@ -209,23 +258,42 @@ class OpenAICodexProvider(BaseProvider):body.pop("metadata", None)return body+ @staticmethod+ def _build_native_body(+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> JsonObject:+ if not request.model.strip():+ raise InvalidRequestError("Responses request model must not be empty.")+ if request.input is None or request.input == "" or request.input == []:+ raise InvalidRequestError("Responses request input must not be empty.")+ body = build_native_responses_request(+ request,+ model=request.model,+ reasoning=reasoning,+ )+ body.pop("max_output_tokens", None)+ body.pop("metadata", None)+ return body+async def _run_stream(self,- body: dict[str, Any],+ body: JsonObject,*,- input_tokens: int,request_id: str | None,response_model: str,- tool_names: OpenAIToolNameCodec,+ presenter_factory: ResponsesPresenterFactory,) -> AsyncIterator[str]:execution = self._admission.start_execution(request_id=request_id)+ outcome = ResponsesExecutionOutcome()provider_stream = self._run_stream_execution(body,- input_tokens=input_tokens,request_id=request_id,response_model=response_model,- tool_names=tool_names,+ presenter_factory=presenter_factory,execution=execution,+ outcome=outcome,)try:async for event in provider_stream:@@ -236,24 +304,26 @@ class OpenAICodexProvider(BaseProvider):execution.fail(error)raiseelse:- execution.succeed()+ if outcome.failure is None:+ execution.succeed()+ else:+ execution.fail(outcome.failure)finally:await maybe_await_aclose(provider_stream)execution.abandon()async def _run_stream_execution(self,- body: dict[str, Any],+ body: JsonObject,*,- input_tokens: int,request_id: str | None,response_model: str,- tool_names: OpenAIToolNameCodec,+ presenter_factory: ResponsesPresenterFactory,execution: ProviderExecution,+ outcome: ResponsesExecutionOutcome,) -> AsyncIterator[str]:"""Run one Codex execution while retaining Responses transport ownership."""recovery = RecoveryController()- message_id = f"msg_{uuid.uuid4()}"session_id = str(uuid.uuid4())authentication_recovered = Falsetrace_event(@@ -270,16 +340,9 @@ class OpenAICodexProvider(BaseProvider):)while execution.can_attempt:- stream = ResponsesProviderStream(- message_id=message_id,- model=response_model,- input_tokens=input_tokens,- log_raw_events=self._config.log_raw_sse_events,- tool_names=tool_names,- )- for event in stream.start():- for held in recovery.push(event):- yield held+ presenter = presenter_factory()+ start_events = tuple(presenter.start())+ presenter_started = Falsescope: ProviderAttemptScope | None = Nonestream_opened = False@@ -338,10 +401,24 @@ class OpenAICodexProvider(BaseProvider):async for event_type, payload in _iter_sse(response):if not scope.attempt.accepted:await scope.attempt.accept()- for event in stream.feed(event_type, payload):+ if not presenter_started:+ presenter_started = True+ for event in start_events:+ for held in recovery.push(event):+ yield held+ if event_type in {+ "response.failed",+ "error",+ "response.error",+ }:+ raise responses_stream_failure_from_event(+ event_type,+ payload,+ )+ for event in presenter.feed(event_type, payload):for held in recovery.push(event):yield held- if not stream.completed:+ if not presenter.completed:raise _TruncatedResponsesStream("OpenAI Responses stream ended without a terminal event.")@@ -414,8 +491,11 @@ class OpenAICodexProvider(BaseProvider):if not decision.committed:recovery.discard()raise failure from raw_error- for event in stream.ledger.close_unclosed_blocks():+ for event in presenter.terminal_failure(raw_error, failure):yield event+ if presenter.terminal_failure_completes_wire:+ outcome.failure = failure+ returnraise failure from raw_errorfinally:if scope is not None:diff --git a/src/free_claude_code/providers/openai_responses/presentation.py b/src/free_claude_code/providers/openai_responses/presentation.pynew file mode 100644index 00000000..80fa56e3--- /dev/null+++ b/src/free_claude_code/providers/openai_responses/presentation.py@@ -0,0 +1,106 @@+"""Client-protocol presenters shared by Responses upstream transports."""++from collections.abc import Callable, Iterable+from dataclasses import dataclass+from typing import Protocol++from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses import (+ NativeResponsesRelay,+ ResponsesProviderStream,+ ResponsesStreamFailure,+)+++class ResponsesStreamPresenter(Protocol):+ """One client-protocol view over an upstream Responses attempt."""++ @property+ def completed(self) -> bool: ...++ @property+ def terminal_failure_completes_wire(self) -> bool: ...++ def start(self) -> Iterable[str]: ...++ def feed(self, event_type: str, payload: JsonObject) -> Iterable[str]: ...++ def terminal_failure(+ self,+ raw_error: Exception,+ failure: ExecutionFailure,+ ) -> Iterable[str]: ...+++class MessagesResponsesPresenter:+ """Translate one Responses attempt into Anthropic Messages SSE."""++ def __init__(self, stream: ResponsesProviderStream) -> None:+ self._stream = stream++ @property+ def completed(self) -> bool:+ return self._stream.completed++ @property+ def terminal_failure_completes_wire(self) -> bool:+ return False++ def start(self) -> Iterable[str]:+ return self._stream.start()++ def feed(self, event_type: str, payload: JsonObject) -> Iterable[str]:+ return self._stream.feed(event_type, payload)++ def terminal_failure(+ self,+ raw_error: Exception,+ failure: ExecutionFailure,+ ) -> Iterable[str]:+ del raw_error, failure+ return self._stream.ledger.close_unclosed_blocks()+++class NativeResponsesPresenter:+ """Relay one Responses attempt as native Responses SSE."""++ def __init__(self, *, public_model: str) -> None:+ self._relay = NativeResponsesRelay(public_model=public_model)++ @property+ def completed(self) -> bool:+ return self._relay.completed++ @property+ def terminal_failure_completes_wire(self) -> bool:+ return True++ def start(self) -> Iterable[str]:+ return ()++ def feed(self, event_type: str, payload: JsonObject) -> Iterable[str]:+ return (self._relay.feed(event_type, payload),)++ def terminal_failure(+ self,+ raw_error: Exception,+ failure: ExecutionFailure,+ ) -> Iterable[str]:+ if (+ isinstance(raw_error, ResponsesStreamFailure)+ and raw_error.event_type == "response.failed"+ and raw_error.payload is not None+ ):+ return (self._relay.feed(raw_error.event_type, raw_error.payload),)+ return (self._relay.synthesize_failure(failure),)+++@dataclass(slots=True)+class ResponsesExecutionOutcome:+ """Provider outcome retained when terminal failure is consumed on-wire."""++ failure: Exception | None = None+++type ResponsesPresenterFactory = Callable[[], ResponsesStreamPresenter]diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex ba5aaa80..2cefdc68 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -7,20 +7,24 @@ from collections.abc import AsyncIteratorfrom typing import castfrom openai import AsyncOpenAI, AsyncStream-from openai.types.responses import ResponseStreamEvent+from openai.types.responses import ResponseInputParam, ResponseStreamEventfrom openai.types.responses.response_create_params import ResponseCreateParamsStreamingfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.diagnostics import extract_upstream_error_detailfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,ResponsesConversionError,ResponsesProviderStream,ResponsesStreamFailure,+ build_native_responses_request,build_responses_provider_request,+ responses_stream_failure_from_event,)+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.core.trace import trace_eventfrom free_claude_code.providers.admission import (@@ -39,6 +43,13 @@ from free_claude_code.providers.stream_recovery import (RecoveryFailureAction,)+from .presentation import (+ MessagesResponsesPresenter,+ NativeResponsesPresenter,+ ResponsesExecutionOutcome,+ ResponsesPresenterFactory,+)+class _TruncatedResponsesStream(RetryableProviderProtocolError):"""A Responses stream ended without a terminal lifecycle event."""@@ -78,15 +89,15 @@ class OpenAIResponsesTransport:self._read_timeout_s = read_timeout_sself._log_raw_sse_events = log_raw_sse_events- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,reasoning: ReasoningPolicy,) -> None:- self._build_body(request, reasoning=reasoning)+ self._build_messages_body(request, reasoning=reasoning)- def stream_response(+ def stream_messages(self,request: MessagesRequest,*,@@ -95,47 +106,102 @@ class OpenAIResponsesTransport:response_model: str,reasoning: ReasoningPolicy,) -> AsyncIterator[str]:- body = self._build_body(request, reasoning=reasoning)+ body = self._build_messages_body(request, reasoning=reasoning)tool_names = OpenAIToolNameCodec.from_request(request)+ message_id = f"msg_{uuid.uuid4()}"return self._run_stream(body,- input_tokens=input_tokens,request_id=request_id,response_model=response_model,- tool_names=tool_names,+ presenter_factory=lambda: MessagesResponsesPresenter(+ ResponsesProviderStream(+ message_id=message_id,+ model=response_model,+ input_tokens=input_tokens,+ tool_names=tool_names,+ log_raw_events=self._log_raw_sse_events,+ )+ ),+ )++ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ self._build_native_body(request, reasoning=reasoning)++ def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str | None,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ del input_tokens+ body = self._build_native_body(request, reasoning=reasoning)+ return self._run_stream(+ body,+ request_id=request_id,+ response_model=response_model,+ presenter_factory=lambda: NativeResponsesPresenter(+ public_model=response_model+ ),)@staticmethod- def _build_body(+ def _build_messages_body(request: MessagesRequest,*,reasoning: ReasoningPolicy,- ) -> ResponseCreateParamsStreaming:+ ) -> JsonObject:try:return cast(- ResponseCreateParamsStreaming,- build_responses_provider_request(request, reasoning=reasoning),+ JsonObject,+ cast(+ ResponseCreateParamsStreaming,+ build_responses_provider_request(request, reasoning=reasoning),+ ),)except ResponsesConversionError as exc:raise InvalidRequestError(str(exc)) from exc+ @staticmethod+ def _build_native_body(+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> JsonObject:+ if not request.model.strip():+ raise InvalidRequestError("Responses request model must not be empty.")+ if request.input is None or request.input == "" or request.input == []:+ raise InvalidRequestError("Responses request input must not be empty.")+ return build_native_responses_request(+ request,+ model=request.model,+ reasoning=reasoning,+ )+async def _run_stream(self,- body: ResponseCreateParamsStreaming,+ body: JsonObject,*,- input_tokens: int,request_id: str | None,response_model: str,- tool_names: OpenAIToolNameCodec,+ presenter_factory: ResponsesPresenterFactory,) -> AsyncIterator[str]:execution = self._admission.start_execution(request_id=request_id)+ outcome = ResponsesExecutionOutcome()provider_stream = self._run_execution(body,- input_tokens=input_tokens,request_id=request_id,response_model=response_model,- tool_names=tool_names,+ presenter_factory=presenter_factory,execution=execution,+ outcome=outcome,)try:async for event in provider_stream:@@ -146,23 +212,25 @@ class OpenAIResponsesTransport:execution.fail(error)raiseelse:- execution.succeed()+ if outcome.failure is None:+ execution.succeed()+ else:+ execution.fail(outcome.failure)finally:await maybe_await_aclose(provider_stream)execution.abandon()async def _run_execution(self,- body: ResponseCreateParamsStreaming,+ body: JsonObject,*,- input_tokens: int,request_id: str | None,response_model: str,- tool_names: OpenAIToolNameCodec,+ presenter_factory: ResponsesPresenterFactory,execution: ProviderExecution,+ outcome: ResponsesExecutionOutcome,) -> AsyncIterator[str]:recovery = RecoveryController()- message_id = f"msg_{uuid.uuid4()}"trace_event(stage="provider",event="provider.request.sent",@@ -176,16 +244,9 @@ class OpenAIResponsesTransport:)while execution.can_attempt:- stream_adapter = ResponsesProviderStream(- message_id=message_id,- model=response_model,- input_tokens=input_tokens,- tool_names=tool_names,- log_raw_events=self._log_raw_sse_events,- )- for event in stream_adapter.start():- for held in recovery.push(event):- yield held+ presenter = presenter_factory()+ start_events = tuple(presenter.start())+ presenter_started = Falsescope: ProviderAttemptScope | None = Nonestream_opened = False@@ -196,20 +257,37 @@ class OpenAIResponsesTransport:provider_name=self._provider_name,request_id=request_id,)- sdk_stream = await self._client.responses.create(**body)+ sdk_stream = await self._create_sdk_stream(body)stream = scope.retain(_ClosableResponsesStream(sdk_stream))stream_opened = Trueasync for upstream_event in stream:if not scope.attempt.accepted:await scope.attempt.accept()- for event in stream_adapter.feed(- upstream_event.type,+ if not presenter_started:+ presenter_started = True+ for event in start_events:+ for held in recovery.push(event):+ yield held+ payload = cast(+ JsonObject,upstream_event.to_dict(mode="json"),- ):+ )+ if upstream_event.type in {+ "response.failed",+ "error",+ "response.error",+ }:+ raise responses_stream_failure_from_event(+ upstream_event.type,+ payload,+ )+ for event in presenter.feed(upstream_event.type, payload):for held in recovery.push(event):yield held- if not stream_adapter.completed:+ if presenter.completed:+ break+ if not presenter.completed:raise _TruncatedResponsesStream("Provider Responses stream ended without a terminal event.")@@ -282,8 +360,11 @@ class OpenAIResponsesTransport:if not decision.committed:recovery.discard()raise failure from raw_error- for event in stream_adapter.ledger.close_unclosed_blocks():+ for event in presenter.terminal_failure(raw_error, failure):yield event+ if presenter.terminal_failure_completes_wire:+ outcome.failure = failure+ returnraise failure from raw_errorfinally:if scope is not None:@@ -293,6 +374,27 @@ class OpenAIResponsesTransport:raise execution.last_failureraise RuntimeError("Responses execution ended without a terminal result.")+ async def _create_sdk_stream(+ self,+ body: JsonObject,+ ) -> AsyncStream[ResponseStreamEvent]:+ model = body.get("model")+ if not isinstance(model, str) or not model:+ raise InvalidRequestError("Responses request model must not be empty.")+ input_value = cast(str | ResponseInputParam, body.get("input"))+ extra_body = {+ key: value+ for key, value in body.items()+ if key not in {"model", "input", "stream", "store"}+ }+ return await self._client.responses.create(+ model=model,+ input=input_value,+ stream=True,+ store=False,+ extra_body=extra_body or None,+ )+def _effective_error(error: Exception) -> Exception:if not isinstance(error, ResponsesStreamFailure):diff --git a/src/free_claude_code/providers/opencode/provider.py b/src/free_claude_code/providers/opencode/provider.pyindex 9e6e9bd6..e263bb61 100644--- a/src/free_claude_code/providers/opencode/provider.py+++ b/src/free_claude_code/providers/opencode/provider.py@@ -10,6 +10,7 @@ from free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -119,7 +120,7 @@ class OpenCodeProvider(OpenAIChatProvider):snapshot = await self._catalog.refresh()return snapshot.model_infos- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -130,13 +131,30 @@ class OpenCodeProvider(OpenAIChatProvider):if snapshot is None:returnroute = self._require_route(snapshot, request.model)- routed = _routed_request(request, route)+ routed = _routed_messages_request(request, route)if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_stream(routed, reasoning=reasoning)+ self._responses.preflight_messages(routed, reasoning=reasoning)return- super().preflight_stream(routed, reasoning=reasoning)+ super().preflight_messages(routed, reasoning=reasoning)- def stream_response(+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ """Validate native Responses ingress against a warm catalog route."""+ snapshot = self._catalog.current_snapshot+ if snapshot is None:+ return+ route = self._require_route(snapshot, request.model)+ routed = _routed_responses_request(request, route)+ if route.transport is OpenCodeUpstreamTransport.RESPONSES:+ self._responses.preflight_responses(routed, reasoning=reasoning)+ return+ super().preflight_responses(routed, reasoning=reasoning)++ def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -164,12 +182,72 @@ class OpenCodeProvider(OpenAIChatProvider):) -> AsyncIterator[str]:snapshot = await self._catalog.snapshot(request_id=request_id)route = self._require_route(snapshot, request.model)- routed = _routed_request(request, route)+ routed = _routed_messages_request(request, route)+ selected_stream: AsyncIterator[str] | None = None+ try:+ if route.transport is OpenCodeUpstreamTransport.RESPONSES:+ self._responses.preflight_messages(routed, reasoning=reasoning)+ selected_stream = self._responses.stream_messages(+ routed,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=reasoning,+ )+ else:+ super().preflight_messages(routed, reasoning=reasoning)+ selected_stream = super().stream_messages(+ routed,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=reasoning,+ )+ async for event in selected_stream:+ yield event+ finally:+ if selected_stream is not None:+ await close_provider_stream(+ selected_stream,+ active_error=sys.exception(),+ provider_name=self._opencode_profile.provider_name,+ request_id=request_id,+ )++ def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> AsyncIterator[str]:+ return self._dispatch_responses_stream(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model or request.model,+ reasoning=reasoning,+ )++ async def _dispatch_responses_stream(+ self,+ request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str | None,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ snapshot = await self._catalog.snapshot(request_id=request_id)+ route = self._require_route(snapshot, request.model)+ routed = _routed_responses_request(request, route)selected_stream: AsyncIterator[str] | None = Nonetry:if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_stream(routed, reasoning=reasoning)- selected_stream = self._responses.stream_response(+ self._responses.preflight_responses(routed, reasoning=reasoning)+ selected_stream = self._responses.stream_responses(routed,input_tokens=input_tokens,request_id=request_id,@@ -177,8 +255,8 @@ class OpenCodeProvider(OpenAIChatProvider):reasoning=reasoning,)else:- super().preflight_stream(routed, reasoning=reasoning)- selected_stream = super().stream_response(+ super().preflight_responses(routed, reasoning=reasoning)+ selected_stream = super().stream_responses(routed,input_tokens=input_tokens,request_id=request_id,@@ -229,7 +307,7 @@ def create_opencode_provider()-def _routed_request(+def _routed_messages_request(request: MessagesRequest,route: OpenCodeModelRoute,) -> MessagesRequest:@@ -237,3 +315,13 @@ def _routed_request(update={"model": route.upstream_model_id},deep=True,)+++def _routed_responses_request(+ request: OpenAIResponsesRequest,+ route: OpenCodeModelRoute,+) -> OpenAIResponsesRequest:+ return request.model_copy(+ update={"model": route.upstream_model_id},+ deep=True,+ )diff --git a/tests/api/model_fallback_support.py b/tests/api/model_fallback_support.pyindex ce7a4336..258f4d66 100644--- a/tests/api/model_fallback_support.py+++ b/tests/api/model_fallback_support.py@@ -1,5 +1,6 @@"""Controlled provider boundary for model-fallback API and product tests."""+import jsonfrom collections.abc import AsyncIterator, Iteratorfrom contextlib import contextmanagerfrom unittest.mock import patch@@ -11,6 +12,8 @@ from free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom tests.api.support import create_test_app@@ -74,17 +77,123 @@ def text_stream(text: str, *, model: str) -> list[str]:]+def responses_created_event(*, model: str) -> str:+ return _responses_event(+ "response.created",+ {+ "type": "response.created",+ "sequence_number": 0,+ "response": _responses_payload(+ model=model,+ status="in_progress",+ ),+ },+ )+++def responses_text_stream(text: str, *, model: str) -> list[str]:+ output: JsonObject = {+ "id": "msg_fallback",+ "type": "message",+ "status": "completed",+ "role": "assistant",+ "content": [+ {+ "type": "output_text",+ "text": text,+ "annotations": [],+ "logprobs": [],+ }+ ],+ }+ return [+ responses_created_event(model=model),+ _responses_event(+ "response.output_text.delta",+ {+ "type": "response.output_text.delta",+ "sequence_number": 1,+ "item_id": "msg_fallback",+ "output_index": 0,+ "content_index": 0,+ "delta": text,+ "logprobs": [],+ },+ ),+ _responses_event(+ "response.completed",+ {+ "type": "response.completed",+ "sequence_number": 2,+ "response": _responses_payload(+ model=model,+ status="completed",+ output=[output],+ ),+ },+ ),+ ]+++def responses_failure_event(+ failure: ExecutionFailure,+ *,+ model: str,+) -> str:+ return _responses_event(+ "response.failed",+ {+ "type": "response.failed",+ "sequence_number": 1,+ "response": _responses_payload(+ model=model,+ status="failed",+ error={+ "message": failure.message,+ "type": "api_error",+ "param": None,+ "code": None,+ },+ ),+ },+ )+++def _responses_event(event_type: str, payload: JsonObject) -> str:+ return f"event: {event_type}\ndata: {json.dumps(payload)}\n\n"+++def _responses_payload(+ *,+ model: str,+ status: str,+ output: list[JsonObject] | None = None,+ error: JsonObject | None = None,+) -> JsonObject:+ return {+ "id": "resp_fallback",+ "object": "response",+ "model": model,+ "status": status,+ "output": output or [],+ "error": error,+ "usage": None,+ }++class ControlledFallbackProvider:def __init__(self,*,failure: ExecutionFailure | None = None,chunks_before_failure: tuple[str, ...] = (),+ responses_chunks_before_failure: tuple[str, ...] = (),text: str | None = None,preflight_error: InvalidRequestError | None = None,) -> None:self._failure = failureself._chunks_before_failure = chunks_before_failure+ self._responses_chunks_before_failure = responses_chunks_before_failureself._text = textself._preflight_error = preflight_errorself.preflight_models: list[str] = []@@ -92,7 +201,7 @@ class ControlledFallbackProvider:self.response_models: list[str] = []self.close_calls = 0- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -103,7 +212,7 @@ class ControlledFallbackProvider:if self._preflight_error is not None:raise self._preflight_error- async def stream_response(+ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -127,6 +236,44 @@ class ControlledFallbackProvider:finally:self.close_calls += 1+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ del reasoning+ self.preflight_models.append(request.model)+ if self._preflight_error is not None:+ raise self._preflight_error++ async def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ del input_tokens, request_id, reasoning+ self.stream_models.append(request.model)+ public_model = response_model or request.model+ self.response_models.append(public_model)+ try:+ for chunk in self._responses_chunks_before_failure:+ yield chunk+ if self._failure is not None:+ if self._responses_chunks_before_failure:+ yield responses_failure_event(self._failure, model=public_model)+ return+ raise self._failure+ assert self._text is not None+ for chunk in responses_text_stream(self._text, model=public_model):+ yield chunk+ finally:+ self.close_calls += 1+@contextmanagerdef fallback_client(diff --git a/tests/api/test_api.py b/tests/api/test_api.pyindex 7bbb8f8e..7b26fd25 100644--- a/tests/api/test_api.py+++ b/tests/api/test_api.py@@ -13,20 +13,20 @@ app = create_test_app()# Mock providermock_provider = MagicMock(spec=NvidiaNimProvider)-# Track stream_response calls for test_model_mapping-_stream_response_calls: list = []+# Track stream_messages calls for test_model_mapping+_stream_messages_calls: list = []-async def _mock_stream_response(*args, **kwargs):+async def _mock_stream_messages(*args, **kwargs):"""Minimal async generator for streaming tests."""- _stream_response_calls.append((args, kwargs))+ _stream_messages_calls.append((args, kwargs))yield "event: message_start\ndata: {}\n\n"yield "[DONE]\n\n"async def _mock_pre_start_rate_limit(*args, **kwargs):"""Provider stream that fails before any downstream-visible SSE chunk."""- _stream_response_calls.append((args, kwargs))+ _stream_messages_calls.append((args, kwargs))raise ExecutionFailure(kind=FailureKind.RATE_LIMIT,status_code=429,@@ -38,7 +38,7 @@ async def _mock_pre_start_rate_limit(*args, **kwargs):async def _mock_empty_stream(*args, **kwargs):"""Provider stream that completes without a protocol frame."""- _stream_response_calls.append((args, kwargs))+ _stream_messages_calls.append((args, kwargs))if False:yield "unreachable"@@ -53,7 +53,7 @@ def _terminal_json_error(response, *, status_code: int):return payload["error"]-mock_provider.stream_response = _mock_stream_response+mock_provider.stream_messages = _mock_stream_messages@pytest.fixture(scope="module")@@ -114,7 +114,7 @@ def test_probe_endpoints_return_204_with_allow_headers(client: TestClient):def test_create_message_stream(client: TestClient):"""Create message returns streaming response."""- _stream_response_calls.clear()+ _stream_messages_calls.clear()payload = {"model": "claude-3-sonnet","messages": [{"role": "user", "content": "Hi"}],@@ -126,12 +126,12 @@ def test_create_message_stream(client: TestClient):assert "text/event-stream" in response.headers.get("content-type", "")content = b"".join(response.iter_bytes())assert b"message_start" in content or b"event:" in content- assert _stream_response_calls[0][1]["request_id"] == response.headers["request-id"]+ assert _stream_messages_calls[0][1]["request_id"] == response.headers["request-id"]def test_auto_mode_classifier_without_stream_returns_json(client: TestClient):"""Claude side queries omit stream and require one complete Message object."""- _stream_response_calls.clear()+ _stream_messages_calls.clear()payload = {"model": "claude-opus-4-8","max_tokens": 64,@@ -154,9 +154,9 @@ def test_auto_mode_classifier_without_stream_returns_json(client: TestClient):body = response.json()assert body["type"] == "message"assert body["usage"] == {"input_tokens": 0, "output_tokens": 0}- routed_request = _stream_response_calls[0][0][0]+ routed_request = _stream_messages_calls[0][0][0]assert routed_request.stream is False- assert _stream_response_calls[0][1]["reasoning"] == ReasoningPolicy.off()+ assert _stream_messages_calls[0][1]["reasoning"] == ReasoningPolicy.off()def test_create_message_ingress_error_has_request_id_without_terminal_header(@@ -189,8 +189,8 @@ def test_create_message_pre_start_provider_error_returns_terminal_json(client: TestClient,):"""Pre-start provider failures keep status without enabling client retries."""- mock_provider.stream_response = _mock_pre_start_rate_limit- _stream_response_calls.clear()+ mock_provider.stream_messages = _mock_pre_start_rate_limit+ _stream_messages_calls.clear()payload = {"model": "claude-3-sonnet","messages": [{"role": "user", "content": "Hi"}],@@ -207,7 +207,7 @@ def test_create_message_pre_start_provider_error_returns_terminal_json(error = _terminal_json_error(response, status_code=429)assert error == {"type": "rate_limit_error", "message": "upstream is busy"}request_id = response.headers["request-id"]- assert _stream_response_calls[0][1]["request_id"] == request_id+ assert _stream_messages_calls[0][1]["request_id"] == request_idroute_trace = next(call.kwargsfor call in execution_trace.call_args_list@@ -233,13 +233,13 @@ def test_create_message_pre_start_provider_error_returns_terminal_json("failure_kind": "rate_limit","provider_retryable": True,}- mock_provider.stream_response = _mock_stream_response+ mock_provider.stream_messages = _mock_stream_messagesdef test_create_message_preserves_system_role_messages(client: TestClient):"""Create message preserves latest-client system message placement."""- mock_provider.stream_response = _mock_stream_response- _stream_response_calls.clear()+ mock_provider.stream_messages = _mock_stream_messages+ _stream_messages_calls.clear()payload = {"model": "claude-3-sonnet","messages": [@@ -254,7 +254,7 @@ def test_create_message_preserves_system_role_messages(client: TestClient):response = client.post("/v1/messages", json=payload)assert response.status_code == 200- routed_request = _stream_response_calls[0][0][0]+ routed_request = _stream_messages_calls[0][0][0]assert [message.role for message in routed_request.messages] == ["user","system",@@ -266,7 +266,7 @@ def test_create_message_preserves_system_role_messages(client: TestClient):def test_model_mapping(client: TestClient):# Test Haiku mapping- _stream_response_calls.clear()+ _stream_messages_calls.clear()payload_haiku = {"model": "claude-3-haiku-20240307","messages": [{"role": "user", "content": "Hi"}],@@ -274,9 +274,9 @@ def test_model_mapping(client: TestClient):"stream": True,}client.post("/v1/messages", json=payload_haiku)- assert len(_stream_response_calls) == 1- args = _stream_response_calls[0][0]- kwargs = _stream_response_calls[0][1]+ assert len(_stream_messages_calls) == 1+ args = _stream_messages_calls[0][0]+ kwargs = _stream_messages_calls[0][1]assert args[0].model != "claude-3-haiku-20240307"assert kwargs["reasoning"] == ReasoningPolicy.provider_default()@@ -335,7 +335,7 @@ def test_provider_execution_errors_preserve_status_and_type(raise failuretry:- mock_provider.stream_response = _raise_provider_error+ mock_provider.stream_messages = _raise_provider_errorresponse = client.post("/v1/messages", json=base_payload)error = _terminal_json_error(response, status_code=failure.status_code)assert error["type"] == expected_type@@ -343,11 +343,11 @@ def test_provider_execution_errors_preserve_status_and_type(if expected_type == "invalid_request_error":assert "useful detail" in error["message"]finally:- mock_provider.stream_response = _mock_stream_response+ mock_provider.stream_messages = _mock_stream_messagesdef test_empty_provider_stream_returns_terminal_json(client: TestClient):- mock_provider.stream_response = _mock_empty_stream+ mock_provider.stream_messages = _mock_empty_streamtry:response = client.post("/v1/messages",@@ -362,7 +362,7 @@ def test_empty_provider_stream_returns_terminal_json(client: TestClient):assert error["type"] == "api_error"assert error["message"] == "Stream ended before emitting a response."finally:- mock_provider.stream_response = _mock_stream_response+ mock_provider.stream_messages = _mock_stream_messagesdef test_generic_stream_exception_returns_terminal_json(client: TestClient):@@ -371,7 +371,7 @@ def test_generic_stream_exception_returns_terminal_json(client: TestClient):def _raise_runtime(*args, **kwargs):raise RuntimeError("unexpected crash")- mock_provider.stream_response = _raise_runtime+ mock_provider.stream_messages = _raise_runtimeresponse = client.post("/v1/messages",json={@@ -384,7 +384,7 @@ def test_generic_stream_exception_returns_terminal_json(client: TestClient):error = _terminal_json_error(response, status_code=500)assert error["type"] == "api_error"assert error["message"] == "unexpected crash"- mock_provider.stream_response = _mock_stream_response+ mock_provider.stream_messages = _mock_stream_messagesdef test_generic_stream_exception_with_status_code_returns_terminal_json(@@ -400,7 +400,7 @@ def test_generic_stream_exception_with_status_code_returns_terminal_json(def _raise_with_status(*args, **kwargs):raise ExceptionWithStatus("bad gateway", 502)- mock_provider.stream_response = _raise_with_status+ mock_provider.stream_messages = _raise_with_statusresponse = client.post("/v1/messages",json={@@ -413,7 +413,7 @@ def test_generic_stream_exception_with_status_code_returns_terminal_json(error = _terminal_json_error(response, status_code=500)assert error["type"] == "api_error"assert error["message"] == "bad gateway"- mock_provider.stream_response = _mock_stream_response+ mock_provider.stream_messages = _mock_stream_messagesdef test_generic_stream_exception_empty_message_returns_non_empty_error(@@ -428,7 +428,7 @@ def test_generic_stream_exception_empty_message_returns_non_empty_error(def _raise_silent(*args, **kwargs):raise SilentError()- mock_provider.stream_response = _raise_silent+ mock_provider.stream_messages = _raise_silentresponse = client.post("/v1/messages",json={@@ -441,7 +441,7 @@ def test_generic_stream_exception_empty_message_returns_non_empty_error(error = _terminal_json_error(response, status_code=500)assert error["type"] == "api_error"assert error["message"] != ""- mock_provider.stream_response = _mock_stream_response+ mock_provider.stream_messages = _mock_stream_messagesdef test_count_tokens_endpoint(client: TestClient):diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.pyindex 6caea988..4c3ccebc 100644--- a/tests/api/test_api_handlers.py+++ b/tests/api/test_api_handlers.py@@ -40,25 +40,34 @@ _CLASSIFIER_USER = (class FakeProvider:def __init__(self, events: list[str] | None = None) -> None:self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []+ self.responses_preflight_calls: list[+ tuple[OpenAIResponsesRequest, ReasoningPolicy]+ ] = []self.requests: list[MessagesRequest] = []+ self.responses_requests: list[OpenAIResponsesRequest] = []self.stream_kwargs: list[dict[str, Any]] = []self.events = events or ['event: message_start\ndata: {"type":"message_start"}\n\n','event: message_stop\ndata: {"type":"message_stop"}\n\n',]- def preflight_stream(+ def preflight_messages(self, request: MessagesRequest, *, reasoning: ReasoningPolicy) -> None:self.preflight_calls.append((request, reasoning))+ def preflight_responses(+ self, request: OpenAIResponsesRequest, *, reasoning: ReasoningPolicy+ ) -> None:+ self.responses_preflight_calls.append((request, reasoning))+async def cleanup(self) -> None:return Noneasync def list_model_infos(self) -> frozenset[ProviderModelInfo]:return frozenset({ProviderModelInfo("test-model")})- async def stream_response(+ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -79,6 +88,26 @@ class FakeProvider:for event in self.events:yield event+ async def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ self.responses_requests.append(request)+ self.stream_kwargs.append(+ {+ "input_tokens": input_tokens,+ "request_id": request_id,+ "response_model": response_model,+ "reasoning": reasoning,+ }+ )+ yield 'event: response.completed\ndata: {"type":"response.completed"}\n\n'+async def _streaming_body_text(response: StreamingResponse) -> str:parts: list[str] = []@@ -134,7 +163,7 @@ async def test_messages_handler_preflight_invalid_request_stays_http_error(stream: bool,) -> None:class RejectPreflightProvider(FakeProvider):- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -339,7 +368,7 @@ async def test_messages_handler_discards_partial_stream_false_output_on_error()@pytest.mark.asyncioasync def test_messages_handler_stream_false_provider_exception_keeps_status() -> None:class FailingProvider(FakeProvider):- async def stream_response(+ async def stream_messages(self,request: Any,input_tokens: int = 0,@@ -616,7 +645,7 @@ async def test_responses_handler_bypasses_message_only_optimizations() -> None:assert isinstance(response, StreamingResponse)body = await _streaming_body_text(response)assert "response.completed" in body- assert provider.requests[0].messages[0].content == "quota check"+ assert provider.responses_requests[0].input == "quota check"@pytest.mark.asyncio@@ -636,7 +665,9 @@ async def test_responses_handler_does_not_apply_safety_classifier_policy() -> Noassert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.provider_default()+ assert (+ provider.responses_preflight_calls[0][1] == ReasoningPolicy.provider_default()+ )assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()assert (_trace_events(diff --git a/tests/api/test_execution_failure_contract.py b/tests/api/test_execution_failure_contract.pyindex 7a05200e..9a04fe5e 100644--- a/tests/api/test_execution_failure_contract.py+++ b/tests/api/test_execution_failure_contract.py@@ -1,8 +1,9 @@"""Public commit-boundary behavior for canonical execution failures."""import asyncio+import jsonfrom collections.abc import AsyncIterator-from typing import Any+from typing import Any, castfrom unittest.mock import MagicMock, patchimport pytest@@ -13,6 +14,11 @@ from free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ openai_error_from_failure,+)from free_claude_code.core.reasoning import ReasoningPolicyfrom tests.api.support import create_test_app@@ -38,10 +44,11 @@ class CanonicalFailureProvider:self._message = messageself._retryable = retryableself._grouped = grouped- self.preflight_stream = MagicMock()+ self.preflight_messages = MagicMock()+ self.preflight_responses = MagicMock()self.stream_kwargs: list[dict[str, Any]] = []- async def stream_response(+ async def stream_messages(self,_request: object,**kwargs: Any,@@ -49,31 +56,52 @@ class CanonicalFailureProvider:self.stream_kwargs.append(kwargs)for chunk in self._chunks:yield chunk- request_id = kwargs["request_id"]- failure = ExecutionFailure(+ failure = self._failure(str(kwargs["request_id"]))+ if self._grouped:+ raise self._grouped_failure(failure)+ raise failure++ async def stream_responses(+ self,+ _request: OpenAIResponsesRequest,+ **kwargs: Any,+ ) -> AsyncIterator[str]:+ self.stream_kwargs.append(kwargs)+ failure = self._failure(str(kwargs["request_id"]))+ if not self._chunks:+ if self._grouped:+ raise self._grouped_failure(failure)+ raise failure+ for chunk in _partial_responses_stream(failure):+ yield chunk++ def _failure(self, request_id: str) -> ExecutionFailure:+ return ExecutionFailure(kind=self._kind,status_code=self._status_code,message=f"{self._message}\n\nRequest ID: {request_id}",retryable=self._retryable,)- if self._grouped:- raise ExceptionGroup(- "provider stream and cleanup failed",- [- RuntimeError("cleanup failed"),- ExceptionGroup("provider request failed", [failure]),- ],- )- raise failure++ @staticmethod+ def _grouped_failure(failure: ExecutionFailure) -> ExceptionGroup:+ return ExceptionGroup(+ "provider stream and cleanup failed",+ [+ RuntimeError("cleanup failed"),+ ExceptionGroup("provider request failed", [failure]),+ ],+ )class StalledProvider:"""Provider double that makes no protocol-visible progress."""- def __init__(self) -> None:+ def __init__(self, *, responses_chunks: tuple[str, ...] = ()) -> None:+ self._responses_chunks = responses_chunksself.close_calls = 0- def preflight_stream(+ def preflight_messages(self,_request: MessagesRequest,*,@@ -81,7 +109,15 @@ class StalledProvider:) -> None:del reasoning- async def stream_response(+ def preflight_responses(+ self,+ _request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ del reasoning++ async def stream_messages(self,_request: MessagesRequest,*,@@ -97,6 +133,24 @@ class StalledProvider:finally:self.close_calls += 1+ async def stream_responses(+ self,+ _request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ del input_tokens, request_id, response_model, reasoning+ try:+ for chunk in self._responses_chunks:+ yield chunk+ await asyncio.Event().wait()+ yield ""+ finally:+ self.close_calls += 1+def _messages_payload(*, stream: bool) -> dict[str, object]:return {@@ -145,6 +199,80 @@ def _partial_anthropic_stream(*, close_block: bool) -> list[str]:return chunks+def _partial_responses_stream(failure: ExecutionFailure) -> list[str]:+ response_id = "resp_failure_contract"+ message: JsonObject = {+ "id": "msg_failure_contract",+ "type": "message",+ "status": "completed",+ "role": "assistant",+ "content": [+ {+ "type": "output_text",+ "text": _PARTIAL_CONTENT,+ "annotations": [],+ "logprobs": [],+ }+ ],+ }+ created = _responses_event(+ "response.created",+ {+ "type": "response.created",+ "sequence_number": 0,+ "response": _responses_wire_payload(+ response_id=response_id,+ status="in_progress",+ ),+ },+ )+ item_done = _responses_event(+ "response.output_item.done",+ {+ "type": "response.output_item.done",+ "sequence_number": 1,+ "output_index": 0,+ "item": message,+ },+ )+ failed = _responses_event(+ "response.failed",+ {+ "type": "response.failed",+ "sequence_number": 2,+ "response": _responses_wire_payload(+ response_id=response_id,+ status="failed",+ output=[message],+ error=cast(JsonObject, openai_error_from_failure(failure)),+ ),+ },+ )+ return [created, item_done, failed]+++def _responses_event(event_type: str, payload: JsonObject) -> str:+ return f"event: {event_type}\ndata: {json.dumps(payload)}\n\n"+++def _responses_wire_payload(+ *,+ response_id: str,+ status: str,+ output: list[JsonObject] | None = None,+ error: JsonObject | None = None,+) -> JsonObject:+ return {+ "id": response_id,+ "object": "response",+ "model": "nvidia_nim/test-model",+ "status": status,+ "output": output or [],+ "error": error,+ "usage": None,+ }++def _client_for(provider: CanonicalFailureProvider | StalledProvider,*,@@ -280,7 +408,10 @@ def test_grouped_post_start_execution_failure_keeps_canonical_terminal_event(assert response.status_code == 200assert error["type"] == "rate_limit_error"assert error["message"] == f"upstream is busy\n\nRequest ID: {request_id}"- assert _terminal_trace(trace_mock)["failure_kind"] == "rate_limit"+ if path == "/v1/messages":+ assert _terminal_trace(trace_mock)["failure_kind"] == "rate_limit"+ else:+ trace_mock.assert_not_called()def test_grouped_stream_false_execution_failure_discards_partial_content() -> None:@@ -540,19 +671,7 @@ def test_responses_post_start_execution_failure_retains_id_after_block_close() -"param": None,"code": None,}- assert _terminal_trace(trace_mock) == {- "stage": "egress",- "event": "free_claude_code.api.response.terminal_execution_error",- "source": "api",- "wire_api": "responses",- "request_id": request_id,- "status_code": 429,- "error_type": "rate_limit_error",- "client_should_retry": False,- "exc_type": "ExecutionFailure",- "failure_kind": "rate_limit",- "provider_retryable": True,- }+ trace_mock.assert_not_called()def test_messages_stream_false_discards_partial_content_on_execution_failure() -> None:@@ -661,10 +780,78 @@ def test_post_start_progress_timeout_is_terminal_protocol_event(path: str) -> No"Provider execution made no progress for 600 seconds.\n\n"f"Request ID: {request_id}")- trace = _terminal_trace(trace_mock)- assert trace["failure_kind"] == "timeout"- assert trace["provider_retryable"] is False- assert trace["client_should_retry"] is False+ if path == "/v1/messages":+ trace = _terminal_trace(trace_mock)+ assert trace["failure_kind"] == "timeout"+ assert trace["provider_retryable"] is False+ assert trace["client_should_retry"] is False+ else:+ trace_mock.assert_not_called()+++def test_responses_application_progress_timeout_closes_committed_lifecycle() -> None:+ response_id = "resp_application_timeout"+ provider = StalledProvider(+ responses_chunks=(+ _responses_event(+ "response.created",+ {+ "type": "response.created",+ "sequence_number": 0,+ "response": _responses_wire_payload(+ response_id=response_id,+ status="in_progress",+ ),+ },+ ),+ )+ )+ resolver_patch, client = _client_for(+ provider,+ settings=Settings(provider_progress_timeout=0.02),+ )++ with (+ resolver_patch,+ patch("free_claude_code.api.response_streams.trace_event") as trace_mock,+ client,+ ):+ response = client.post("/v1/responses", json=_responses_payload())++ request_id = response.headers["request-id"]+ events = parse_sse_text(response.text)+ assert response.status_code == 200+ assert [event.event for event in events] == [+ "response.created",+ "response.failed",+ ]+ assert events[-1].data["sequence_number"] == 1+ failed = events[-1].data["response"]+ assert failed["id"] == response_id+ assert failed["status"] == "failed"+ assert failed["error"] == {+ "message": (+ "Provider execution made no progress for 0.02 seconds.\n\n"+ f"Request ID: {request_id}"+ ),+ "type": "timeout_error",+ "param": None,+ "code": None,+ }+ assert provider.close_calls == 1+ assert _terminal_trace(trace_mock) == {+ "stage": "egress",+ "event": "free_claude_code.api.response.terminal_execution_error",+ "source": "api",+ "wire_api": "responses",+ "request_id": request_id,+ "status_code": 504,+ "error_type": "timeout_error",+ "client_should_retry": False,+ "exc_type": "ExecutionFailure",+ "failure_kind": "timeout",+ "provider_retryable": False,+ }def test_stream_false_progress_timeout_discards_partial_content() -> None:diff --git a/tests/api/test_model_fallback.py b/tests/api/test_model_fallback.pyindex f94738ca..b93c8e7e 100644--- a/tests/api/test_model_fallback.py+++ b/tests/api/test_model_fallback.py@@ -11,6 +11,7 @@ from tests.api.model_fallback_support import (execution_failure,fallback_client,messages_payload,+ responses_created_event,responses_payload,text_stream,)@@ -175,24 +176,9 @@ def test_postframe_failure_never_opens_fallback_for_streaming_messages() -> Nonedef test_postframe_failure_never_opens_fallback_for_responses() -> None:- first = format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_primary",- "type": "message",- "role": "assistant",- "model": "nvidia_nim/primary-model",- "content": [],- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": 3, "output_tokens": 0},- },- },- )+ first = responses_created_event(model="nvidia_nim/primary-model")primary = ControlledFallbackProvider(- chunks_before_failure=(first,),+ responses_chunks_before_failure=(first,),failure=execution_failure("primary failed after start"),)fallback = ControlledFallbackProvider(text="must not run")diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.pyindex 4d10355d..4357008d 100644--- a/tests/api/test_openai_responses.py+++ b/tests/api/test_openai_responses.py@@ -1,4 +1,5 @@-from typing import Any+import json+from collections.abc import AsyncIteratorfrom unittest.mock import MagicMock, patchimport pytest@@ -6,8 +7,9 @@ from fastapi.testclient import TestClientfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.json_types import JsonObject+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,@@ -15,17 +17,25 @@ from free_claude_code.core.reasoning import ()from tests.api.support import create_test_app+_PUBLIC_MODEL = "nvidia_nim/test-model"+_UPSTREAM_MODEL = "test-model"+_RESPONSE_ID = "resp_test"+class FakeProvider:def __init__(self, chunks: list[str]) -> None:self.chunks = chunks- self.preflight_stream = MagicMock()- self.requests: list[Any] = []- self.stream_kwargs: list[dict[str, Any]] = []-- async def stream_response(self, request_data, **_kwargs):+ self.preflight_responses = MagicMock()+ self.requests: list[OpenAIResponsesRequest] = []+ self.stream_kwargs: list[dict[str, object]] = []++ async def stream_responses(+ self,+ request_data: OpenAIResponsesRequest,+ **kwargs: object,+ ) -> AsyncIterator[str]:self.requests.append(request_data)- self.stream_kwargs.append(_kwargs)+ self.stream_kwargs.append(kwargs)for chunk in self.chunks:yield chunk@@ -34,9 +44,13 @@ class PreStartFailingProvider(FakeProvider):def __init__(self) -> None:super().__init__([])- async def stream_response(self, request_data, **_kwargs):+ async def stream_responses(+ self,+ request_data: OpenAIResponsesRequest,+ **kwargs: object,+ ) -> AsyncIterator[str]:self.requests.append(request_data)- self.stream_kwargs.append(_kwargs)+ self.stream_kwargs.append(kwargs)raise ExecutionFailure(kind=FailureKind.RATE_LIMIT,status_code=429,@@ -46,21 +60,9 @@ class PreStartFailingProvider(FakeProvider):yield "unreachable"-class PostStartFailingProvider(FakeProvider):- def __init__(self) -> None:- super().__init__([format_sse_event("message_start", {"type": "message_start"})])-- async def stream_response(self, request_data, **_kwargs):- self.requests.append(request_data)- self.stream_kwargs.append(_kwargs)- for chunk in self.chunks:- yield chunk- raise RuntimeError("socket closed")--@pytest.fixturedef responses_client():- provider = FakeProvider(_anthropic_text_stream("Hello from provider"))+ provider = FakeProvider(_responses_text_stream("Hello from provider"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -78,7 +80,7 @@ def test_responses_probe_endpoints_return_204(assert client.options("/v1/responses").status_code == 204-def test_create_response_stream_routes_through_provider(+def test_create_response_stream_routes_native_request_through_provider(responses_client: tuple[TestClient, FakeProvider],) -> None:client, provider = responses_client@@ -86,7 +88,7 @@ def test_create_response_stream_routes_through_provider(response = client.post("/v1/responses",json={- "model": "nvidia_nim/test-model",+ "model": _PUBLIC_MODEL,"input": "Hello","max_output_tokens": 32,},@@ -96,24 +98,24 @@ def test_create_response_stream_routes_through_provider(assert "text/event-stream" in response.headers["content-type"]assert response.headers["x-request-id"] == response.headers["request-id"]events = parse_sse_text(response.text)- assert events[0].event == "response.created"- assert events[-1].event == "response.completed"+ assert [event.event for event in events] == [+ "response.created",+ "response.output_text.delta",+ "response.completed",+ ]assert events[-1].data["response"]["output"][0]["content"][0]["text"] == ("Hello from provider")- assert provider.preflight_stream.called+ assert provider.preflight_responses.calledrouted = provider.requests[0]- assert routed.model == "test-model"- assert routed.messages[0].role == "user"- assert routed.messages[0].content == "Hello"- assert routed.max_tokens == 32+ assert routed.model == _UPSTREAM_MODEL+ assert routed.input == "Hello"+ assert routed.max_output_tokens == 32assert provider.stream_kwargs[0]["request_id"] == response.headers["request-id"]def test_create_response_stream_preserves_output_limit_as_incomplete() -> None:- provider = FakeProvider(- _anthropic_text_stream("partial output", stop_reason="max_tokens")- )+ provider = FakeProvider(_responses_text_stream("partial output", incomplete=True))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -122,7 +124,7 @@ def test_create_response_stream_preserves_output_limit_as_incomplete() -> None:response = client.post("/v1/responses",json={- "model": "nvidia_nim/test-model",+ "model": _PUBLIC_MODEL,"input": "Keep working","max_output_tokens": 32,},@@ -139,8 +141,8 @@ def test_create_response_stream_preserves_output_limit_as_incomplete() -> None:def test_create_response_preflight_rejection_stays_an_ordinary_http_error() -> None:- provider = FakeProvider(_anthropic_text_stream("unused"))- provider.preflight_stream.side_effect = InvalidRequestError("bad tool shape")+ provider = FakeProvider(_responses_text_stream("unused"))+ provider.preflight_responses.side_effect = InvalidRequestError("bad tool shape")app = create_test_app()with (@@ -149,7 +151,7 @@ def test_create_response_preflight_rejection_stays_an_ordinary_http_error() -> N):response = client.post("/v1/responses",- json={"model": "nvidia_nim/test-model", "input": "Hello"},+ json={"model": _PUBLIC_MODEL, "input": "Hello"},)assert response.status_code == 400@@ -163,7 +165,7 @@ def test_create_response_preflight_rejection_stays_an_ordinary_http_error() -> Nassert provider.requests == []-def test_create_response_accepts_unknown_top_level_extensions(+def test_create_response_preserves_unknown_top_level_extensions(responses_client: tuple[TestClient, FakeProvider],) -> None:client, provider = responses_client@@ -171,14 +173,14 @@ def test_create_response_accepts_unknown_top_level_extensions(response = client.post("/v1/responses",json={- "model": "nvidia_nim/test-model",+ "model": _PUBLIC_MODEL,"input": "Hello","provider_extension": {"enabled": True},},)assert response.status_code == 200- assert provider.requests[0].messages[0].content == "Hello"+ assert provider.requests[0].model_dump()["provider_extension"] == {"enabled": True}def test_create_response_pre_start_provider_error_returns_openai_error() -> None:@@ -191,10 +193,7 @@ def test_create_response_pre_start_provider_error_returns_openai_error() -> None):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Hello",- },+ json={"model": _PUBLIC_MODEL, "input": "Hello"},)assert response.status_code == 429@@ -220,8 +219,21 @@ def test_create_response_pre_start_provider_error_returns_openai_error() -> Noneassert terminal_trace["provider_retryable"] is True-def test_create_response_post_start_failure_preserves_response_id() -> None:- provider = PostStartFailingProvider()+def test_create_response_relays_provider_owned_post_start_failure() -> None:+ provider = FakeProvider(+ [+ _created_event(),+ _terminal_event(+ "failed",+ error={+ "message": "socket closed",+ "type": "api_error",+ "param": None,+ "code": None,+ },+ ),+ ]+ )app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -229,10 +241,7 @@ def test_create_response_post_start_failure_preserves_response_id() -> None:):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Hello",- },+ json={"model": _PUBLIC_MODEL, "input": "Hello"},)assert response.status_code == 200@@ -244,7 +253,7 @@ def test_create_response_post_start_failure_preserves_response_id() -> None:def test_create_response_stream_bypasses_local_message_optimizations() -> None:- provider = FakeProvider(_anthropic_text_stream("Provider response"))+ provider = FakeProvider(_responses_text_stream("Provider response"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -256,16 +265,13 @@ def test_create_response_stream_bypasses_local_message_optimizations() -> None:):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "quota check",- },+ json={"model": _PUBLIC_MODEL, "input": "quota check"},)assert response.status_code == 200completed = parse_sse_text(response.text)[-1].data["response"]assert completed["output"][0]["content"][0]["text"] == "Provider response"- assert provider.requests[0].messages[0].content == "quota check"+ assert provider.requests[0].input == "quota check"def test_create_response_stream_false_returns_openai_error(@@ -275,11 +281,7 @@ def test_create_response_stream_false_returns_openai_error(response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Hello",- "stream": False,- },+ json={"model": _PUBLIC_MODEL, "input": "Hello", "stream": False},)assert response.status_code == 400@@ -289,8 +291,50 @@ def test_create_response_stream_false_returns_openai_error(assert provider.requests == []-def test_create_response_stream_preserves_interleaved_reasoning_order() -> None:- provider = FakeProvider(_anthropic_interleaved_reasoning_stream())+def test_create_response_relays_interleaved_reasoning_order() -> None:+ output: list[JsonObject] = [+ {+ "id": "rs_1",+ "type": "reasoning",+ "status": "completed",+ "summary": [],+ "content": [{"type": "reasoning_text", "text": "first thought"}],+ },+ _message_output("first answer", item_id="msg_1"),+ {+ "id": "fc_1",+ "type": "function_call",+ "status": "completed",+ "call_id": "call_1",+ "name": "echo",+ "arguments": '{"value":"FCC"}',+ },+ {+ "id": "rs_2",+ "type": "reasoning",+ "status": "completed",+ "summary": [],+ "content": [{"type": "reasoning_text", "text": "second thought"}],+ },+ _message_output("final answer", item_id="msg_2"),+ ]+ provider = FakeProvider(+ [+ _created_event(),+ _event(+ "response.reasoning_text.delta",+ {+ "type": "response.reasoning_text.delta",+ "sequence_number": 1,+ "item_id": "rs_1",+ "output_index": 0,+ "content_index": 0,+ "delta": "first thought",+ },+ ),+ _terminal_event("completed", output=output),+ ]+ )app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -298,18 +342,7 @@ def test_create_response_stream_preserves_interleaved_reasoning_order() -> None:):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Use reasoning and tools",- "stream": True,- "tools": [- {- "type": "function",- "name": "echo",- "parameters": {"type": "object", "properties": {}},- }- ],- },+ json={"model": _PUBLIC_MODEL, "input": "Use reasoning and tools"},)assert response.status_code == 200@@ -323,15 +356,20 @@ def test_create_response_stream_preserves_interleaved_reasoning_order() -> None:"reasoning","message",]- assert completed["output"][0]["content"][0]["text"] == "first thought"- assert completed["output"][1]["content"][0]["text"] == "first answer"- assert completed["output"][2]["arguments"] == '{"value":"FCC"}'- assert completed["output"][3]["content"][0]["text"] == "second thought"- assert completed["output"][4]["content"][0]["text"] == "final answer"-def test_create_response_tool_stream_emits_function_call() -> None:- provider = FakeProvider(_anthropic_tool_stream())+def test_create_response_relays_function_call() -> None:+ call: JsonObject = {+ "id": "fc_1",+ "type": "function_call",+ "status": "completed",+ "call_id": "toolu_1",+ "name": "echo",+ "arguments": '{"value":"FCC"}',+ }+ provider = FakeProvider(+ [_created_event(), _terminal_event("completed", output=[call])]+ )app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -340,9 +378,8 @@ def test_create_response_tool_stream_emits_function_call() -> None:response = client.post("/v1/responses",json={- "model": "nvidia_nim/test-model",+ "model": _PUBLIC_MODEL,"input": "Use echo",- "stream": True,"tools": [{"type": "function",@@ -354,18 +391,30 @@ def test_create_response_tool_stream_emits_function_call() -> None:)assert response.status_code == 200- events = parse_sse_text(response.text)- completed = events[-1].data["response"]- call = completed["output"][0]- assert call["type"] == "function_call"- assert call["call_id"] == "toolu_1"- assert call["arguments"] == '{"value":"FCC"}'+ completed_call = parse_sse_text(response.text)[-1].data["response"]["output"][0]+ assert completed_call == call-def test_create_response_malformed_provider_function_call_fails_stream() -> None:- provider = FakeProvider(- _anthropic_tool_stream(partial_json='{"value":"FCC" "bad"}')- )+def test_create_response_preserves_namespace_and_passive_tools() -> None:+ tools: list[JsonObject] = [+ {"type": "web_search", "external_web_access": True},+ {"type": "image_generation", "output_format": "png"},+ {+ "type": "namespace",+ "name": "mcp__node_repl",+ "tools": [+ {+ "type": "function",+ "name": "js",+ "parameters": {+ "type": "object",+ "properties": {"code": {"type": "string"}},+ },+ }+ ],+ },+ ]+ provider = FakeProvider(_responses_text_stream("done"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -373,136 +422,76 @@ def test_create_response_malformed_provider_function_call_fails_stream() -> None):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Use echo",- "stream": True,- "tools": [- {- "type": "function",- "name": "echo",- "parameters": {"type": "object", "properties": {}},- }- ],- },+ json={"model": _PUBLIC_MODEL, "input": "Use JS", "tools": tools},)assert response.status_code == 200- events = parse_sse_text(response.text)- assert events[-1].event == "response.failed"- failed = events[-1].data["response"]- assert failed["status"] == "failed"- assert failed["output"] == []- assert "replay-unsafe Responses output" in failed["error"]["message"]---def test_create_response_accepts_codex_namespace_tool_request() -> None:- provider = FakeProvider(_anthropic_tool_stream(tool_name="mcp__node_repl__js"))- app = create_test_app()- with (- patch("free_claude_code.api.routes.resolve_provider", return_value=provider),- TestClient(app) as client,- ):- response = client.post(- "/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Use JS",- "stream": True,+ assert provider.requests[0].tools == tools+++def test_create_response_preserves_muse_code_request_shape() -> None:+ request = {+ "model": _PUBLIC_MODEL,+ "input": "Read the file",+ "instructions": "Be concise.",+ "max_output_tokens": 64,+ "store": False,+ "stream": True,+ "reasoning": {"effort": "high", "summary": "auto"},+ "include": ["reasoning.encrypted_content"],+ "prompt_cache_key": "muse-session-1",+ "tools": [+ {+ "type": "namespace",+ "name": "muse","tools": [- {"type": "web_search", "external_web_access": True},- {"type": "image_generation", "output_format": "png"},{- "type": "namespace",- "name": "mcp__node_repl",- "tools": [- {- "type": "function",- "name": "js",- "parameters": {- "type": "object",- "properties": {"code": {"type": "string"}},- },- }- ],- },+ "type": "function",+ "name": "read_file",+ "description": "Read one file.",+ "strict": True,+ "parameters": {+ "type": "object",+ "properties": {"path": {"type": "string"}},+ "required": ["path"],+ "additionalProperties": False,+ },+ }],- },- )-- assert response.status_code == 200- routed = provider.requests[0]- assert [tool.name for tool in routed.tools] == ["mcp__node_repl__js"]- completed = parse_sse_text(response.text)[-1].data["response"]- call = completed["output"][0]- assert call["namespace"] == "mcp__node_repl"- assert call["name"] == "js"---def test_create_response_accepts_muse_code_request_shape() -> None:- provider = FakeProvider(_anthropic_tool_stream(tool_name="muse__read_file"))+ }+ ],+ }+ provider = FakeProvider(_responses_text_stream("done"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),TestClient(app) as client,):- response = client.post(- "/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Read the file",- "instructions": "Be concise.",- "max_output_tokens": 64,- "store": False,- "stream": True,- "reasoning": {"effort": "high", "summary": "auto"},- "include": ["reasoning.encrypted_content"],- "prompt_cache_key": "muse-session-1",- "tools": [- {- "type": "namespace",- "name": "muse",- "tools": [- {- "type": "function",- "name": "read_file",- "description": "Read one file.",- "strict": True,- "parameters": {- "type": "object",- "properties": {"path": {"type": "string"}},- "required": ["path"],- "additionalProperties": False,- },- }- ],- }- ],- },- )+ response = client.post("/v1/responses", json=request)assert response.status_code == 200routed = provider.requests[0]- assert routed.max_tokens == 64- assert routed.output_config == {"effort": "high"}- assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy(+ assert routed.max_output_tokens == 64+ assert routed.reasoning == {"effort": "high", "summary": "auto"}+ assert routed.model_dump()["include"] == ["reasoning.encrypted_content"]+ assert routed.model_dump()["prompt_cache_key"] == "muse-session-1"+ expected_policy = ReasoningPolicy(control=ReasoningControl.DEFAULT,effort=ReasoningEffort.HIGH,)- assert [tool.name for tool in routed.tools] == ["muse__read_file"]- completed = parse_sse_text(response.text)[-1].data["response"]- call = completed["output"][0]- assert call["namespace"] == "muse"- assert call["name"] == "read_file"+ assert provider.stream_kwargs[0]["reasoning"] == expected_policy+ assert provider.preflight_responses.call_args.kwargs["reasoning"] == expected_policy-def test_create_response_accepts_codex_custom_tool_request() -> None:- provider = FakeProvider(- _anthropic_tool_stream(- tool_name="apply_patch",- partial_json='{"input":"*** Begin Patch"}',- )- )+def test_create_response_preserves_custom_tool_request() -> None:+ tool: JsonObject = {+ "type": "custom",+ "name": "apply_patch",+ "description": "Apply repo patches",+ "format": {"type": "text"},+ }+ choice: JsonObject = {"type": "custom", "name": "apply_patch"}+ provider = FakeProvider(_responses_text_stream("done"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -511,49 +500,26 @@ def test_create_response_accepts_codex_custom_tool_request() -> None:response = client.post("/v1/responses",json={- "model": "nvidia_nim/test-model",+ "model": _PUBLIC_MODEL,"input": "Use apply_patch",- "stream": True,- "tools": [- {- "type": "custom",- "name": "apply_patch",- "description": "Apply repo patches",- "format": {"type": "text"},- }- ],- "tool_choice": {"type": "custom", "name": "apply_patch"},+ "tools": [tool],+ "tool_choice": choice,},)assert response.status_code == 200- routed = provider.requests[0]- assert [tool.name for tool in routed.tools] == ["apply_patch"]- assert routed.tool_choice == {"type": "tool", "name": "apply_patch"}- events = parse_sse_text(response.text)- assert "response.custom_tool_call_input.delta" in [event.event for event in events]- completed = events[-1].data["response"]- call = completed["output"][0]- assert call["type"] == "custom_tool_call"- assert call["name"] == "apply_patch"- assert call["input"] == "*** Begin Patch"+ assert provider.requests[0].tools == [tool]+ assert provider.requests[0].tool_choice == choice-def test_create_response_stream_provider_error_returns_response_failed() -> None:- provider = FakeProvider(- [- format_sse_event(- "error",- {- "type": "error",- "error": {- "type": "api_error",- "message": "provider failed",- },- },- )- ]- )+def test_create_response_relays_provider_error_lifecycle() -> None:+ error: JsonObject = {+ "message": "provider failed",+ "type": "api_error",+ "param": None,+ "code": None,+ }+ provider = FakeProvider([_created_event(), _terminal_event("failed", error=error)])app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -561,11 +527,7 @@ def test_create_response_stream_provider_error_returns_response_failed() -> None):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Hello",- "stream": True,- },+ json={"model": _PUBLIC_MODEL, "input": "Hello"},)assert response.status_code == 200@@ -574,16 +536,31 @@ def test_create_response_stream_provider_error_returns_response_failed() -> Nonefailed = events[-1].data["response"]assert failed["id"] == events[0].data["response"]["id"]assert failed["status"] == "failed"- assert failed["error"] == {- "message": "provider failed",- "type": "api_error",- "param": None,- "code": None,- }+ assert failed["error"] == error-def test_create_response_replays_prior_reasoning_as_reasoning_content() -> None:- provider = FakeProvider(_anthropic_text_stream("done"))+def test_create_response_preserves_prior_reasoning_and_tool_history() -> None:+ input_items: list[JsonObject] = [+ {+ "id": "rs_1",+ "type": "reasoning",+ "summary": [],+ "content": [{"type": "reasoning_text", "text": "Need the tool."}],+ },+ {+ "type": "function_call",+ "call_id": "call_1",+ "name": "echo",+ "arguments": "{}",+ },+ {+ "type": "function_call_output",+ "call_id": "call_1",+ "output": "ok",+ },+ {"role": "user", "content": "continue"},+ ]+ provider = FakeProvider(_responses_text_stream("done"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -591,57 +568,29 @@ def test_create_response_replays_prior_reasoning_as_reasoning_content() -> None:):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": [- {- "id": "rs_1",- "type": "reasoning",- "summary": [],- "content": [- {"type": "reasoning_text", "text": "Need the tool."}- ],- },- {- "type": "function_call",- "call_id": "call_1",- "name": "echo",- "arguments": "{}",- },- {- "type": "function_call_output",- "call_id": "call_1",- "output": "ok",- },- {- "id": "rs_2",- "type": "reasoning",- "summary": [- {"type": "summary_text", "text": "Use the result."}- ],- },- {"role": "user", "content": "continue"},- ],- "stream": True,- },+ json={"model": _PUBLIC_MODEL, "input": input_items},)assert response.status_code == 200- routed = provider.requests[0]- assert routed.messages[0].role == "assistant"- assert routed.messages[0].reasoning_content == "Need the tool."- assert routed.messages[0].content[0].type == "tool_use"- assert routed.messages[1].role == "user"- assert routed.messages[1].content[0].type == "tool_result"- assert routed.messages[2].role == "assistant"- assert routed.messages[2].content == ""- assert routed.messages[2].reasoning_content == "Use the result."- assert routed.messages[3].role == "user"- assert routed.messages[3].content == "continue"---def test_create_response_quarantines_malformed_prior_function_call() -> None:- provider = FakeProvider(_anthropic_text_stream("done"))+ assert provider.requests[0].input == input_items+++def test_create_response_preserves_malformed_prior_function_call() -> None:+ input_items: list[JsonObject] = [+ {"role": "user", "content": "hello"},+ {+ "type": "function_call",+ "call_id": "call_bad",+ "name": "echo",+ "arguments": "{",+ },+ {+ "type": "function_call_output",+ "call_id": "call_bad",+ "output": "stale output",+ },+ ]+ provider = FakeProvider(_responses_text_stream("done"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -649,34 +598,11 @@ def test_create_response_quarantines_malformed_prior_function_call() -> None:):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": [- {"role": "user", "content": "hello"},- {- "type": "function_call",- "call_id": "call_bad",- "name": "echo",- "arguments": "{",- },- {- "type": "function_call_output",- "call_id": "call_bad",- "output": "stale output",- },- {"role": "user", "content": "continue"},- ],- "stream": True,- },+ json={"model": _PUBLIC_MODEL, "input": input_items},)assert response.status_code == 200- routed = provider.requests[0]- assert [message.role for message in routed.messages] == ["user", "user"]- assert routed.messages[0].content == "hello"- assert routed.messages[1].content == "continue"- completed = parse_sse_text(response.text)[-1].data["response"]- assert completed["output"][0]["content"][0]["text"] == "done"+ assert provider.requests[0].input == input_items@pytest.mark.parametrize(@@ -693,10 +619,10 @@ def test_create_response_quarantines_malformed_prior_function_call() -> None:],)def test_create_response_preserves_and_resolves_reasoning_effort(- reasoning: dict[str, str],+ reasoning: JsonObject,expected_policy: ReasoningPolicy,) -> None:- provider = FakeProvider(_anthropic_text_stream("done"))+ provider = FakeProvider(_responses_text_stream("done"))app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -705,23 +631,29 @@ def test_create_response_preserves_and_resolves_reasoning_effort(response = client.post("/v1/responses",json={- "model": "nvidia_nim/test-model",+ "model": _PUBLIC_MODEL,"input": "Hello",- "stream": True,"reasoning": reasoning,},)assert response.status_code == 200- routed = provider.requests[0]- assert routed.thinking is None- assert routed.output_config == reasoning+ assert provider.requests[0].reasoning == reasoningassert provider.stream_kwargs[0]["reasoning"] == expected_policy- assert provider.preflight_stream.call_args.kwargs["reasoning"] == expected_policy+ assert provider.preflight_responses.call_args.kwargs["reasoning"] == expected_policy-def test_create_response_maps_redacted_thinking_to_encrypted_reasoning() -> None:- provider = FakeProvider(_anthropic_redacted_thinking_stream())+def test_create_response_relays_encrypted_reasoning() -> None:+ reasoning: JsonObject = {+ "id": "rs_1",+ "type": "reasoning",+ "status": "completed",+ "summary": [],+ "encrypted_content": "opaque-redacted",+ }+ provider = FakeProvider(+ [_created_event(), _terminal_event("completed", output=[reasoning])]+ )app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -729,36 +661,25 @@ def test_create_response_maps_redacted_thinking_to_encrypted_reasoning() -> None):response = client.post("/v1/responses",- json={- "model": "nvidia_nim/test-model",- "input": "Continue",- "stream": True,- },+ json={"model": _PUBLIC_MODEL, "input": "Continue"},)assert response.status_code == 200- completed = parse_sse_text(response.text)[-1].data["response"]- assert completed["output"] == [- {- "id": completed["output"][0]["id"],- "type": "reasoning",- "status": "completed",- "summary": [],- "encrypted_content": "opaque-redacted",- }- ]- assert "content" not in completed["output"][0]+ assert parse_sse_text(response.text)[-1].data["response"]["output"] == [reasoning]-def test_create_response_unsupported_tool_returns_openai_error(+def test_create_response_provider_rejects_unsupported_tool(responses_client: tuple[TestClient, FakeProvider],) -> None:- client, _provider = responses_client+ client, provider = responses_client+ provider.preflight_responses.side_effect = InvalidRequestError(+ "Unsupported Responses tool type: 'web_search_preview'"+ )response = client.post("/v1/responses",json={- "model": "nvidia_nim/test-model",+ "model": _PUBLIC_MODEL,"input": "Hello","tools": [{"type": "web_search_preview"}],},@@ -770,292 +691,108 @@ def test_create_response_unsupported_tool_returns_openai_error(assert "Unsupported Responses tool type" in payload["error"]["message"]-def _anthropic_text_stream(text: str, *, stop_reason: str = "end_turn") -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": text},- },+def _event(event_type: str, payload: JsonObject) -> str:+ return f"event: {event_type}\ndata: {json.dumps(payload)}\n\n"+++def _response(+ *,+ status: str,+ output: list[JsonObject] | None = None,+ error: JsonObject | None = None,+ incomplete_details: JsonObject | None = None,+) -> JsonObject:+ return {+ "id": _RESPONSE_ID,+ "object": "response",+ "created_at": 1,+ "model": _PUBLIC_MODEL,+ "status": status,+ "output": output or [],+ "error": error,+ "incomplete_details": incomplete_details,+ "usage": (+ None+ if status == "in_progress"+ else {+ "input_tokens": 3,+ "input_tokens_details": {"cached_tokens": 0},+ "output_tokens": 4,+ "output_tokens_details": {"reasoning_tokens": 0},+ "total_tokens": 7,+ }),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": stop_reason, "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+ }-def _anthropic_tool_stream(- tool_name: str = "echo", partial_json: str = '{"value":"FCC"}'-) -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": tool_name,- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {- "type": "input_json_delta",- "partial_json": partial_json,- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "tool_use", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+def _created_event() -> str:+ return _event(+ "response.created",+ {+ "type": "response.created",+ "sequence_number": 0,+ "response": _response(status="in_progress"),+ },+ )-def _anthropic_reasoning_text_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {- "type": "thinking_delta",- "thinking": "provider reasoning",- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "provider answer"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+def _terminal_event(+ status: str,+ *,+ output: list[JsonObject] | None = None,+ error: JsonObject | None = None,+) -> str:+ event_type = f"response.{status}"+ incomplete_details: JsonObject | None = (+ {"reason": "max_output_tokens"} if status == "incomplete" else None+ )+ return _event(+ event_type,+ {+ "type": event_type,+ "sequence_number": 2,+ "response": _response(+ status=status,+ output=output,+ error=error,+ incomplete_details=incomplete_details,+ ),+ },+ )-def _anthropic_interleaved_reasoning_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "thinking_delta", "thinking": "first thought"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "first answer"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 2,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": "echo",- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 2,- "delta": {- "type": "input_json_delta",- "partial_json": '{"value":"FCC"}',- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 2},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 3,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 3,- "delta": {"type": "thinking_delta", "thinking": "second thought"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 3},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 4,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 4,- "delta": {"type": "text_delta", "text": "final answer"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 4},- ),- format_sse_event(- "message_delta",+def _message_output(text: str, *, item_id: str = "msg_1") -> JsonObject:+ return {+ "id": item_id,+ "type": "message",+ "status": "completed",+ "role": "assistant",+ "content": [{- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+ "type": "output_text",+ "text": text,+ "annotations": [],+ "logprobs": [],+ }+ ],+ }-def _anthropic_redacted_thinking_stream() -> list[str]:+def _responses_text_stream(text: str, *, incomplete: bool = False) -> list[str]:+ status = "incomplete" if incomplete else "completed"return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {- "type": "redacted_thinking",- "data": "opaque-redacted",- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",+ _created_event(),+ _event(+ "response.output_text.delta",{- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},+ "type": "response.output_text.delta",+ "sequence_number": 1,+ "item_id": "msg_1",+ "output_index": 0,+ "content_index": 0,+ "delta": text,+ "logprobs": [],},),- format_sse_event("message_stop", {"type": "message_stop"}),+ _terminal_event(status, output=[_message_output(text)]),]diff --git a/tests/api/test_ordinary_error_phases.py b/tests/api/test_ordinary_error_phases.pyindex 00f5c452..cce786a1 100644--- a/tests/api/test_ordinary_error_phases.py+++ b/tests/api/test_ordinary_error_phases.py@@ -196,7 +196,12 @@ def test_preflight_rejection_is_protocol_specific_400_without_terminal_header() -> None:message = "bad tool shape"provider = MagicMock()- provider.preflight_stream.side_effect = InvalidRequestError(message)+ preflight = (+ provider.preflight_responses+ if wire_api == "responses"+ else provider.preflight_messages+ )+ preflight.side_effect = InvalidRequestError(message)app = create_test_app(_settings())with (@@ -208,7 +213,12 @@ def test_preflight_rejection_is_protocol_specific_400_without_terminal_header():response = client.post(path, json=payload)- provider.stream_response.assert_not_called()+ stream = (+ provider.stream_responses+ if wire_api == "responses"+ else provider.stream_messages+ )+ stream.assert_not_called()_assert_ordinary_protocol_error(response,wire_api=wire_api,diff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.pyindex 103624a7..97c4cb18 100644--- a/tests/api/test_request_lifetime.py+++ b/tests/api/test_request_lifetime.py@@ -23,6 +23,7 @@ from free_claude_code.application.ports import (from free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.streaming import format_sse_event+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicy@@ -384,7 +385,7 @@ class _ControlledProvider:self.closed = asyncio.Event()self.request_ids: list[str] = []- def preflight_stream(+ def preflight_messages(self,_request: MessagesRequest,*,@@ -392,7 +393,15 @@ class _ControlledProvider:) -> None:del reasoning- async def stream_response(+ def preflight_responses(+ self,+ _request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ del reasoning++ async def stream_messages(self,_request: MessagesRequest,*,@@ -411,6 +420,25 @@ class _ControlledProvider:finally:self.closed.set()+ async def stream_responses(+ self,+ _request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ del input_tokens, response_model, reasoning+ self.request_ids.append(request_id)+ try:+ for chunk in self._chunks:+ yield chunk+ self.blocked.set()+ await asyncio.Event().wait()+ finally:+ self.closed.set()+class _Lease:generation_id = 1@@ -473,6 +501,23 @@ def _message_start() -> str:)+def _response_created() -> str:+ payload = {+ "type": "response.created",+ "sequence_number": 0,+ "response": {+ "id": "resp_lifetime",+ "object": "response",+ "model": "nvidia_nim/test-model",+ "status": "in_progress",+ "output": [],+ "error": None,+ "usage": None,+ },+ }+ return f"event: response.created\ndata: {json.dumps(payload)}\n\n"++def _partial_message_stream() -> tuple[str, ...]:return (_message_start(),@@ -617,7 +662,7 @@ async def test_real_messages_post_start_disconnect_has_no_terminal_error() -> No@pytest.mark.asyncioasync def test_real_responses_post_start_disconnect_has_no_failed_event() -> None:- provider = _ControlledProvider((_message_start(),))+ provider = _ControlledProvider((_response_created(),))sent, lease = await _disconnect_real_app(path="/v1/responses",diff --git a/tests/api/test_safe_logging.py b/tests/api/test_safe_logging.pyindex 8c718473..203cef56 100644--- a/tests/api/test_safe_logging.py+++ b/tests/api/test_safe_logging.py@@ -23,7 +23,7 @@ async def test_create_message_skips_full_payload_debug_log_by_default():async def fake_stream(*_a, **_kw):yield "event: ping\ndata: {}\n\n"- mock_provider.stream_response = fake_stream+ mock_provider.stream_messages = fake_streamservice = MessagesHandler(settings, provider_resolver=lambda _: mock_provider)request = MessagesRequest(@@ -52,7 +52,7 @@ async def test_create_message_logs_full_payload_when_opt_in():async def fake_stream(*_a, **_kw):yield "event: ping\ndata: {}\n\n"- mock_provider.stream_response = fake_stream+ mock_provider.stream_messages = fake_streamservice = MessagesHandler(settings, provider_resolver=lambda _: mock_provider)request = MessagesRequest(model="claude-3-haiku-20240307",@@ -109,7 +109,7 @@ async def test_create_message_unexpected_error_default_logs_exclude_exception_tedef stream_boom(*_a, **_kw):raise RuntimeError(secret)- mock_provider.stream_response = stream_boom+ mock_provider.stream_messages = stream_boomservice = MessagesHandler(settings, provider_resolver=lambda _: mock_provider)request = MessagesRequest(model="claude-3-haiku-20240307",@@ -142,7 +142,7 @@ async def test_create_message_unexpected_error_terminal_json_ignores_status_codedef stream_boom(*_a, **_kw):raise WeirdError("no")- mock_provider.stream_response = stream_boom+ mock_provider.stream_messages = stream_boomservice = MessagesHandler(settings, provider_resolver=lambda _: mock_provider)request = MessagesRequest(model="claude-3-haiku-20240307",diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.pyindex d0dca6ff..90641c57 100644--- a/tests/api/test_web_server_tools.py+++ b/tests/api/test_web_server_tools.py@@ -51,6 +51,7 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.core.version import package_versionfrom free_claude_code.messaging.event_parser import parse_cli_event@@ -126,12 +127,32 @@ class ScriptedSelectionProvider:self.stream_kwargs: list[dict[str, object]] = []self.close_count = 0- def preflight_stream(+ def preflight_messages(self, request: MessagesRequest, *, reasoning: ReasoningPolicy) -> None:return None- async def stream_response(+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ raise AssertionError("Web-search selection received a Responses request")++ async def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ raise AssertionError("Web-search selection received a Responses request")+ yield ""++ async def stream_messages(self,request: MessagesRequest,*,diff --git a/tests/application/test_execution.py b/tests/application/test_execution.pyindex 4ab1ff20..88c5aa90 100644--- a/tests/application/test_execution.py+++ b/tests/application/test_execution.py@@ -12,11 +12,13 @@ from free_claude_code.application.routing import (ProviderModelTarget,ResolvedModelRoute,RoutedMessagesRequest,+ RoutedResponsesRequest,)from free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.core.anthropic.models import Message, MessagesRequestfrom free_claude_code.core.async_iterators import AsyncCloseablefrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicy@@ -26,7 +28,7 @@ class FakeProvider:self.stream_calls: list[dict[str, object]] = []self.stream_close_calls = 0- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -34,7 +36,15 @@ class FakeProvider:) -> None:self.preflight_calls.append((request, reasoning))- async def stream_response(+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ raise AssertionError("Messages test provider received a Responses request")++ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -55,6 +65,18 @@ class FakeProvider:finally:self.stream_close_calls += 1+ async def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ raise AssertionError("Messages test provider received a Responses request")+ yield ""+def _record_stream_call(self,request: MessagesRequest,@@ -75,6 +97,64 @@ class FakeProvider:)+class ResponsesFakeProvider:+ def __init__(self) -> None:+ self.preflight_calls: list[tuple[OpenAIResponsesRequest, ReasoningPolicy]] = []+ self.stream_calls: list[dict[str, object]] = []+ self.stream_close_calls = 0++ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ self.preflight_calls.append((request, reasoning))++ def preflight_messages(+ self,+ request: MessagesRequest,+ *,+ reasoning: ReasoningPolicy,+ ) -> None:+ raise AssertionError("Responses test provider received a Messages request")++ async def stream_messages(+ self,+ request: MessagesRequest,+ *,+ input_tokens: int,+ request_id: str,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ raise AssertionError("Responses test provider received a Messages request")+ yield ""++ async def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ input_tokens: int,+ request_id: str,+ response_model: str,+ reasoning: ReasoningPolicy,+ ) -> AsyncIterator[str]:+ self.stream_calls.append(+ {+ "request": request,+ "input_tokens": input_tokens,+ "request_id": request_id,+ "response_model": response_model,+ "reasoning": reasoning,+ }+ )+ try:+ yield "event: response.completed\ndata: {}\n\n"+ finally:+ self.stream_close_calls += 1++class WaitStep:def __init__(self) -> None:self.started = asyncio.Event()@@ -101,7 +181,7 @@ class ControlledProvider(FakeProvider):super().__init__()self._steps = steps- async def stream_response(+ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -136,7 +216,7 @@ class ControlledProvider(FakeProvider):class FailingPreflightProvider(FakeProvider):- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -150,7 +230,7 @@ class ApplicationErrorPreflightProvider(FakeProvider):super().__init__()self._error = error- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -160,7 +240,7 @@ class ApplicationErrorPreflightProvider(FakeProvider):class FailingStreamConstructionProvider(FakeProvider):- def stream_response(+ def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -177,7 +257,7 @@ class ExecutionFailureStreamConstructionProvider(FakeProvider):super().__init__()self._failure = failure- def stream_response(+ def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -204,7 +284,7 @@ class CloseControlledProvider(FakeProvider):self._close_error = close_errorself._read = False- def stream_response(+ def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -266,6 +346,26 @@ def _routed_request()+def _routed_responses_request(+ *fallbacks: ProviderModelTarget,+) -> RoutedResponsesRequest:+ request = OpenAIResponsesRequest(+ model="provider-model",+ input=[{"role": "user", "content": "hello"}],+ reasoning={"effort": "high"},+ )+ return RoutedResponsesRequest(+ request=request,+ resolved=ResolvedModelRoute(+ original_model="gateway-model",+ primary=_target("provider", "provider-model"),+ fallbacks=fallbacks,+ reasoning_preference=ReasoningPreference.CLIENT,+ ),+ reasoning=ReasoningPolicy.on(),+ )++def _executor_stream(provider: FakeProvider,*,@@ -277,15 +377,46 @@ def _executor_stream(token_counter=lambda _messages, _system, _tools: 17,progress_timeout_seconds=timeout_seconds,)- return executor.stream(+ return executor.stream_messages(_routed_request(),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id=request_id,)+async def test_executor_routes_native_responses_without_messages_conversion() -> None:+ provider = ResponsesFakeProvider()+ routed = _routed_responses_request()+ request = routed.request+ executor = ProviderExecutor(+ lambda _provider_id: provider,+ progress_timeout_seconds=60.0,+ responses_token_counter=lambda _request: 23,+ )++ stream = executor.stream_responses(+ routed,+ raw_log_payload=request.model_dump(mode="json"),+ request_id="req_responses_application",+ )++ assert provider.preflight_calls == [(request, ReasoningPolicy.on())]+ assert [chunk async for chunk in stream] == [+ "event: response.completed\ndata: {}\n\n"+ ]+ assert provider.stream_calls == [+ {+ "request": request,+ "input_tokens": 23,+ "request_id": "req_responses_application",+ "response_model": "gateway-model",+ "reasoning": ReasoningPolicy.on(),+ }+ ]+ assert provider.stream_close_calls == 1++@pytest.mark.asyncioasync def test_executor_uses_structural_provider_port_and_preflights_eagerly() -> None:provider = FakeProvider()@@ -297,10 +428,8 @@ async def test_executor_uses_structural_provider_port_and_preflights_eagerly() -token_counter=lambda _messages, _system, _tools: 17,)- stream = executor.stream(+ stream = executor.stream_messages(routed,- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload=request.model_dump(),request_id="req_application",)@@ -343,10 +472,8 @@ async def test_primary_success_never_resolves_fallback() -> None:return {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=60.0)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "fallback-model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_primary_success",)@@ -382,10 +509,8 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primarywith patch("free_claude_code.application.execution.trace_event") as trace_mock:chunks = [chunk- async for chunk in executor.stream(+ async for chunk in executor.stream_messages(routed,- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_fallback",)@@ -445,10 +570,8 @@ async def test_fallback_chain_preserves_exact_last_failure() -> None:providers.__getitem__,progress_timeout_seconds=60.0,)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("second", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_exhausted",)@@ -474,13 +597,11 @@ async def test_multiple_retryable_failures_walk_fallbacks_in_order() -> None:return providers[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=60.0)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("second", "second-model"),_target("third", "third-model"),),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_ordered_fallbacks",)@@ -501,10 +622,8 @@ async def test_empty_primary_completion_does_not_select_fallback() -> None:return {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=60.0)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_empty_primary",)@@ -525,10 +644,8 @@ async def test_unexpected_primary_failure_does_not_select_fallback() -> None:return {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=60.0)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_unexpected_primary",)@@ -551,11 +668,9 @@ async def test_invalid_none_stream_remains_terminal() -> None:return {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=60.0)- with patch.object(primary, "stream_response", return_value=None):- stream = executor.stream(+ with patch.object(primary, "stream_messages", return_value=None):+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_invalid_stream",)@@ -586,10 +701,8 @@ async def test_nonretryable_provider_failure_selects_fallback_before_first_framereturn {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=60.0)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_rejected",)@@ -623,10 +736,8 @@ async def test_nonretryable_stream_construction_failure_selects_fallback() -> Noproviders.__getitem__,progress_timeout_seconds=60.0,)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_construction_failure",)@@ -647,10 +758,8 @@ async def test_failure_after_first_frame_never_selects_fallback() -> None:return {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=60.0)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_committed",)@@ -673,10 +782,8 @@ async def test_lazy_fallback_preflight_application_error_stops_unchanged() -> Noproviders.__getitem__,progress_timeout_seconds=60.0,)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_preflight",)@@ -692,7 +799,7 @@ async def test_lazy_fallback_preflight_application_error_stops_unchanged() -> No@pytest.mark.asyncioasync def test_candidate_requests_are_isolated_from_provider_mutation() -> None:class MutatingProvider(ControlledProvider):- async def stream_response(+ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -702,7 +809,7 @@ async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:reasoning: ReasoningPolicy,) -> AsyncIterator[str]:request.messages[0].content = "mutated"- async for chunk in super().stream_response(+ async for chunk in super().stream_messages(request,input_tokens,request_id=request_id,@@ -722,10 +829,8 @@ async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:assert [chunk- async for chunk in executor.stream(+ async for chunk in executor.stream_messages(routed,- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_isolated",)@@ -745,10 +850,8 @@ async def test_closing_executor_stream_closes_provider_stream_once() -> None:progress_timeout_seconds=60.0,token_counter=lambda _messages, _system, _tools: 17,)- stream = executor.stream(+ stream = executor.stream_messages(routed,- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_early_close",)@@ -776,10 +879,8 @@ async def test_stream_construction_failure_remains_deferred_to_iteration() -> Notoken_counter=lambda _messages, _system, _tools: 17,)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_deferred_construction",)@@ -800,10 +901,8 @@ def test_executor_preflight_failure_stays_before_token_count_and_stream() -> Non)with pytest.raises(ValueError, match="invalid provider request"):- executor.stream(+ executor.stream_messages(_routed_request(),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_application",)@@ -877,10 +976,8 @@ async def test_application_progress_timeout_never_resolves_fallback() -> None:return {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=0.02)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_terminal_progress_timeout",)@@ -910,10 +1007,8 @@ async def test_provider_cleanup_cannot_delay_fallback_past_progress_deadline() -return {"provider": primary, "fallback": fallback}[provider_id]executor = ProviderExecutor(resolve, progress_timeout_seconds=0.02)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_cleanup_timeout",)@@ -1017,10 +1112,8 @@ async def test_fallback_transition_does_not_reset_shared_progress_deadline() ->providers.__getitem__,progress_timeout_seconds=timeout_seconds,)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_shared_deadline",)@@ -1076,10 +1169,8 @@ async def test_cancelling_progress_wait_remains_cancellation() -> None:resolve,progress_timeout_seconds=1.0,)- stream = executor.stream(+ stream = executor.stream_messages(_routed_request(_target("fallback", "model")),- wire_api="messages",- raw_log_label="FULL_PAYLOAD",raw_log_payload={},request_id="req_cancelled_progress",)diff --git a/tests/application/test_reasoning.py b/tests/application/test_reasoning.pyindex fbbc527a..ce49ea0e 100644--- a/tests/application/test_reasoning.py+++ b/tests/application/test_reasoning.py@@ -2,10 +2,13 @@ import pytestfrom free_claude_code.application.reasoning import (client_reasoning_policy,+ client_responses_reasoning_policy,resolve_reasoning_policy,+ resolve_responses_reasoning_policy,)from free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,@@ -118,6 +121,47 @@ def test_unresolved_inherit_is_rejected() -> None:resolve_reasoning_policy(_request(), ReasoningPreference.INHERIT)+ ("reasoning", "expected"),+ (+ (None, ReasoningPolicy.provider_default()),+ ({"effort": "none"}, ReasoningPolicy.off()),+ (+ {"effort": "high"},+ ReasoningPolicy(+ control=ReasoningControl.DEFAULT,+ effort=ReasoningEffort.HIGH,+ ),+ ),+ ({"effort": "future-value"}, ReasoningPolicy.provider_default()),+ ),+)+def test_responses_reasoning_policy_preserves_supported_client_intent(+ reasoning: dict[str, str] | None,+ expected: ReasoningPolicy,+) -> None:+ request = OpenAIResponsesRequest(+ model="provider/model",+ input="hello",+ reasoning=reasoning,+ )++ assert client_responses_reasoning_policy(request) == expected+++def test_responses_route_preference_overrides_client_reasoning() -> None:+ request = OpenAIResponsesRequest(+ model="provider/model",+ input="hello",+ reasoning={"effort": "none"},+ )++ assert resolve_responses_reasoning_policy(+ request,+ ReasoningPreference.XHIGH,+ ) == ReasoningPolicy.on(effort=ReasoningEffort.XHIGH)++@pytest.mark.parametrize("budget", [0, -1, True])def test_reasoning_budget_requires_a_positive_integer(budget: int) -> None:with pytest.raises(ValueError, match="positive integer"):diff --git a/tests/application/test_routing.py b/tests/application/test_routing.pyindex 009b7c90..09b0049a 100644--- a/tests/application/test_routing.py+++ b/tests/application/test_routing.py@@ -12,6 +12,7 @@ from free_claude_code.core.anthropic.models import (MessagesRequest,TokenCountRequest,)+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort@@ -270,6 +271,31 @@ def test_model_router_routes_token_count_request(settings):assert request.model == "claude-3-haiku-20240307"+def test_model_router_routes_responses_request_without_protocol_conversion(settings):+ settings.model_fallbacks = ("open_router/vendor/fallback",)+ request = OpenAIResponsesRequest(+ model="opencode_zen/responses-model",+ input=[{"role": "user", "content": "hello"}],+ reasoning={"effort": "high"},+ previous_response_id="resp_previous",+ )++ routed = ModelRouter(settings).resolve_responses_request(request)++ assert routed.request.model == "responses-model"+ assert routed.request.input == request.input+ assert routed.request.previous_response_id == "resp_previous"+ assert routed.resolved.original_model == "opencode_zen/responses-model"+ assert routed.resolved.primary.provider_id == "opencode_zen"+ assert routed.resolved.primary.provider_model == "responses-model"+ assert [target.provider_model_ref for target in routed.resolved.fallbacks] == [+ "open_router/vendor/fallback"+ ]+ assert routed.reasoning.control is ReasoningControl.DEFAULT+ assert routed.reasoning.effort is ReasoningEffort.HIGH+ assert request.model == "opencode_zen/responses-model"++def test_model_router_appends_global_fallbacks_and_skips_only_primary(settings):settings.model_fallbacks = ("nvidia_nim/fallback-model",diff --git a/tests/contracts/test_protocol_matrix.py b/tests/contracts/test_protocol_matrix.pynew file mode 100644index 00000000..5a81c31c--- /dev/null+++ b/tests/contracts/test_protocol_matrix.py@@ -0,0 +1,315 @@+"""Executable contract for the two-ingress by two-upstream protocol matrix."""++import json+from collections.abc import AsyncIterator, Callable+from unittest.mock import patch++import httpx2+import pytest+from openai import AsyncOpenAI++from free_claude_code.core.anthropic import MessagesRequest, ReasoningReplayMode+from free_claude_code.core.anthropic.stream_contracts import (+ assert_anthropic_stream_contract,+ parse_sse_text,+ text_content,+)+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY+from free_claude_code.providers.openai_chat import (+ NO_REASONING,+ OpenAIChatProfile,+ OpenAIChatProvider,+ OpenAIChatRequestPolicy,+)+from free_claude_code.providers.openai_responses import OpenAIResponsesTransport+from tests.providers.support import immediate_admission, make_provider_config+++def _messages_request() -> MessagesRequest:+ return MessagesRequest.model_validate(+ {+ "model": "upstream-model",+ "messages": [{"role": "user", "content": "hello"}],+ "max_tokens": 64,+ }+ )+++def _responses_request() -> OpenAIResponsesRequest:+ return OpenAIResponsesRequest.model_validate(+ {+ "model": "upstream-model",+ "input": "hello",+ "max_output_tokens": 64,+ }+ )+++def _client(handler: Callable[[httpx2.Request], httpx2.Response]) -> AsyncOpenAI:+ return AsyncOpenAI(+ api_key="test-key",+ base_url="https://provider.invalid/v1",+ max_retries=0,+ http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(handler)),+ )+++def _chat_sse(text: str) -> str:+ chunks = (+ {+ "id": "chatcmpl_matrix",+ "object": "chat.completion.chunk",+ "created": 1,+ "model": "upstream-model",+ "choices": [+ {+ "index": 0,+ "delta": {"role": "assistant", "content": text},+ "finish_reason": None,+ }+ ],+ },+ {+ "id": "chatcmpl_matrix",+ "object": "chat.completion.chunk",+ "created": 1,+ "model": "upstream-model",+ "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],+ "usage": {+ "prompt_tokens": 2,+ "completion_tokens": 1,+ "total_tokens": 3,+ },+ },+ )+ return "".join(f"data: {json.dumps(chunk)}\n\n" for chunk in chunks) + (+ "data: [DONE]\n\n"+ )+++def _response_payload(*, status: str, text: str) -> dict[str, object]:+ output = (+ []+ if status == "in_progress"+ else [+ {+ "id": "msg_matrix",+ "type": "message",+ "status": "completed",+ "role": "assistant",+ "content": [+ {+ "type": "output_text",+ "text": text,+ "annotations": [],+ "logprobs": [],+ }+ ],+ }+ ]+ )+ return {+ "id": "resp_matrix",+ "created_at": 1,+ "error": None,+ "incomplete_details": None,+ "instructions": None,+ "metadata": None,+ "model": "upstream-model",+ "object": "response",+ "output": output,+ "parallel_tool_calls": True,+ "temperature": None,+ "tool_choice": "auto",+ "tools": [],+ "top_p": None,+ "background": False,+ "conversation": None,+ "max_output_tokens": 64,+ "max_tool_calls": None,+ "previous_response_id": None,+ "prompt": None,+ "prompt_cache_key": None,+ "reasoning": None,+ "safety_identifier": None,+ "service_tier": "default",+ "status": status,+ "text": {"format": {"type": "text"}, "verbosity": "medium"},+ "top_logprobs": 0,+ "truncation": "disabled",+ "usage": (+ None+ if status == "in_progress"+ else {+ "input_tokens": 2,+ "input_tokens_details": {"cached_tokens": 0},+ "output_tokens": 1,+ "output_tokens_details": {"reasoning_tokens": 0},+ "total_tokens": 3,+ }+ ),+ "user": None,+ "store": False,+ }+++def _responses_sse(text: str) -> str:+ events = (+ {+ "type": "response.created",+ "sequence_number": 0,+ "response": _response_payload(status="in_progress", text=text),+ },+ {+ "type": "response.output_text.delta",+ "sequence_number": 1,+ "item_id": "msg_matrix",+ "output_index": 0,+ "content_index": 0,+ "delta": text,+ "logprobs": [],+ },+ {+ "type": "response.completed",+ "sequence_number": 2,+ "response": _response_payload(status="completed", text=text),+ },+ )+ return "".join(f"data: {json.dumps(event)}\n\n" for event in events)+++async def _collect(stream: AsyncIterator[str]) -> str:+ return "".join([chunk async for chunk in stream])+++async def test_chat_upstream_accepts_both_ingress_protocols_directly() -> None:+ requests: list[httpx2.Request] = []++ def handler(request: httpx2.Request) -> httpx2.Response:+ requests.append(request)+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_chat_sse("chat-ok"),+ )++ client = _client(handler)+ config = make_provider_config(+ api_key="test-key",+ base_url="https://provider.invalid/v1",+ )+ with patch(+ "free_claude_code.providers.openai_chat.provider.AsyncOpenAI",+ return_value=client,+ ):+ provider = OpenAIChatProvider(+ config,+ profile=OpenAIChatProfile(+ OpenAIChatRequestPolicy(+ provider_name="MATRIX_CHAT",+ reasoning_replay=ReasoningReplayMode.DISABLED,+ ),+ NO_REASONING,+ ),+ admission=immediate_admission(provider_name="MATRIX_CHAT"),+ )+ try:+ messages_body = await _collect(+ provider.stream_messages(+ _messages_request(),+ input_tokens=2,+ request_id="req_matrix_messages_chat",+ response_model="public-model",+ )+ )+ responses_body = await _collect(+ provider.stream_responses(+ _responses_request(),+ input_tokens=2,+ request_id="req_matrix_responses_chat",+ response_model="public-model",+ )+ )+ finally:+ await provider.cleanup()++ assert [request.url.path for request in requests] == [+ "/v1/chat/completions",+ "/v1/chat/completions",+ ]+ messages_events = parse_sse_text(messages_body)+ assert_anthropic_stream_contract(messages_events)+ assert text_content(messages_events) == "chat-ok"+ responses_events = parse_sse_text(responses_body)+ assert responses_events[0].event == "response.created"+ assert responses_events[-1].event == "response.completed"+ assert responses_events[-1].data["response"]["model"] == "public-model"+ assert (+ responses_events[-1].data["response"]["output"][0]["content"][0]["text"]+ == "chat-ok"+ )+++async def test_responses_upstream_accepts_both_ingress_protocols_directly() -> None:+ requests: list[httpx2.Request] = []++ def handler(request: httpx2.Request) -> httpx2.Response:+ requests.append(request)+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_responses_sse("responses-ok"),+ )++ client = _client(handler)+ transport = OpenAIResponsesTransport(+ client=client,+ admission=immediate_admission(provider_name="MATRIX_RESPONSES"),+ provider_name="MATRIX_RESPONSES",+ read_timeout_s=120.0,+ log_raw_sse_events=False,+ )+ try:+ messages_body = await _collect(+ transport.stream_messages(+ _messages_request(),+ input_tokens=2,+ request_id="req_matrix_messages_responses",+ response_model="public-model",+ reasoning=DEFAULT_REASONING_POLICY,+ )+ )+ responses_body = await _collect(+ transport.stream_responses(+ _responses_request(),+ input_tokens=2,+ request_id="req_matrix_responses_responses",+ response_model="public-model",+ reasoning=DEFAULT_REASONING_POLICY,+ )+ )+ finally:+ await client.close()++ assert [request.url.path for request in requests] == [+ "/v1/responses",+ "/v1/responses",+ ]+ messages_events = parse_sse_text(messages_body)+ assert_anthropic_stream_contract(messages_events)+ assert text_content(messages_events) == "responses-ok"+ responses_events = parse_sse_text(responses_body)+ assert [event.event for event in responses_events] == [+ "response.created",+ "response.output_text.delta",+ "response.completed",+ ]+ assert responses_events[0].data["response"]["id"] == "resp_matrix"+ assert responses_events[-1].data["response"]["model"] == "public-model"+ assert (+ responses_events[-1].data["response"]["output"][0]["content"][0]["text"]+ == "responses-ok"+ )diff --git a/tests/core/anthropic/test_openai_tool_names.py b/tests/core/anthropic/test_openai_tool_names.pyindex 908aae01..a3c9719f 100644--- a/tests/core/anthropic/test_openai_tool_names.py+++ b/tests/core/anthropic/test_openai_tool_names.py@@ -1,7 +1,7 @@import refrom free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec_PORTABLE_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")diff --git a/tests/core/anthropic/test_text_tools.py b/tests/core/anthropic/test_text_tools.pyindex 82107cf7..a57276ac 100644--- a/tests/core/anthropic/test_text_tools.py+++ b/tests/core/anthropic/test_text_tools.py@@ -1,10 +1,8 @@import pytest-from free_claude_code.core.anthropic import (- FunctionTagToolParser,- OpenAIToolNameCodec,-)+from free_claude_code.core.anthropic import FunctionTagToolParserfrom free_claude_code.core.anthropic import tools as tool_parsers+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecfrom tests.providers.request_factory import make_messages_requestdiff --git a/tests/core/openai_responses/test_chat_request.py b/tests/core/openai_responses/test_chat_request.pynew file mode 100644index 00000000..73f95e5b--- /dev/null+++ b/tests/core/openai_responses/test_chat_request.py@@ -0,0 +1,386 @@+import pytest++from free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.core.openai_responses.chat_request import (+ build_responses_chat_request,+)+from free_claude_code.core.openai_responses.errors import ResponsesConversionError+from free_claude_code.core.openai_responses.models import OpenAIResponsesRequest+++def _request(**overrides: object) -> OpenAIResponsesRequest:+ payload: dict[str, object] = {+ "model": "provider/model",+ "input": "Hello",+ }+ payload.update(overrides)+ return OpenAIResponsesRequest.model_validate(payload)+++def test_build_responses_chat_request_preserves_rich_supported_semantics() -> None:+ translated = build_responses_chat_request(+ _request(+ instructions="System rules",+ input=[+ {+ "type": "message",+ "role": "developer",+ "content": [{"type": "input_text", "text": "Developer rules"}],+ },+ {+ "type": "message",+ "role": "user",+ "content": [+ {"type": "input_text", "text": "Inspect this"},+ {+ "type": "input_image",+ "image_url": "data:image/png;base64,AA==",+ "detail": "low",+ },+ ],+ },+ {+ "type": "reasoning",+ "summary": [{"type": "summary_text", "text": "Use the tool."}],+ "encrypted_content": "opaque-replay",+ },+ {+ "type": "function_call",+ "call_id": "call_1",+ "namespace": "mcp.shell",+ "name": "echo value",+ "arguments": '{"value":"FCC"}',+ },+ {+ "type": "function_call_output",+ "call_id": "call_1",+ "output": "FCC",+ },+ {"type": "message", "role": "user", "content": "Continue"},+ ],+ tools=[+ {"type": "web_search", "external_web_access": True},+ {+ "type": "namespace",+ "name": "mcp.shell",+ "tools": [+ {+ "type": "function",+ "name": "echo value",+ "description": "Echo a value",+ "parameters": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ },+ "strict": True,+ }+ ],+ },+ {+ "type": "custom",+ "name": "apply patch",+ "description": "Apply a patch",+ "format": {"type": "text"},+ },+ ],+ tool_choice={+ "type": "function",+ "namespace": "mcp.shell",+ "name": "echo value",+ },+ parallel_tool_calls=False,+ max_output_tokens=128,+ temperature=0.2,+ top_p=0.9,+ metadata={"trace": "abc"},+ text={+ "format": {+ "type": "json_schema",+ "name": "answer",+ "schema": {+ "type": "object",+ "properties": {"ok": {"type": "boolean"}},+ },+ "strict": True,+ }+ },+ ),+ reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,+ structured_reasoning_details=True,+ )++ body = translated.body+ namespace_name = "mcp_shell__echo_value"+ namespace_alias = translated.tool_names.encode(namespace_name)+ custom_alias = translated.tool_names.encode("apply patch")+ assert namespace_alias == namespace_name+ assert custom_alias != "apply patch"++ assert body == {+ "model": "provider/model",+ "messages": [+ {+ "role": "system",+ "content": "System rules\n\nDeveloper rules",+ },+ {+ "role": "user",+ "content": [+ {"type": "text", "text": "Inspect this"},+ {+ "type": "image_url",+ "image_url": {+ "url": "data:image/png;base64,AA==",+ "detail": "low",+ },+ },+ ],+ },+ {+ "role": "assistant",+ "content": "",+ "reasoning_content": "Use the tool.",+ "reasoning_details": [+ {"type": "reasoning.encrypted", "data": "opaque-replay"}+ ],+ "tool_calls": [+ {+ "id": "call_1",+ "type": "function",+ "function": {+ "name": namespace_name,+ "arguments": '{"value":"FCC"}',+ },+ }+ ],+ },+ {"role": "tool", "tool_call_id": "call_1", "content": "FCC"},+ {"role": "user", "content": "Continue"},+ ],+ "tools": [+ {+ "type": "function",+ "function": {+ "name": namespace_name,+ "description": "Echo a value",+ "parameters": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ },+ "strict": True,+ },+ },+ {+ "type": "function",+ "function": {+ "name": "apply patch",+ "description": (+ "Apply a patch\n\nCustom tool input format: unconstrained text."+ ),+ "parameters": {+ "type": "object",+ "properties": {+ "input": {+ "type": "string",+ "description": "Free-form input for the custom tool.",+ }+ },+ "required": ["input"],+ },+ },+ },+ ],+ "tool_choice": {+ "type": "function",+ "function": {"name": namespace_name},+ },+ "parallel_tool_calls": False,+ "max_tokens": 128,+ "temperature": 0.2,+ "top_p": 0.9,+ "metadata": {"trace": "abc"},+ "response_format": {+ "type": "json_schema",+ "json_schema": {+ "name": "answer",+ "schema": {+ "type": "object",+ "properties": {"ok": {"type": "boolean"}},+ },+ "strict": True,+ },+ },+ }+++ ("mode", "expected"),+ [+ (ReasoningReplayMode.REASONING_CONTENT, {"reasoning_content": "Think"}),+ (ReasoningReplayMode.REASONING, {"reasoning": "Think"}),+ (ReasoningReplayMode.THINK_TAGS, {"content": "<think>\nThink\n</think>"}),+ (ReasoningReplayMode.DISABLED, {}),+ ],+)+def test_build_responses_chat_request_uses_provider_reasoning_replay(+ mode: ReasoningReplayMode,+ expected: dict[str, str],+) -> None:+ translated = build_responses_chat_request(+ _request(+ input=[+ {+ "type": "reasoning",+ "content": [{"type": "reasoning_text", "text": "Think"}],+ },+ {"type": "message", "role": "assistant", "content": "Answer"},+ ]+ ),+ reasoning_replay=mode,+ )++ messages = translated.body["messages"]+ assert isinstance(messages, list)+ assistant = messages[0]+ assert isinstance(assistant, dict)+ if mode is ReasoningReplayMode.THINK_TAGS:+ assert assistant["content"] == "<think>\nThink\n</think>\n\nAnswer"+ else:+ for key, value in expected.items():+ assert assistant[key] == value+ if mode is ReasoningReplayMode.DISABLED:+ assert assistant == {"role": "assistant", "content": "Answer"}+++def test_build_responses_chat_request_quarantines_one_malformed_call_pair() -> None:+ translated = build_responses_chat_request(+ _request(+ input=[+ {"role": "user", "content": "Hello"},+ {+ "type": "function_call",+ "call_id": "call_bad",+ "name": "echo",+ "arguments": "{",+ },+ {+ "type": "function_call_output",+ "call_id": "call_bad",+ "output": "stale",+ },+ {+ "type": "function_call",+ "call_id": "call_good",+ "name": "echo",+ "arguments": '{"value":"ok"}',+ },+ {+ "type": "function_call_output",+ "call_id": "call_good",+ "output": "ok",+ },+ ]+ ),+ reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,+ )++ assert translated.body["messages"] == [+ {"role": "user", "content": "Hello"},+ {+ "role": "assistant",+ "content": "",+ "tool_calls": [+ {+ "id": "call_good",+ "type": "function",+ "function": {+ "name": "echo",+ "arguments": '{"value":"ok"}',+ },+ }+ ],+ },+ {"role": "tool", "tool_call_id": "call_good", "content": "ok"},+ ]+++def test_build_responses_chat_request_skips_unsupported_optional_items_and_choice() -> (+ None+):+ translated = build_responses_chat_request(+ _request(+ input=[+ {"type": "computer_screenshot", "image_url": "ignored"},+ {"role": "user", "content": "Hello"},+ ],+ tools=[{"type": "web_search_preview"}],+ tool_choice={"type": "web_search_preview"},+ ),+ reasoning_replay=ReasoningReplayMode.DISABLED,+ )++ assert translated.body == {+ "model": "provider/model",+ "messages": [{"role": "user", "content": "Hello"}],+ }+++def test_build_responses_chat_request_rejects_no_usable_input() -> None:+ with pytest.raises(ResponsesConversionError, match="usable input"):+ build_responses_chat_request(+ _request(input=[{"type": "computer_screenshot", "image_url": "x"}]),+ reasoning_replay=ReasoningReplayMode.DISABLED,+ )+++def test_build_responses_chat_request_rejects_message_with_only_skipped_parts() -> None:+ with pytest.raises(ResponsesConversionError, match="usable input"):+ build_responses_chat_request(+ _request(+ input=[+ {+ "type": "message",+ "role": "user",+ "content": [+ {+ "type": "input_image",+ "file_id": "file_not_representable_in_chat",+ }+ ],+ }+ ]+ ),+ reasoning_replay=ReasoningReplayMode.DISABLED,+ )+++def test_build_responses_chat_request_rejects_colliding_tool_wire_names() -> None:+ with pytest.raises(ResponsesConversionError, match="same Chat-compatible name"):+ build_responses_chat_request(+ _request(+ tools=[+ {+ "type": "function",+ "name": "mcp_shell__echo_value",+ "parameters": {"type": "object"},+ },+ {+ "type": "namespace",+ "name": "mcp.shell",+ "tools": [+ {+ "type": "function",+ "name": "echo value",+ "parameters": {"type": "object"},+ }+ ],+ },+ ],+ tool_choice={+ "type": "function",+ "namespace": "mcp.shell",+ "name": "echo value",+ },+ ),+ reasoning_replay=ReasoningReplayMode.DISABLED,+ )diff --git a/tests/core/openai_responses/test_conversion.py b/tests/core/openai_responses/test_conversion.pydeleted file mode 100644index 5adac9ba..00000000--- a/tests/core/openai_responses/test_conversion.py+++ /dev/null@@ -1,684 +0,0 @@-from typing import Any--import pytest--from free_claude_code.core.openai_responses import (- OpenAIResponsesAdapter,- OpenAIResponsesRequest,-)--_ADAPTER = OpenAIResponsesAdapter()-_CONVERSION_ERROR = OpenAIResponsesAdapter.ConversionError---def _to_anthropic_payload(request: dict[str, Any]) -> dict[str, Any]:- return _ADAPTER.to_anthropic_payload(OpenAIResponsesRequest.model_validate(request))---def test_responses_string_input_converts_to_anthropic_message() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "instructions": "System instructions",- "input": "Hello",- "max_output_tokens": 64,- "temperature": 0.2,- "top_p": 0.9,- "metadata": {"trace": "abc"},- }- )-- assert payload["model"] == "nvidia_nim/test-model"- assert payload["system"] == "System instructions"- assert payload["messages"] == [{"role": "user", "content": "Hello"}]- assert payload["max_tokens"] == 64- assert payload["temperature"] == 0.2- assert payload["top_p"] == 0.9- assert payload["metadata"] == {"trace": "abc"}--[email protected]("effort", ["none", "low", "medium", "high", "xhigh"])-def test_responses_reasoning_effort_is_preserved_for_application_policy(- effort: str,-) -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": "Hello",- "reasoning": {"effort": effort},- }- )-- assert payload["output_config"] == {"effort": effort}- assert "thinking" not in payload---def test_responses_messages_tools_and_tool_results_convert() -> None:- payload = _to_anthropic_payload(- {- "model": "deepseek/deepseek-chat",- "input": [- {- "type": "message",- "role": "developer",- "content": [{"type": "input_text", "text": "Developer rules"}],- },- {- "type": "message",- "role": "user",- "content": [{"type": "input_text", "text": "Use the tool"}],- },- {- "type": "function_call",- "call_id": "call_1",- "name": "echo",- "arguments": '{"value":"FCC"}',- },- {- "type": "function_call_output",- "call_id": "call_1",- "output": "FCC",- },- ],- "tools": [- {- "type": "function",- "name": "echo",- "description": "Echo a value",- "parameters": {- "type": "object",- "properties": {"value": {"type": "string"}},- },- }- ],- "tool_choice": {"type": "function", "name": "echo"},- }- )-- assert payload["system"] == "Developer rules"- assert payload["messages"] == [- {"role": "user", "content": [{"type": "text", "text": "Use the tool"}]},- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "call_1",- "name": "echo",- "input": {"value": "FCC"},- }- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_1",- "content": "FCC",- }- ],- },- ]- assert payload["tools"] == [- {- "name": "echo",- "description": "Echo a value",- "input_schema": {- "type": "object",- "properties": {"value": {"type": "string"}},- },- }- ]- assert payload["tool_choice"] == {"type": "tool", "name": "echo"}---def test_responses_tool_choice_none_disables_forwarded_tools() -> None:- payload = _to_anthropic_payload(- {- "model": "deepseek/deepseek-chat",- "input": "Reply without tools",- "tools": [- {- "type": "function",- "name": "echo",- "parameters": {- "type": "object",- "properties": {"value": {"type": "string"}},- },- }- ],- "tool_choice": "none",- }- )-- assert "tools" not in payload- assert "tool_choice" not in payload---def test_responses_namespace_tools_flatten_for_anthropic() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": "Use JS",- "tools": [- {- "type": "namespace",- "name": "mcp__node_repl",- "description": "Node tools",- "tools": [- {- "type": "function",- "name": "js",- "description": "Run JavaScript",- "parameters": {- "type": "object",- "properties": {"code": {"type": "string"}},- "required": ["code"],- },- }- ],- }- ],- "tool_choice": {- "type": "function",- "namespace": "mcp__node_repl",- "name": "js",- },- }- )-- assert payload["tools"] == [- {- "name": "mcp__node_repl__js",- "description": "Run JavaScript",- "input_schema": {- "type": "object",- "properties": {"code": {"type": "string"}},- "required": ["code"],- },- }- ]- assert payload["tool_choice"] == {"type": "tool", "name": "mcp__node_repl__js"}---def test_responses_namespaced_tool_choice_type_tool_flattens_for_anthropic() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": "Use JS",- "tools": [- {- "type": "namespace",- "name": "mcp__node_repl",- "tools": [- {- "type": "function",- "name": "js",- "parameters": {"type": "object", "properties": {}},- }- ],- }- ],- "tool_choice": {- "type": "tool",- "namespace": "mcp__node_repl",- "name": "js",- },- }- )-- assert payload["tool_choice"] == {"type": "tool", "name": "mcp__node_repl__js"}---def test_responses_custom_tool_converts_to_anthropic_string_tool() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": "Use apply_patch",- "tools": [- {- "type": "custom",- "name": "apply_patch",- "description": "Apply a repo patch",- "format": {- "type": "grammar",- "syntax": "lark",- "definition": "start: /.+/",- },- }- ],- "tool_choice": {"type": "custom", "name": "apply_patch"},- }- )-- assert payload["tools"] == [- {- "name": "apply_patch",- "description": (- "Apply a repo patch\n\n"- "Custom tool input format: grammar (lark): start: /.+/"- ),- "input_schema": {- "type": "object",- "properties": {- "input": {- "type": "string",- "description": "Free-form input for the custom tool.",- }- },- "required": ["input"],- },- }- ]- assert payload["tool_choice"] == {"type": "tool", "name": "apply_patch"}---def test_responses_namespaced_custom_tool_flattens_for_anthropic() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": "Use shell",- "tools": [- {- "type": "namespace",- "name": "mcp__shell",- "tools": [- {- "type": "custom",- "name": "exec",- "description": "Run shell text",- "format": {"type": "text"},- }- ],- }- ],- "tool_choice": {- "type": "custom",- "namespace": "mcp__shell",- "custom": {"name": "exec"},- },- }- )-- assert payload["tools"][0]["name"] == "mcp__shell__exec"- assert payload["tools"][0]["description"] == (- "Run shell text\n\nCustom tool input format: unconstrained text."- )- assert payload["tool_choice"] == {"type": "tool", "name": "mcp__shell__exec"}---def test_responses_passive_codex_built_in_tools_are_ignored() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": "Hello",- "tools": [- {"type": "web_search", "external_web_access": True},- {"type": "image_generation", "output_format": "png"},- {"type": "tool_search"},- {- "type": "function",- "name": "echo",- "parameters": {"type": "object", "properties": {}},- },- ],- }- )-- assert payload["tools"] == [- {"name": "echo", "input_schema": {"type": "object", "properties": {}}}- ]---def test_responses_namespaced_prior_function_call_flattens_tool_use_name() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {- "type": "function_call",- "call_id": "call_1",- "namespace": "mcp__node_repl",- "name": "js",- "arguments": '{"code":"1+1"}',- },- {- "type": "function_call_output",- "call_id": "call_1",- "output": "2",- },- ],- }- )-- assert payload["messages"][0]["content"][0]["name"] == "mcp__node_repl__js"---def test_responses_prior_custom_tool_call_flattens_tool_use_name() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {- "type": "custom_tool_call",- "call_id": "call_1",- "namespace": "mcp__shell",- "name": "exec",- "input": "printf FCC",- },- {- "type": "custom_tool_call_output",- "call_id": "call_1",- "output": "FCC",- },- ],- }- )-- assert payload["messages"] == [- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "call_1",- "name": "mcp__shell__exec",- "input": {"input": "printf FCC"},- }- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_1",- "content": "FCC",- }- ],- },- ]---def test_responses_groups_consecutive_prior_tool_calls() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {- "type": "function_call",- "call_id": "call_1",- "name": "echo",- "arguments": '{"value":"FCC"}',- },- {- "type": "custom_tool_call",- "call_id": "call_2",- "name": "apply_patch",- "input": "*** Begin Patch",- },- ],- }- )-- assert payload["messages"] == [- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "call_1",- "name": "echo",- "input": {"value": "FCC"},- },- {- "type": "tool_use",- "id": "call_2",- "name": "apply_patch",- "input": {"input": "*** Begin Patch"},- },- ],- }- ]---def test_responses_groups_consecutive_prior_tool_outputs() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {- "type": "function_call",- "call_id": "call_1",- "name": "echo",- "arguments": '{"value":"FCC"}',- },- {- "type": "function_call",- "call_id": "call_2",- "name": "echo",- "arguments": '{"value":"Codex"}',- },- {- "type": "function_call_output",- "call_id": "call_1",- "output": "FCC",- },- {- "type": "function_call_output",- "call_id": "call_2",- "output": "Codex",- },- ],- }- )-- assert len(payload["messages"]) == 2- assert payload["messages"][0]["role"] == "assistant"- assert len(payload["messages"][0]["content"]) == 2- assert payload["messages"][1] == {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_1",- "content": "FCC",- },- {- "type": "tool_result",- "tool_use_id": "call_2",- "content": "Codex",- },- ],- }---def test_responses_reasoning_between_tool_call_and_output_attaches_to_tool_message() -> (- None-):- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {- "type": "function_call",- "call_id": "call_1",- "name": "echo",- "arguments": '{"value":"FCC"}',- },- {- "type": "reasoning",- "content": [{"type": "reasoning_text", "text": "Need the result."}],- },- {- "type": "function_call_output",- "call_id": "call_1",- "output": "FCC",- },- ],- }- )-- assert payload["messages"][0]["reasoning_content"] == "Need the result."- assert payload["messages"][0]["content"][0]["id"] == "call_1"- assert payload["messages"][1]["content"][0]["tool_use_id"] == "call_1"---def test_responses_encrypted_reasoning_attaches_before_tool_call() -> None:- payload = _to_anthropic_payload(- {- "model": "openai/gpt-test",- "input": [- {- "type": "reasoning",- "summary": [{"type": "summary_text", "text": "Need the result."}],- "encrypted_content": "opaque-reasoning",- },- {- "type": "function_call",- "call_id": "call_1",- "name": "echo",- "arguments": '{"value":"FCC"}',- },- {- "type": "function_call_output",- "call_id": "call_1",- "output": "FCC",- },- ],- }- )-- assistant = payload["messages"][0]- assert assistant["reasoning_content"] == "Need the result."- assert assistant["content"] == [- {"type": "redacted_thinking", "data": "opaque-reasoning"},- {- "type": "tool_use",- "id": "call_1",- "name": "echo",- "input": {"value": "FCC"},- },- ]- assert payload["messages"][1]["content"][0]["tool_use_id"] == "call_1"---def test_responses_empty_reasoning_attaches_to_prior_tool_call() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {- "type": "function_call",- "call_id": "call_1",- "name": "echo",- "arguments": '{"value":"FCC"}',- },- {- "type": "reasoning",- "content": [{"type": "reasoning_text", "text": ""}],- },- {- "type": "function_call_output",- "call_id": "call_1",- "output": "FCC",- },- ],- }- )-- assert payload["messages"][0]["reasoning_content"] == ""---def test_responses_unsupported_tool_type_is_clear() -> None:- with pytest.raises(_CONVERSION_ERROR, match="Unsupported Responses tool type"):- _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": "Hello",- "tools": [{"type": "web_search_preview"}],- }- )---def test_responses_malformed_prior_function_call_is_quarantined() -> None:- payload = _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {"role": "user", "content": "hello"},- {- "type": "function_call",- "call_id": "call_bad",- "name": "echo",- "arguments": "{",- },- {- "type": "function_call_output",- "call_id": "call_bad",- "output": "stale output",- },- {- "type": "function_call",- "call_id": "call_good",- "name": "echo",- "arguments": '{"value":"ok"}',- },- {- "type": "function_call_output",- "call_id": "call_good",- "output": "ok",- },- {"role": "user", "content": "continue"},- ],- }- )-- assert payload["messages"] == [- {"role": "user", "content": "hello"},- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "call_good",- "name": "echo",- "input": {"value": "ok"},- }- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_good",- "content": "ok",- }- ],- },- {"role": "user", "content": "continue"},- ]---def test_responses_malformed_only_function_call_still_has_no_routable_message() -> None:- with pytest.raises(_CONVERSION_ERROR, match="must contain a message"):- _to_anthropic_payload(- {- "model": "nvidia_nim/test-model",- "input": [- {- "type": "function_call",- "call_id": "call_bad",- "name": "echo",- "arguments": "{",- },- {- "type": "function_call_output",- "call_id": "call_bad",- "output": "stale output",- },- ],- }- )diff --git a/tests/core/openai_responses/test_native.py b/tests/core/openai_responses/test_native.pynew file mode 100644index 00000000..48926e6d--- /dev/null+++ b/tests/core/openai_responses/test_native.py@@ -0,0 +1,229 @@+import json++import pytest++from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.openai_responses.native import (+ NativeResponsesRelay,+ build_native_responses_request,+)+from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+++def _event_payload(frame: str) -> tuple[str, dict[str, object]]:+ lines = frame.splitlines()+ return lines[0].removeprefix("event: "), json.loads(lines[1].removeprefix("data: "))+++def test_native_request_preserves_extensions_and_forces_stateless_streaming() -> None:+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "gateway-model",+ "input": [{"role": "user", "content": "hello"}],+ "instructions": "be concise",+ "stream": False,+ "store": True,+ "previous_response_id": "resp_previous",+ "metadata": {"source": "codex"},+ "future_option": {"enabled": True},+ }+ )++ body = build_native_responses_request(+ request,+ model="upstream-model",+ reasoning=ReasoningPolicy.provider_default(),+ )++ assert body == {+ "model": "upstream-model",+ "input": [{"role": "user", "content": "hello"}],+ "instructions": "be concise",+ "stream": True,+ "store": False,+ "metadata": {"source": "codex"},+ "future_option": {"enabled": True},+ }+ assert request.model == "gateway-model"+ assert request.previous_response_id == "resp_previous"+++def test_native_request_preserves_reasoning_when_fcc_did_not_override_it() -> None:+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "gateway-model",+ "input": "hello",+ "reasoning": {+ "effort": "high",+ "summary": "detailed",+ "future_hint": True,+ },+ }+ )++ body = build_native_responses_request(+ request,+ model="upstream-model",+ reasoning=ReasoningPolicy(+ effort=ReasoningEffort.HIGH,+ ),+ )++ assert body["reasoning"] == {+ "effort": "high",+ "summary": "detailed",+ "future_hint": True,+ }+++ ("reasoning", "expected"),+ (+ (ReasoningPolicy.off(), {"effort": "none"}),+ (+ ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),+ {"effort": "xhigh", "summary": "auto"},+ ),+ ),+)+def test_native_request_applies_fcc_reasoning_override(+ reasoning: ReasoningPolicy,+ expected: dict[str, str],+) -> None:+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "gateway-model",+ "input": "hello",+ "reasoning": {"effort": "low", "summary": "detailed"},+ }+ )++ body = build_native_responses_request(+ request,+ model="upstream-model",+ reasoning=reasoning,+ )++ assert body["reasoning"] == expected+++def test_native_relay_preserves_payload_and_rewrites_only_response_model() -> None:+ relay = NativeResponsesRelay(public_model="gateway-model")+ created = {+ "type": "response.created",+ "sequence_number": 7,+ "response": {+ "id": "resp_upstream",+ "model": "upstream-model",+ "status": "in_progress",+ "output": [],+ "future_field": {"kept": True},+ },+ }+ item = {+ "type": "response.output_item.added",+ "sequence_number": 8,+ "output_index": 0,+ "item": {+ "id": "item_upstream",+ "type": "hosted_tool_call",+ "call_id": "call_upstream",+ "status": "in_progress",+ },+ }+ completed = {+ "type": "response.completed",+ "sequence_number": 9,+ "response": {+ "id": "resp_upstream",+ "model": "upstream-model",+ "status": "completed",+ "output": [item["item"]],+ "usage": {"input_tokens": 11, "output_tokens": 4, "total_tokens": 15},+ },+ }++ frames = [+ relay.feed("response.created", created),+ relay.feed("response.output_item.added", item),+ relay.feed("response.completed", completed),+ ]++ event_types_and_payloads = [_event_payload(frame) for frame in frames]+ assert [event_type for event_type, _ in event_types_and_payloads] == [+ "response.created",+ "response.output_item.added",+ "response.completed",+ ]+ assert event_types_and_payloads[0][1]["response"] == {+ **created["response"],+ "model": "gateway-model",+ }+ assert event_types_and_payloads[1][1] == item+ assert event_types_and_payloads[2][1]["response"] == {+ **completed["response"],+ "model": "gateway-model",+ }+ assert created["response"]["model"] == "upstream-model"+ assert relay.response_id == "resp_upstream"+ assert relay.terminal_type == "response.completed"+++def test_native_relay_rejects_events_after_one_terminal() -> None:+ relay = NativeResponsesRelay(public_model="gateway-model")+ relay.feed(+ "response.incomplete",+ {+ "type": "response.incomplete",+ "response": {"id": "resp_upstream", "model": "upstream-model"},+ },+ )++ with pytest.raises(ValueError, match="after terminal"):+ relay.feed(+ "response.completed",+ {+ "type": "response.completed",+ "response": {"id": "resp_upstream", "model": "upstream-model"},+ },+ )+++def test_native_relay_synthesizes_one_failed_terminal_with_public_identity() -> None:+ relay = NativeResponsesRelay(public_model="gateway-model")+ relay.feed(+ "response.created",+ {+ "type": "response.created",+ "sequence_number": 0,+ "response": {+ "id": "resp_upstream",+ "model": "upstream-model",+ "status": "in_progress",+ "output": [],+ },+ },+ )+ failure = ExecutionFailure(+ kind=FailureKind.UPSTREAM,+ status_code=502,+ message="Provider stream ended before a terminal event.",+ retryable=True,+ )++ event_type, payload = _event_payload(relay.synthesize_failure(failure))++ assert event_type == "response.failed"+ response = payload["response"]+ assert isinstance(response, dict)+ assert response["id"] == "resp_upstream"+ assert response["model"] == "gateway-model"+ assert response["status"] == "failed"+ assert response["error"] == {+ "message": "Provider stream ended before a terminal event.",+ "type": "api_error",+ "param": None,+ "code": None,+ }+ assert relay.terminal_type == "response.failed"diff --git a/tests/core/openai_responses/test_provider_input.py b/tests/core/openai_responses/test_provider_input.pyindex 5b2b7978..9ba7c778 100644--- a/tests/core/openai_responses/test_provider_input.py+++ b/tests/core/openai_responses/test_provider_input.py@@ -2,12 +2,7 @@ import jsonimport pytest-from free_claude_code.application.reasoning import client_reasoning_policyfrom free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.openai_responses import (- OpenAIResponsesAdapter,- OpenAIResponsesRequest,-)from free_claude_code.core.openai_responses.errors import ResponsesConversionErrorfrom free_claude_code.core.openai_responses.provider_input import (build_responses_provider_request,@@ -393,78 +388,6 @@ def test_responses_provider_request_uses_one_portable_tool_alias() -> None:assert request.model_dump() == snapshot-def test_responses_round_trip_preserves_encrypted_reasoning_and_tool_ids() -> None:- adapter = OpenAIResponsesAdapter()- ingress = OpenAIResponsesRequest.model_validate(- {- "model": "openai/gpt-test",- "input": [- {- "type": "reasoning",- "summary": [{"type": "summary_text", "text": "Use a tool."}],- "encrypted_content": "opaque-reasoning",- },- {- "type": "function_call",- "call_id": "call_stable",- "name": "lookup",- "arguments": '{"q":"value"}',- },- {- "type": "function_call_output",- "call_id": "call_stable",- "output": "done",- },- ],- }- )- anthropic = MessagesRequest.model_validate(adapter.to_anthropic_payload(ingress))-- body = build_responses_provider_request(- anthropic,- reasoning=ReasoningPolicy.provider_default(),- )-- assert body["input"][:3] == [- {- "type": "reasoning",- "summary": [{"type": "summary_text", "text": "Use a tool."}],- "encrypted_content": "opaque-reasoning",- },- {- "type": "function_call",- "call_id": "call_stable",- "name": "lookup",- "arguments": '{"q":"value"}',- },- {- "type": "function_call_output",- "call_id": "call_stable",- "output": "done",- },- ]---def test_responses_reasoning_round_trip_reaches_provider_request() -> None:- adapter = OpenAIResponsesAdapter()- ingress = OpenAIResponsesRequest.model_validate(- {- "model": "openai/gpt-test",- "input": "hello",- "reasoning": {"effort": "high"},- }- )- anthropic = MessagesRequest.model_validate(adapter.to_anthropic_payload(ingress))-- body = build_responses_provider_request(- anthropic,- reasoning=client_reasoning_policy(anthropic),- )-- assert body["reasoning"] == {"effort": "high", "summary": "auto"}- assert "output_config" not in body--@pytest.mark.parametrize(("field", "value"),[diff --git a/tests/core/openai_responses/test_provider_stream.py b/tests/core/openai_responses/test_provider_stream.pyindex 53a2b12f..7dfebd55 100644--- a/tests/core/openai_responses/test_provider_stream.py+++ b/tests/core/openai_responses/test_provider_stream.py@@ -1,6 +1,5 @@import pytest-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.anthropic.stream_contracts import (assert_anthropic_stream_contract,parse_sse_text,@@ -10,6 +9,7 @@ from free_claude_code.core.openai_responses.provider_stream import (ResponsesProviderStream,ResponsesStreamFailure,)+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecdef test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() -> None:diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.pydeleted file mode 100644index a4419512..00000000--- a/tests/core/openai_responses/test_sse.py+++ /dev/null@@ -1,1091 +0,0 @@-from collections.abc import AsyncIterator-from typing import Any-from unittest.mock import patch--import pytest--from free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.core.anthropic.streaming import format_sse_event-from free_claude_code.core.async_iterators import AsyncCloseable-from free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.openai_responses import (- OpenAIResponsesAdapter,- OpenAIResponsesRequest,-)-from free_claude_code.core.openai_responses.anthropic_sse import (- AnthropicSseEvent,- iter_sse_events,-)--_ADAPTER = OpenAIResponsesAdapter()---class _CloseTrackingAsyncIterator:- def __init__(- self,- values: list[Any],- *,- iteration_error: Exception | None = None,- close_error: Exception | None = None,- ) -> None:- self._values = iter(values)- self._iteration_error = iteration_error- self._close_error = close_error- self.close_calls = 0-- def __aiter__(self) -> _CloseTrackingAsyncIterator:- return self-- async def __anext__(self) -> Any:- try:- return next(self._values)- except StopIteration:- if self._iteration_error is not None:- error = self._iteration_error- self._iteration_error = None- raise error from None- raise StopAsyncIteration from None-- async def aclose(self) -> None:- self.close_calls += 1- if self._close_error is not None:- raise self._close_error---def _responses_sse(- chunks: AsyncIterator[str], request: dict[str, Any]-) -> AsyncIterator[str]:- return _ADAPTER.iter_sse_from_anthropic(- chunks,- OpenAIResponsesRequest.model_validate(request),- )---async def test_anthropic_sse_parser_closes_source_after_normal_completion() -> None:- source = _CloseTrackingAsyncIterator(- [format_sse_event("message_start", {"type": "message_start"})]- )-- events = [event async for event in iter_sse_events(source)]-- assert [event.event for event in events] == ["message_start"]- assert source.close_calls == 1---async def test_anthropic_sse_parser_closes_source_on_early_close() -> None:- source = _CloseTrackingAsyncIterator(- [- format_sse_event("message_start", {"type": "message_start"}),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- )- events = iter_sse_events(source)-- assert (await anext(events)).event == "message_start"- assert isinstance(events, AsyncCloseable)- await events.aclose()-- assert source.close_calls == 1---async def test_anthropic_sse_parser_preserves_source_failure() -> None:- source_failure = RuntimeError("source failed")- source = _CloseTrackingAsyncIterator(- [],- iteration_error=source_failure,- close_error=RuntimeError("close failed"),- )-- with pytest.raises(RuntimeError) as exc_info:- [event async for event in iter_sse_events(source)]-- assert exc_info.value is source_failure- assert source.close_calls == 1---async def test_responses_transform_closes_direct_event_source_on_early_close() -> None:- events = _CloseTrackingAsyncIterator(- [- AnthropicSseEvent(- event="message_start",- data={"type": "message_start", "message": {}},- ),- AnthropicSseEvent(- event="message_stop",- data={"type": "message_stop"},- ),- ]- )- with patch(- "free_claude_code.core.openai_responses.stream.iter_sse_events",- return_value=events,- ):- stream = _responses_sse(- _aiter([]),- {"model": "nvidia_nim/test-model", "stream": True},- )- assert parse_sse_text(await anext(stream))[0].event == "response.created"- assert isinstance(stream, AsyncCloseable)- await stream.aclose()-- assert events.close_calls == 1---async def test_responses_transform_preserves_direct_source_failure() -> None:- source_failure = RuntimeError("event source failed")- events = _CloseTrackingAsyncIterator(- [],- iteration_error=source_failure,- close_error=RuntimeError("event close failed"),- )- with (- patch(- "free_claude_code.core.openai_responses.stream.iter_sse_events",- return_value=events,- ),- pytest.raises(RuntimeError) as exc_info,- ):- [- chunk- async for chunk in _responses_sse(- _aiter([]),- {"model": "nvidia_nim/test-model", "stream": True},- )- ]-- assert exc_info.value is source_failure- assert events.close_calls == 1---async def test_anthropic_text_stream_converts_to_responses_sse() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_text_stream("Hello Codex")),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- event_names = [event.event for event in events]- assert [event.data["sequence_number"] for event in events] == list(- range(len(events))- )- assert event_names[:3] == [- "response.created",- "response.output_item.added",- "response.content_part.added",- ]- assert "response.output_text.delta" in event_names- assert events[-1].event == "response.completed"- completed = events[-1].data["response"]- assert completed["output"][0]["content"][0]["text"] == "Hello Codex"- assert completed["parallel_tool_calls"] is True- assert completed["tool_choice"] == "auto"---async def test_max_tokens_stop_reason_converts_to_response_incomplete() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_text_stream("partial output", stop_reason="max_tokens")),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[-1].event == "response.incomplete"- assert "response.completed" not in [event.event for event in events]- incomplete = events[-1].data["response"]- assert incomplete["id"] == events[0].data["response"]["id"]- assert incomplete["status"] == "incomplete"- assert incomplete["incomplete_details"] == {"reason": "max_output_tokens"}- assert incomplete["error"] is None- assert incomplete["output"][0]["content"][0]["text"] == "partial output"- assert incomplete["usage"] == {- "input_tokens": 3,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens": 4,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 7,- }---async def test_max_tokens_without_visible_output_is_still_incomplete() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(- [- format_sse_event(- "message_start", {"type": "message_start", "message": {}}- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "max_tokens"},- "usage": {"input_tokens": 3, "output_tokens": 64},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- ),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- incomplete = parse_sse_text(text)[-1]- assert incomplete.event == "response.incomplete"- assert incomplete.data["response"]["output"] == []- assert incomplete.data["response"]["incomplete_details"] == {- "reason": "max_output_tokens"- }---async def test_response_payload_preserves_explicit_request_options() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_text_stream("done")),- {- "model": "nvidia_nim/test-model",- "parallel_tool_calls": False,- "tool_choice": "none",- "temperature": 0.0,- "top_p": 0.0,- "max_output_tokens": 0,- },- )-- assert response["parallel_tool_calls"] is False- assert response["tool_choice"] == "none"- assert response["temperature"] == 0.0- assert response["top_p"] == 0.0- assert response["max_output_tokens"] == 0---async def test_response_payload_maps_explicit_null_options_to_wire_defaults() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_text_stream("done")),- {- "model": "nvidia_nim/test-model",- "parallel_tool_calls": None,- "tool_choice": None,- },- )-- assert response["parallel_tool_calls"] is True- assert response["tool_choice"] == "auto"---async def test_anthropic_tool_stream_converts_to_function_call_item() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_tool_stream()),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- names = [event.event for event in events]- assert "response.function_call_arguments.delta" in names- assert "response.function_call_arguments.done" in names- completed = events[-1].data["response"]- function_call = completed["output"][0]- assert function_call["type"] == "function_call"- assert function_call["call_id"] == "toolu_1"- assert function_call["name"] == "echo"- assert function_call["arguments"] == '{"value":"FCC"}'---async def test_anthropic_function_tool_arguments_are_normalized() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_tool_stream(partial_json='{ "value" : "FCC" }')),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["output"][0]["arguments"] == '{"value":"FCC"}'---async def test_anthropic_malformed_function_tool_arguments_fail_response() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_tool_stream(partial_json='{"value":"FCC" "bad"}')),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[-1].event == "response.failed"- assert "response.function_call_arguments.done" not in [- event.event for event in events- ]- assert "response.output_item.done" not in [event.event for event in events]- failed = events[-1].data["response"]- assert failed["status"] == "failed"- assert failed["output"] == []- assert failed["error"]["type"] == "api_error"- assert "replay-unsafe Responses output" in failed["error"]["message"]---async def test_anthropic_malformed_function_tool_arguments_fail_on_eof() -> None:- stream = _anthropic_tool_stream(- partial_json='{"value":"FCC" "bad"}',- include_block_stop=False,- )- text = await _collect_sse(- _responses_sse(- _aiter(stream[:-1]),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[-1].event == "response.failed"- assert events[-1].data["response"]["output"] == []---async def test_provider_failure_outranks_provisional_incomplete_function_call() -> None:- failure = ExecutionFailure(- kind=FailureKind.RATE_LIMIT,- status_code=429,- message="provider is busy\n\nRequest ID: req_failure_precedence",- retryable=True,- )- incomplete_tool = _anthropic_tool_stream(partial_json='{"value":')[:4]-- text = await _collect_sse(- _responses_sse(- _aiter_then_raise(incomplete_tool, failure),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert [event.event for event in events].count("response.failed") == 1- assert events[-1].event == "response.failed"- failed = events[-1].data["response"]- assert failed["id"] == events[0].data["response"]["id"]- assert failed["error"] == {- "message": "provider is busy\n\nRequest ID: req_failure_precedence",- "type": "rate_limit_error",- "param": None,- "code": None,- }---async def test_post_start_failure_observer_runs_before_terminal_failure_event() -> None:- failure = RuntimeError("socket closed")- timeline: list[tuple[str, object]] = []-- def observe_terminal_failure(exc: BaseException) -> None:- timeline.append(("observed", exc))-- stream = _ADAPTER.iter_sse_from_anthropic(- _aiter_then_raise(_anthropic_text_stream("partial")[:3], failure),- OpenAIResponsesRequest.model_validate(- {"model": "nvidia_nim/test-model", "stream": True}- ),- on_post_start_terminal_failure=observe_terminal_failure,- )- parts: list[str] = []- async for chunk in stream:- parts.append(chunk)- event = parse_sse_text(chunk)- assert len(event) == 1- timeline.append(("emitted", event[0].event))-- events = parse_sse_text("".join(parts))- assert timeline.count(("observed", failure)) == 1- assert timeline.index(("observed", failure)) < timeline.index(- ("emitted", "response.failed")- )- assert events[-1].data["response"]["error"]["message"] == "socket closed"---async def test_unrelated_post_start_exception_group_remains_unexpected() -> None:- grouped = ExceptionGroup("stream failed", [RuntimeError("socket closed")])- observed: list[BaseException] = []- stream = _ADAPTER.iter_sse_from_anthropic(- _aiter_then_raise(_anthropic_text_stream("partial")[:3], grouped),- OpenAIResponsesRequest.model_validate(- {"model": "nvidia_nim/test-model", "stream": True}- ),- on_post_start_terminal_failure=observed.append,- )-- events = parse_sse_text(await _collect_sse(stream))-- assert observed == [grouped]- assert events[-1].event == "response.failed"- assert events[-1].data["response"]["error"]["type"] == "api_error"---async def test_namespaced_anthropic_tool_stream_restores_responses_namespace() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_tool_stream(tool_name="mcp__node_repl__js")),- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [- {- "type": "namespace",- "name": "mcp__node_repl",- "tools": [- {- "type": "function",- "name": "js",- "parameters": {"type": "object", "properties": {}},- }- ],- }- ],- },- )- )-- events = parse_sse_text(text)- completed = events[-1].data["response"]- function_call = completed["output"][0]- assert function_call["type"] == "function_call"- assert function_call["namespace"] == "mcp__node_repl"- assert function_call["name"] == "js"---async def test_anthropic_custom_tool_stream_converts_to_custom_tool_call() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(- _anthropic_tool_stream(- tool_name="apply_patch",- partial_json='{"input":"*** Begin Patch"}',- )- ),- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [- {- "type": "custom",- "name": "apply_patch",- "format": {"type": "text"},- }- ],- },- )- )-- events = parse_sse_text(text)- names = [event.event for event in events]- assert "response.custom_tool_call_input.delta" in names- assert "response.custom_tool_call_input.done" in names- assert "response.function_call_arguments.delta" not in names- completed = events[-1].data["response"]- custom_call = completed["output"][0]- assert custom_call["type"] == "custom_tool_call"- assert custom_call["call_id"] == "toolu_1"- assert custom_call["name"] == "apply_patch"- assert custom_call["input"] == "*** Begin Patch"---async def test_custom_tool_input_remains_free_form_when_not_json() -> None:- response = await _completed_response_from_sse(- _aiter(- _anthropic_tool_stream(- tool_name="apply_patch",- partial_json="*** Begin Patch",- )- ),- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [{"type": "custom", "name": "apply_patch"}],- },- )-- custom_call = response["output"][0]- assert custom_call["type"] == "custom_tool_call"- assert custom_call["input"] == "*** Begin Patch"---async def test_anthropic_error_stream_converts_to_response_failed_event() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(- [- format_sse_event(- "error",- {- "type": "error",- "error": {- "type": "api_error",- "message": "upstream failed",- },- },- )- ]- ),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[0].event == "response.created"- assert events[1].event == "response.failed"- failed = events[1].data["response"]- assert failed["status"] == "failed"- assert failed["error"]["message"] == "upstream failed"---async def test_split_usage_deltas_sum_latest_anthropic_input_categories() -> None:- response = await _completed_response_from_sse(- _aiter(- [- *_anthropic_text_stream("usage")[:-2],- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn"},- "usage": {- "input_tokens": 20,- "cache_creation_input_tokens": 5,- "cache_read_input_tokens": 10,- },- },- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {},- "usage": {- "cache_read_input_tokens": 11,- "output_tokens": 7,- },- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 36,- "input_tokens_details": {"cached_tokens": 11},- "output_tokens": 7,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 43,- }- assert "stop_reason" not in response---async def test_usage_ignores_invalid_anthropic_input_categories() -> None:- response = await _completed_response_from_sse(- _aiter(- [- *_anthropic_text_stream("usage")[:-2],- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn"},- "usage": {- "input_tokens": 20,- "cache_creation_input_tokens": 5,- "cache_read_input_tokens": 10,- },- },- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {},- "usage": {- "input_tokens": -1,- "cache_creation_input_tokens": -2,- "cache_read_input_tokens": True,- "output_tokens": 7,- },- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 35,- "input_tokens_details": {"cached_tokens": 10},- "output_tokens": 7,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 42,- }---async def test_reasoning_stream_reports_reasoning_usage_detail() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_reasoning_stream("inspect the code before answering")),- {"model": "nvidia_nim/test-model", "stream": True},- )-- usage = response["usage"]- assert usage["input_tokens"] == 3- assert usage["output_tokens"] == 20- assert usage["total_tokens"] == 23- assert usage["output_tokens_details"]["reasoning_tokens"] > 0---async def test_reasoning_usage_detail_is_capped_at_output_tokens() -> None:- response = await _completed_response_from_sse(- _aiter(- _anthropic_reasoning_stream(- "this reasoning text is intentionally long enough to exceed one token",- output_tokens=1,- )- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"]["output_tokens"] == 1- assert response["usage"]["output_tokens_details"]["reasoning_tokens"] == 1---async def test_reasoning_usage_detail_reports_zero_capped_count() -> None:- response = await _completed_response_from_sse(- _aiter(- _anthropic_reasoning_stream(- "reasoning text exists without reported output tokens",- output_tokens=None,- )- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 3,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens": 0,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 3,- }---async def test_text_only_usage_reports_zero_reasoning_usage_detail() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_text_stream("plain text only")),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 3,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens": 4,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 7,- }--- ("request_payload", "tool_name", "partial_json", "expected_type", "expected_field"),- [- (- {"model": "nvidia_nim/test-model", "stream": True},- "echo",- '{"value":"FCC"}',- "function_call",- ("arguments", '{"value":"FCC"}'),- ),- (- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [{"type": "custom", "name": "apply_patch"}],- },- "apply_patch",- '{"input":"*** Begin Patch"}',- "custom_tool_call",- ("input", "*** Begin Patch"),- ),- ],-)-async def test_pending_tool_blocks_flush_on_message_stop_and_eof(- request_payload: dict[str, object],- tool_name: str,- partial_json: str,- expected_type: str,- expected_field: tuple[str, str],-) -> None:- stream = _anthropic_tool_stream(- tool_name=tool_name, partial_json=partial_json, include_block_stop=False- )- message_stop_response = await _completed_response_from_sse(- _aiter(stream), request_payload- )- eof_response = await _completed_response_from_sse(- _aiter(stream[:-1]), request_payload- )-- for response in (message_stop_response, eof_response):- call = response["output"][0]- assert call["type"] == expected_type- assert call[expected_field[0]] == expected_field[1]---async def test_overlapping_text_and_tool_blocks_keep_reserved_output_indexes() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_overlapping_text_tool_stream()),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- item_events = [- (event.event, event.data["output_index"])- for event in events- if event.event in {"response.output_item.added", "response.output_item.done"}- ]- assert item_events == [- ("response.output_item.added", 0),- ("response.output_item.added", 1),- ("response.output_item.done", 1),- ("response.output_item.done", 0),- ]- completed = events[-1].data["response"]- assert [item["type"] for item in completed["output"]] == [- "message",- "function_call",- ]- assert completed["output"][0]["content"][0]["text"] == "text"- assert completed["output"][1]["arguments"] == '{"value":"FCC"}'---async def test_overlapping_text_blocks_do_not_merge_content_by_index() -> None:- response = await _completed_response_from_sse(- _aiter(_overlapping_text_stream()),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert [item["content"][0]["text"] for item in response["output"]] == [- "A1-A2",- "B1-B2",- ]---async def _collect_sse(chunks: AsyncIterator[str]) -> str:- parts = [chunk async for chunk in chunks]- return "".join(parts)---async def _completed_response_from_sse(- chunks: AsyncIterator[str],- request: dict[str, object],-) -> dict[str, Any]:- text = await _collect_sse(_responses_sse(chunks, request))- events = parse_sse_text(text)- assert events[-1].event == "response.completed"- return events[-1].data["response"]---async def _aiter(chunks: list[str]) -> AsyncIterator[str]:- for chunk in chunks:- yield chunk---async def _aiter_then_raise(- chunks: list[str], failure: BaseException-) -> AsyncIterator[str]:- for chunk in chunks:- yield chunk- raise failure---def _anthropic_text_stream(text: str, *, stop_reason: str = "end_turn") -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": text},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": stop_reason, "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]---def _anthropic_tool_stream(- tool_name: str = "echo",- partial_json: str = '{"value":"FCC"}',- *,- include_block_stop: bool = True,-) -> list[str]:- chunks = [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": tool_name,- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {- "type": "input_json_delta",- "partial_json": partial_json,- },- },- ),- ]- if include_block_stop:- chunks.append(- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- )- )- chunks.extend(- [- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "tool_use", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- )- return chunks---def _anthropic_reasoning_stream(- reasoning: str,- *,- output_tokens: int | None = 20,-) -> list[str]:- usage = {"input_tokens": 3}- if output_tokens is not None:- usage["output_tokens"] = output_tokens-- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "thinking_delta", "thinking": reasoning},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": usage,- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]---def _overlapping_text_tool_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "text"},- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": "echo",- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {- "type": "input_json_delta",- "partial_json": '{"value":"FCC"}',- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "tool_use", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]---def _overlapping_text_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "A1-"},- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "B1-"},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "A2"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "B2"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]diff --git a/tests/core/openai_responses/test_tokens.py b/tests/core/openai_responses/test_tokens.pynew file mode 100644index 00000000..c2a2ba3b--- /dev/null+++ b/tests/core/openai_responses/test_tokens.py@@ -0,0 +1,66 @@+import json+from collections.abc import Mapping, Sequence++import free_claude_code.core.openai_responses.tokens as responses_tokens+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ estimate_responses_input_tokens,+)+++def test_responses_token_estimate_counts_only_input_bearing_fields() -> None:+ base = OpenAIResponsesRequest(+ model="provider/model",+ input="hello",+ instructions="be concise",+ tools=[+ {+ "type": "function",+ "name": "lookup",+ "description": "look up one value",+ "parameters": {"type": "object"},+ }+ ],+ metadata={"large-unrelated-value": "x" * 20_000},+ )+ without_metadata = base.model_copy(update={"metadata": None})++ assert estimate_responses_input_tokens(base) == (+ estimate_responses_input_tokens(without_metadata)+ )+++def test_responses_token_estimate_increases_with_input_content() -> None:+ short = OpenAIResponsesRequest(model="provider/model", input="hello")+ long = OpenAIResponsesRequest(+ model="provider/model",+ input="hello " * 1_000,+ )++ assert estimate_responses_input_tokens(short) > 0+ assert estimate_responses_input_tokens(long) > estimate_responses_input_tokens(+ short+ )+++def test_structured_estimate_never_serializes_an_unbounded_value(monkeypatch) -> None:+ original_dumps = json.dumps++ def guarded_dumps(value: object, *, ensure_ascii: bool = True) -> str:+ assert not isinstance(value, Mapping)+ assert not (isinstance(value, Sequence) and not isinstance(value, str))+ if isinstance(value, str):+ assert len(value) <= 1_000_000+ return original_dumps(value, ensure_ascii=ensure_ascii)++ monkeypatch.setattr(responses_tokens.json, "dumps", guarded_dumps)+ request = OpenAIResponsesRequest(+ model="provider/model",+ input=[+ {"role": "user", "content": "x" * 1_100_000},+ {"role": "user", "content": "must not be traversed"},+ ],+ tools=[{"type": "function", "name": "lookup"}],+ )++ assert estimate_responses_input_tokens(request) > 0diff --git a/tests/providers/test_cerebras.py b/tests/providers/test_cerebras.pyindex a1e61a71..a2a1cb0e 100644--- a/tests/providers/test_cerebras.py+++ b/tests/providers/test_cerebras.py@@ -186,7 +186,7 @@ def test_build_request_body_preserves_caller_extra_body(cerebras_provider):@pytest.mark.asyncio-async def test_stream_response_text(cerebras_provider):+async def test_stream_messages_text(cerebras_provider):"""Text content deltas are emitted as text blocks."""req = make_request()@@ -211,7 +211,7 @@ async def test_stream_response_text(cerebras_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in cerebras_provider.stream_response(req)]+ events = [event async for event in cerebras_provider.stream_messages(req)]assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -219,7 +219,7 @@ async def test_stream_response_text(cerebras_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning(cerebras_provider):+async def test_stream_messages_reasoning(cerebras_provider):"""Cerebras reasoning deltas are emitted as thinking blocks."""req = make_request()@@ -244,7 +244,7 @@ async def test_stream_response_reasoning(cerebras_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in cerebras_provider.stream_response(req)]+ events = [event async for event in cerebras_provider.stream_messages(req)]assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_cline_pass.py b/tests/providers/test_cline_pass.pyindex 726e61a5..ee8a632f 100644--- a/tests/providers/test_cline_pass.py+++ b/tests/providers/test_cline_pass.py@@ -316,7 +316,7 @@ async def test_stream_uses_upstream_sse_and_preserves_reasoning_details(event_text = "".join([event- async for event in cline_pass_provider.stream_response(+ async for event in cline_pass_provider.stream_messages(_request(),reasoning=ReasoningPolicy.on(),)diff --git a/tests/providers/test_cloudflare.py b/tests/providers/test_cloudflare.pyindex b64c4bfe..52d823ce 100644--- a/tests/providers/test_cloudflare.py+++ b/tests/providers/test_cloudflare.py@@ -225,7 +225,7 @@ async def test_stream_uses_openai_chat_completions(return_value=_stream(_chunk(delta)),) as mock_create:events = [- event async for event in cloudflare_provider.stream_response(_request())+ event async for event in cloudflare_provider.stream_messages(_request())]parsed = parse_sse_text("".join(events))@@ -256,7 +256,7 @@ async def test_stream_maps_cloudflare_reasoning_delta_to_thinking(return_value=_stream(_chunk(delta)),):events = [- event async for event in cloudflare_provider.stream_response(_request())+ event async for event in cloudflare_provider.stream_messages(_request())]parsed = parse_sse_text("".join(events))@@ -306,7 +306,7 @@ async def test_stream_maps_openai_tool_calls_to_tool_use(new_callable=AsyncMock,return_value=_stream(_chunk(delta, finish_reason="tool_calls")),):- events = [event async for event in cloudflare_provider.stream_response(request)]+ events = [event async for event in cloudflare_provider.stream_messages(request)]parsed = parse_sse_text("".join(events))assert any(diff --git a/tests/providers/test_codestral.py b/tests/providers/test_codestral.pyindex f97b5793..83b373c3 100644--- a/tests/providers/test_codestral.py+++ b/tests/providers/test_codestral.py@@ -82,7 +82,7 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():@pytest.mark.asyncio-async def test_stream_response_text(codestral_provider):+async def test_stream_messages_text(codestral_provider):"""Text content deltas are emitted as text blocks."""req = make_request()@@ -107,7 +107,7 @@ async def test_stream_response_text(codestral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in codestral_provider.stream_response(req)]+ events = [event async for event in codestral_provider.stream_messages(req)]assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -115,7 +115,7 @@ async def test_stream_response_text(codestral_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning_content(codestral_provider):+async def test_stream_messages_reasoning_content(codestral_provider):"""reasoning_content deltas are emitted as thinking blocks."""req = make_request()@@ -140,7 +140,7 @@ async def test_stream_response_reasoning_content(codestral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in codestral_provider.stream_response(req)]+ events = [event async for event in codestral_provider.stream_messages(req)]assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_cohere.py b/tests/providers/test_cohere.pyindex 14dfc4e9..040ea0c3 100644--- a/tests/providers/test_cohere.py+++ b/tests/providers/test_cohere.py@@ -185,7 +185,7 @@ def test_build_request_body_rejects_unsupported_extra_body(cohere_provider):@pytest.mark.asyncio-async def test_stream_response_text(cohere_provider):+async def test_stream_messages_text(cohere_provider):mock_chunk = MagicMock()mock_chunk.choices = [MagicMock(@@ -208,7 +208,7 @@ async def test_stream_response_text(cohere_provider):mock_create.return_value = mock_stream()events = [- event async for event in cohere_provider.stream_response(make_request())+ event async for event in cohere_provider.stream_messages(make_request())]assert any(@@ -217,7 +217,7 @@ async def test_stream_response_text(cohere_provider):@pytest.mark.asyncio-async def test_stream_response_tool_call(cohere_provider):+async def test_stream_messages_tool_call(cohere_provider):mock_tc = MagicMock()mock_tc.index = 0mock_tc.id = "call_1"@@ -243,7 +243,7 @@ async def test_stream_response_tool_call(cohere_provider):mock_create.return_value = mock_stream()events = [- event async for event in cohere_provider.stream_response(make_request())+ event async for event in cohere_provider.stream_messages(make_request())]assert any(@@ -255,7 +255,7 @@ async def test_stream_response_tool_call(cohere_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning_content(cohere_provider):+async def test_stream_messages_reasoning_content(cohere_provider):mock_chunk = MagicMock()mock_chunk.choices = [MagicMock(@@ -278,7 +278,7 @@ async def test_stream_response_reasoning_content(cohere_provider):mock_create.return_value = mock_stream()events = [- event async for event in cohere_provider.stream_response(make_request())+ event async for event in cohere_provider.stream_messages(make_request())]assert any(diff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.pyindex 89e7ac20..00d40527 100644--- a/tests/providers/test_deepseek.py+++ b/tests/providers/test_deepseek.py@@ -17,6 +17,7 @@ from free_claude_code.core.anthropic.models import (Tool,)from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.openai_responses.models import OpenAIResponsesRequestfrom free_claude_code.providers.deepseek import DeepSeekProviderfrom tests.providers.support import (REASONING_OFF,@@ -57,6 +58,81 @@ def test_init(deepseek_config):assert mock_client.called+def test_responses_request_uses_deepseek_chat_policy(deepseek_provider):+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "deepseek-chat",+ "input": [+ {+ "type": "function_call",+ "call_id": "call_1",+ "name": "Read",+ "arguments": '{"file_path":"x"}',+ },+ {+ "type": "function_call_output",+ "call_id": "call_1",+ "output": "ok",+ },+ {"role": "user", "content": "Continue"},+ ],+ "tools": [+ {+ "type": "function",+ "name": "Read",+ "parameters": {+ "type": "object",+ "properties": {"file_path": {"type": "string"}},+ },+ }+ ],+ "tool_choice": {"type": "function", "name": "Read"},+ }+ )++ translated = deepseek_provider._build_responses_request_body(+ request, reasoning=REASONING_ON+ )++ assert translated.body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+ assert translated.body["tool_choice"] == "auto"+ assert translated.body["extra_body"] == {"thinking": {"type": "disabled"}}+++def test_responses_tool_history_keeps_deepseek_replayable_reasoning(+ deepseek_provider,+):+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "deepseek-chat",+ "input": [+ {+ "type": "reasoning",+ "summary": [{"type": "summary_text", "text": "Inspect first"}],+ },+ {+ "type": "function_call",+ "call_id": "call_1",+ "name": "Read",+ "arguments": '{"file_path":"x"}',+ },+ {+ "type": "function_call_output",+ "call_id": "call_1",+ "output": "ok",+ },+ ],+ }+ )++ translated = deepseek_provider._build_responses_request_body(+ request, reasoning=REASONING_ON+ )++ assert translated.body["messages"][0]["reasoning_content"] == "Inspect first"+ assert translated.body["extra_body"] == {"thinking": {"type": "enabled"}}++@pytest.mark.parametrize(("usage", "expected"),[@@ -710,7 +786,7 @@ def test_preflight_strips_user_image():admission=immediate_admission(),)# Should not raise; image is stripped.- provider.preflight_stream(request, reasoning=REASONING_ON)+ provider.preflight_messages(request, reasoning=REASONING_ON)body = provider._build_request_body(request, reasoning=reasoning_for(request))content = body["messages"][0]["content"]assert "attachment omitted" in content.lower()@@ -748,7 +824,7 @@ def test_vision_model_forwards_user_image():admission=immediate_admission(),)# Must not raise on preflight (no InvalidRequestError for image blocks).- provider.preflight_stream(request, reasoning=REASONING_ON)+ provider.preflight_messages(request, reasoning=REASONING_ON)body = provider._build_request_body(request, reasoning=reasoning_for(request))content = body["messages"][0]["content"]assert isinstance(content, list)@@ -796,7 +872,7 @@ def test_vision_model_strips_user_document():),admission=immediate_admission(),)- provider.preflight_stream(request, reasoning=REASONING_ON)+ provider.preflight_messages(request, reasoning=REASONING_ON)body = provider._build_request_body(request, reasoning=reasoning_for(request))content = body["messages"][0]["content"]assert content@@ -833,7 +909,7 @@ def test_preflight_rejects_mcp_servers():admission=immediate_admission(),)with pytest.raises(InvalidRequestError, match="mcp_servers"):- provider.preflight_stream(request)+ provider.preflight_messages(request)def test_preflight_rejects_listed_server_tools_in_tools_list():@@ -852,7 +928,7 @@ def test_preflight_rejects_listed_server_tools_in_tools_list():admission=immediate_admission(),)with pytest.raises(InvalidRequestError, match="web_search"):- provider.preflight_stream(request)+ provider.preflight_messages(request)def test_preflight_rejects_server_tool_result_blocks():@@ -889,7 +965,7 @@ def test_preflight_rejects_server_tool_result_blocks():admission=immediate_admission(),)with pytest.raises(InvalidRequestError, match=r"web_search_tool_result|server"):- provider.preflight_stream(request)+ provider.preflight_messages(request)def test_non_tool_top_level_reasoning_is_not_replayed(deepseek_provider):@@ -1081,7 +1157,7 @@ async def test_stream_uses_chat_completions_and_maps_cache_usage(deepseek_providwith patch.object(deepseek_provider._client.chat.completions, "create", create):chunks = [chunk- async for chunk in deepseek_provider.stream_response(+ async for chunk in deepseek_provider.stream_messages(request, input_tokens=7, request_id="r1")]diff --git a/tests/providers/test_execution_failure_boundary.py b/tests/providers/test_execution_failure_boundary.pyindex 434ca634..2cd19c1b 100644--- a/tests/providers/test_execution_failure_boundary.py+++ b/tests/providers/test_execution_failure_boundary.py@@ -98,7 +98,7 @@ async def test_committed_provider_failure_closes_block_then_raises_canonical_val),pytest.raises(ExecutionFailure) as exc_info,):- async for event in provider.stream_response(+ async for event in provider.stream_messages(request,request_id="req_committed_failure",):@@ -140,7 +140,7 @@ async def test_openai_stream_close_failure_cannot_mask_execution_failure() -> No):[event- async for event in provider.stream_response(+ async for event in provider.stream_messages(request,request_id="req_close_failure",)@@ -278,7 +278,7 @@ async def test_completed_stream_close_failure_preserves_success_lifecycle():emitted = [event- async for event in provider.stream_response(+ async for event in provider.stream_messages(request,request_id="req_successful_close_failure",)@@ -354,7 +354,7 @@ async def test_closing_public_openai_stream_closes_raw_stream_once() -> None:new_callable=AsyncMock,return_value=raw_stream,):- stream = provider.stream_response(request, request_id="req_early_close")+ stream = provider.stream_messages(request, request_id="req_early_close")await anext(stream)assert isinstance(stream, AsyncCloseable)await stream.aclose()diff --git a/tests/providers/test_gemini.py b/tests/providers/test_gemini.pyindex aae9a3bd..a10ec55c 100644--- a/tests/providers/test_gemini.py+++ b/tests/providers/test_gemini.py@@ -430,7 +430,7 @@ def test_build_request_body_adds_current_turn_fallback_signature(@pytest.mark.asyncio-async def test_stream_response_text(gemini_provider):+async def test_stream_messages_text(gemini_provider):req = make_request(thinking={"type": "enabled"})mock_chunk = MagicMock()@@ -456,7 +456,7 @@ async def test_stream_response_text(gemini_provider):events = [event- async for event in gemini_provider.stream_response(+ async for event in gemini_provider.stream_messages(req, reasoning=reasoning_for(req))]@@ -478,7 +478,7 @@ async def test_stream_response_text(gemini_provider):@pytest.mark.asyncio-async def test_stream_response_preserves_tool_call_extra_content(gemini_provider):+async def test_stream_messages_preserves_tool_call_extra_content(gemini_provider):req = make_request()mock_tc = MagicMock()@@ -510,7 +510,7 @@ async def test_stream_response_preserves_tool_call_extra_content(gemini_provider) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in gemini_provider.stream_response(req)]+ events = [event async for event in gemini_provider.stream_messages(req)]tool_starts = [event@@ -587,7 +587,7 @@ async def test_colliding_stream_tool_id_rekeys_cached_thought_signature(new_callable=AsyncMock,return_value=mock_stream(),):- events = [event async for event in gemini_provider.stream_response(request)]+ events = [event async for event in gemini_provider.stream_messages(request)]starts = [event.data["content_block"]@@ -641,7 +641,7 @@ async def test_colliding_stream_tool_id_rekeys_cached_thought_signature(@pytest.mark.asyncio-async def test_stream_response_reasoning_content(gemini_provider):+async def test_stream_messages_reasoning_content(gemini_provider):req = make_request()mock_chunk = MagicMock()@@ -665,7 +665,7 @@ async def test_stream_response_reasoning_content(gemini_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in gemini_provider.stream_response(req)]+ events = [event async for event in gemini_provider.stream_messages(req)]assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_github_models.py b/tests/providers/test_github_models.pyindex 3e22f76d..d1777e39 100644--- a/tests/providers/test_github_models.py+++ b/tests/providers/test_github_models.py@@ -201,7 +201,7 @@ async def test_model_list_returns_empty_set_when_no_models_support_streaming_too@pytest.mark.asyncio-async def test_stream_response_text(+async def test_stream_messages_text(github_models_provider: GitHubModelsProvider,) -> None:delta = SimpleNamespace(@@ -217,7 +217,7 @@ async def test_stream_response_text(return_value=_stream(_chunk(delta)),) as mock_create:events = [- event async for event in github_models_provider.stream_response(_request())+ event async for event in github_models_provider.stream_messages(_request())]parsed = parse_sse_text("".join(events))@@ -231,7 +231,7 @@ async def test_stream_response_text(@pytest.mark.asyncio-async def test_stream_response_tool_call(+async def test_stream_messages_tool_call(github_models_provider: GitHubModelsProvider,) -> None:tool_call = SimpleNamespace(@@ -267,7 +267,7 @@ async def test_stream_response_tool_call(return_value=_stream(_chunk(delta, finish_reason="tool_calls")),):events = [- event async for event in github_models_provider.stream_response(request)+ event async for event in github_models_provider.stream_messages(request)]parsed = parse_sse_text("".join(events))@@ -285,7 +285,7 @@ async def test_stream_response_tool_call(@pytest.mark.asyncio-async def test_stream_response_reasoning_content(+async def test_stream_messages_reasoning_content(github_models_provider: GitHubModelsProvider,) -> None:delta = SimpleNamespace(@@ -301,7 +301,7 @@ async def test_stream_response_reasoning_content(return_value=_stream(_chunk(delta)),):events = [- event async for event in github_models_provider.stream_response(_request())+ event async for event in github_models_provider.stream_messages(_request())]parsed = parse_sse_text("".join(events))diff --git a/tests/providers/test_groq.py b/tests/providers/test_groq.pyindex e85ebe2a..985dc626 100644--- a/tests/providers/test_groq.py+++ b/tests/providers/test_groq.py@@ -184,7 +184,7 @@ def test_build_request_body_preserves_caller_extra_body(groq_provider):@pytest.mark.asyncio-async def test_stream_response_text(groq_provider):+async def test_stream_messages_text(groq_provider):"""Text content deltas are emitted as text blocks."""req = make_request()@@ -209,7 +209,7 @@ async def test_stream_response_text(groq_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in groq_provider.stream_response(req)]+ events = [event async for event in groq_provider.stream_messages(req)]assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -217,7 +217,7 @@ async def test_stream_response_text(groq_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning_content(groq_provider):+async def test_stream_messages_reasoning_content(groq_provider):"""reasoning_content deltas are emitted as thinking blocks."""req = make_request()@@ -242,7 +242,7 @@ async def test_stream_response_reasoning_content(groq_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in groq_provider.stream_response(req)]+ events = [event async for event in groq_provider.stream_messages(req)]assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_groq_reasoning.py b/tests/providers/test_groq_reasoning.pyindex 7f4c63c6..6d359ac0 100644--- a/tests/providers/test_groq_reasoning.py+++ b/tests/providers/test_groq_reasoning.py@@ -707,7 +707,7 @@ async def test_reasoning_correction_emits_one_downstream_lifecycle() -> None:raw = "".join([event- async for event in provider.stream_response(+ async for event in provider.stream_messages(request,reasoning=policy,)diff --git a/tests/providers/test_huggingface.py b/tests/providers/test_huggingface.pyindex e8724366..461e9df2 100644--- a/tests/providers/test_huggingface.py+++ b/tests/providers/test_huggingface.py@@ -164,7 +164,7 @@ def test_build_request_body_does_not_replay_top_level_reasoning_content(@pytest.mark.asyncio-async def test_stream_response_text(huggingface_provider):+async def test_stream_messages_text(huggingface_provider):mock_chunk = MagicMock()mock_chunk.choices = [MagicMock(@@ -188,7 +188,7 @@ async def test_stream_response_text(huggingface_provider):events = [event- async for event in huggingface_provider.stream_response(make_request())+ async for event in huggingface_provider.stream_messages(make_request())]assert any(@@ -198,7 +198,7 @@ async def test_stream_response_text(huggingface_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning_content(huggingface_provider):+async def test_stream_messages_reasoning_content(huggingface_provider):mock_chunk = MagicMock()mock_chunk.choices = [MagicMock(@@ -222,7 +222,7 @@ async def test_stream_response_reasoning_content(huggingface_provider):events = [event- async for event in huggingface_provider.stream_response(make_request())+ async for event in huggingface_provider.stream_messages(make_request())]assert any(diff --git a/tests/providers/test_kilo.py b/tests/providers/test_kilo.pyindex f4ea054d..cd26da8f 100644--- a/tests/providers/test_kilo.py+++ b/tests/providers/test_kilo.py@@ -265,7 +265,7 @@ async def test_stream_uses_reasoning_field_without_duplicating_plain_details(return_value=stream,):event_text = "".join(- [event async for event in kilo_provider.stream_response(request)]+ [event async for event in kilo_provider.stream_messages(request)])events = parse_sse_text(event_text)@@ -306,7 +306,7 @@ async def test_stream_restarts_reasoning_reconciliation_after_early_retry(side_effect=[abandoned, recovered],) as create:event_text = "".join(- [event async for event in kilo_provider.stream_response(request)]+ [event async for event in kilo_provider.stream_messages(request)])events = parse_sse_text(event_text)@@ -348,7 +348,7 @@ async def test_stream_omits_all_reasoning_representations_when_disabled(event_text = "".join([event- async for event in kilo_provider.stream_response(+ async for event in kilo_provider.stream_messages(request,reasoning=ReasoningPolicy.off(),)diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.pyindex c432d6b4..7b9e8041 100644--- a/tests/providers/test_llamacpp.py+++ b/tests/providers/test_llamacpp.py@@ -111,7 +111,7 @@ def test_replay_is_independent_of_current_turn_reasoning_control(@pytest.mark.asyncio-async def test_stream_response_uses_shared_openai_chat_provider(+async def test_stream_messages_uses_shared_openai_chat_provider(provider: OpenAIChatProvider,) -> None:chunk = MagicMock()@@ -139,7 +139,7 @@ async def test_stream_response_uses_shared_openai_chat_provider(output = "".join([event- async for event in provider.stream_response(+ async for event in provider.stream_messages(make_messages_request(LLAMACPP_MODEL))]diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex c6694d7d..41ae4d5e 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -7,6 +7,7 @@ import pytestfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.provider_catalog import LMSTUDIO_DEFAULT_BASE+from free_claude_code.core.anthropic import get_token_countfrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.lmstudio import LMStudioProvider@@ -123,9 +124,8 @@ def test_preflight_builds_before_context_budget_and_preserves_policy(calls.append(("build", reasoning))return {}- def check_context(request_arg):- assert request_arg is request- calls.append(("context", request_arg))+ def check_context(estimate: int):+ calls.append(("context", estimate))with (patch.object(lmstudio_provider, "_build_request_body", side_effect=build),@@ -135,9 +135,12 @@ def test_preflight_builds_before_context_budget_and_preserves_policy(side_effect=check_context,),):- lmstudio_provider.preflight_stream(request, reasoning=REASONING_OFF)+ lmstudio_provider.preflight_messages(request, reasoning=REASONING_OFF)- assert calls == [("build", REASONING_OFF), ("context", request)]+ assert calls == [+ ("build", REASONING_OFF),+ ("context", get_token_count(request.messages, request.system, request.tools)),+ ]def test_preflight_conversion_failure_skips_context_budget(lmstudio_provider):@@ -153,13 +156,13 @@ def test_preflight_conversion_failure_skips_context_budget(lmstudio_provider):patch.object(lmstudio_provider, "_preflight_context_budget") as context,pytest.raises(InvalidRequestError, match="invalid request conversion"),):- lmstudio_provider.preflight_stream(request, reasoning=REASONING_ON)+ lmstudio_provider.preflight_messages(request, reasoning=REASONING_ON)context.assert_not_called()@pytest.mark.asyncio-async def test_stream_response_text(lmstudio_provider):+async def test_stream_messages_text(lmstudio_provider):"""Text content deltas are emitted through the shared OpenAI-chat provider."""req = make_request()@@ -182,7 +185,7 @@ async def test_stream_response_text(lmstudio_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in lmstudio_provider.stream_response(req)]+ events = [event async for event in lmstudio_provider.stream_messages(req)]assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -190,7 +193,7 @@ async def test_stream_response_text(lmstudio_provider):@pytest.mark.asyncio-async def test_stream_response_passes_exact_reasoning_budget_via_extra_body(+async def test_stream_messages_passes_exact_reasoning_budget_via_extra_body(lmstudio_provider,):req = make_request()@@ -218,7 +221,7 @@ async def test_stream_response_passes_exact_reasoning_budget_via_extra_body(events = [event- async for event in lmstudio_provider.stream_response(+ async for event in lmstudio_provider.stream_messages(req,reasoning=policy,)@@ -245,29 +248,22 @@ async def test_cleanup(lmstudio_provider):def test_preflight_context_budget_noop_when_context_length_unknown(lmstudio_provider):"""No LM Studio /api/v0/models data available -> preflight is a no-op (fail open)."""with patch.object(lmstudio_provider, "_loaded_context_length", return_value=None):- lmstudio_provider._preflight_context_budget(make_request()) # must not raise+ lmstudio_provider._preflight_context_budget(1) # must not raisedef test_preflight_context_budget_allows_request_under_budget(lmstudio_provider):with patch.object(lmstudio_provider, "_loaded_context_length", return_value=100_000):- req = make_request(- messages=[{"role": "user", "content": "hi"}], system=None, tools=[]- )- lmstudio_provider._preflight_context_budget(req) # must not raise+ lmstudio_provider._preflight_context_budget(1) # must not raisedef test_preflight_context_budget_rejects_request_over_90_percent(lmstudio_provider):with (patch.object(lmstudio_provider, "_loaded_context_length", return_value=1000),- patch(- "free_claude_code.providers.lmstudio.client.get_token_count",- return_value=901,- ),pytest.raises(ExecutionFailure) as exc_info,):- lmstudio_provider._preflight_context_budget(make_request())+ lmstudio_provider._preflight_context_budget(901)failure = exc_info.valueassert failure.kind is FailureKind.CONTEXT_WINDOW_EXCEEDEDdiff --git a/tests/providers/test_minimax.py b/tests/providers/test_minimax.pyindex f2c1b03c..ab5759bc 100644--- a/tests/providers/test_minimax.py+++ b/tests/providers/test_minimax.py@@ -156,7 +156,7 @@ async def test_stream_preserves_reasoning_content(minimax_provider):new_callable=AsyncMock,return_value=stream,) as create:- events = [event async for event in minimax_provider.stream_response(request)]+ events = [event async for event in minimax_provider.stream_messages(request)]parsed = parse_sse_text("".join(events))assert thinking_content(parsed) == "plan"diff --git a/tests/providers/test_mistral.py b/tests/providers/test_mistral.pyindex ba9f6efd..a9571a87 100644--- a/tests/providers/test_mistral.py+++ b/tests/providers/test_mistral.py@@ -189,7 +189,7 @@ def test_reasoning_off_keeps_replay_separate_from_new_turn_compute():@pytest.mark.asyncio-async def test_stream_response_text(mistral_provider):+async def test_stream_messages_text(mistral_provider):"""Text content deltas are emitted as text blocks."""req = make_request()@@ -214,7 +214,7 @@ async def test_stream_response_text(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -222,7 +222,7 @@ async def test_stream_response_text(mistral_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning_content(mistral_provider):+async def test_stream_messages_reasoning_content(mistral_provider):"""reasoning_content deltas are emitted as thinking blocks."""req = make_request()@@ -247,7 +247,7 @@ async def test_stream_response_reasoning_content(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]assert any('"thinking_delta"' in event and "Thinking..." in event for event in events@@ -255,7 +255,7 @@ async def test_stream_response_reasoning_content(mistral_provider):@pytest.mark.asyncio-async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):+async def test_stream_messages_native_mistral_thinking_chunk(mistral_provider):req = make_request()mock_chunk = MagicMock()@@ -284,7 +284,7 @@ async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]assert any('"thinking_delta"' in event and "Native thought." in event for event in events@@ -292,7 +292,7 @@ async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):@pytest.mark.asyncio-async def test_stream_response_native_mistral_text_chunk(mistral_provider):+async def test_stream_messages_native_mistral_text_chunk(mistral_provider):req = make_request()mock_chunk = MagicMock()@@ -316,13 +316,13 @@ async def test_stream_response_native_mistral_text_chunk(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]assert any('"text_delta"' in event and "Native text." in event for event in events)@pytest.mark.asyncio-async def test_stream_response_preserves_native_thinking_and_string_text(+async def test_stream_messages_preserves_native_thinking_and_string_text(mistral_provider,):req = make_request()@@ -350,7 +350,7 @@ async def test_stream_response_preserves_native_thinking_and_string_text() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]event_text = "\n".join(events)assert '"thinking_delta"' in event_text@@ -360,7 +360,7 @@ async def test_stream_response_preserves_native_thinking_and_string_text(@pytest.mark.asyncio-async def test_stream_response_preserves_native_reasoning_and_string_text(+async def test_stream_messages_preserves_native_reasoning_and_string_text(mistral_provider,):req = make_request()@@ -388,7 +388,7 @@ async def test_stream_response_preserves_native_reasoning_and_string_text() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]event_text = "\n".join(events)assert "Native reasoning." in event_text@@ -396,7 +396,7 @@ async def test_stream_response_preserves_native_reasoning_and_string_text(@pytest.mark.asyncio-async def test_stream_response_preserves_mixed_native_content_array(+async def test_stream_messages_preserves_mixed_native_content_array(mistral_provider,):req = make_request()@@ -428,7 +428,7 @@ async def test_stream_response_preserves_mixed_native_content_array() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]event_text = "\n".join(events)assert "Native thought." in event_text@@ -436,7 +436,7 @@ async def test_stream_response_preserves_mixed_native_content_array(@pytest.mark.asyncio-async def test_stream_response_ignores_unknown_native_content_chunks(+async def test_stream_messages_ignores_unknown_native_content_chunks(mistral_provider,):req = make_request()@@ -467,7 +467,7 @@ async def test_stream_response_ignores_unknown_native_content_chunks() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = [event async for event in mistral_provider.stream_messages(req)]event_text = "\n".join(events)assert "reference_ids" not in event_text@@ -475,7 +475,7 @@ async def test_stream_response_ignores_unknown_native_content_chunks(@pytest.mark.asyncio-async def test_stream_response_suppresses_native_mistral_thinking_when_disabled(+async def test_stream_messages_suppresses_native_mistral_thinking_when_disabled(mistral_provider,):req = make_request()@@ -509,7 +509,7 @@ async def test_stream_response_suppresses_native_mistral_thinking_when_disabled(events = [event- async for event in mistral_provider.stream_response(+ async for event in mistral_provider.stream_messages(req, reasoning=REASONING_OFF)]@@ -520,7 +520,7 @@ async def test_stream_response_suppresses_native_mistral_thinking_when_disabled(@pytest.mark.asyncio-async def test_stream_response_retries_without_mistral_reasoning_on_rejection(+async def test_stream_messages_retries_without_mistral_reasoning_on_rejection(mistral_provider,):req = make_request(@@ -574,7 +574,7 @@ async def test_stream_response_retries_without_mistral_reasoning_on_rejection(events = [e- async for e in mistral_provider.stream_response(+ async for e in mistral_provider.stream_messages(req, reasoning=reasoning_for(req))]@@ -592,7 +592,7 @@ async def test_stream_response_retries_without_mistral_reasoning_on_rejection(@pytest.mark.asyncio-async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools(+async def test_stream_messages_reasoning_retry_preserves_visible_text_and_tools(mistral_provider,):req = make_request(@@ -645,7 +645,7 @@ async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools(events = [e- async for e in mistral_provider.stream_response(+ async for e in mistral_provider.stream_messages(req, reasoning=reasoning_for(req))]@@ -657,7 +657,7 @@ async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools(@pytest.mark.asyncio-async def test_stream_response_retries_on_mistral_422_reasoning_rejection(+async def test_stream_messages_retries_on_mistral_422_reasoning_rejection(mistral_provider,):req = make_request()@@ -687,7 +687,7 @@ async def test_stream_response_retries_on_mistral_422_reasoning_rejection(events = [e- async for e in mistral_provider.stream_response(+ async for e in mistral_provider.stream_messages(req, reasoning=reasoning_for(req))]@@ -698,7 +698,7 @@ async def test_stream_response_retries_on_mistral_422_reasoning_rejection(@pytest.mark.asyncio-async def test_stream_response_retries_when_model_disables_reasoning_input(+async def test_stream_messages_retries_when_model_disables_reasoning_input(mistral_provider,):req = make_request(@@ -742,7 +742,7 @@ async def test_stream_response_retries_when_model_disables_reasoning_input() as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [e async for e in mistral_provider.stream_response(req)]+ events = [e async for e in mistral_provider.stream_messages(req)]assert mock_create.await_count == 2second_call = mock_create.await_args_list[1].kwargs@@ -752,7 +752,7 @@ async def test_stream_response_retries_when_model_disables_reasoning_input(@pytest.mark.asyncio-async def test_stream_response_unrelated_bad_request_does_not_retry(mistral_provider):+async def test_stream_messages_unrelated_bad_request_does_not_retry(mistral_provider):req = make_request()error = _make_bad_request_error("Unsupported field: top_k")@@ -762,14 +762,14 @@ async def test_stream_response_unrelated_bad_request_does_not_retry(mistral_provmock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in mistral_provider.stream_response(req)]+ [e async for e in mistral_provider.stream_messages(req)]assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@pytest.mark.asyncio-async def test_stream_response_generic_thinking_error_does_not_retry(+async def test_stream_messages_generic_thinking_error_does_not_retry(mistral_provider,):req = make_request()@@ -781,7 +781,7 @@ async def test_stream_response_generic_thinking_error_does_not_retry(mock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in mistral_provider.stream_response(req)]+ [e async for e in mistral_provider.stream_messages(req)]assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.messagediff --git a/tests/providers/test_model_discovery.py b/tests/providers/test_model_discovery.pyindex c5e3444d..8b8dcdf7 100644--- a/tests/providers/test_model_discovery.py+++ b/tests/providers/test_model_discovery.py@@ -354,7 +354,15 @@ class FakeProvider(BaseProvider):self.cleaned = Falseself.model_list_calls = 0- def preflight_stream(+ def preflight_messages(+ self,+ request: Any,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ return None++ def preflight_responses(self,request: Any,*,@@ -378,7 +386,19 @@ class FakeProvider(BaseProvider):await self._before_model_list()return self._model_infos- async def stream_response(+ async def stream_messages(+ self,+ request: Any,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> AsyncIterator[str]:+ if False:+ yield ""++ async def stream_responses(self,request: Any,input_tokens: int = 0,diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.pyindex fcd3a7d6..1bb801ff 100644--- a/tests/providers/test_nvidia_nim.py+++ b/tests/providers/test_nvidia_nim.py@@ -8,6 +8,7 @@ from httpx2 import Request, Responsefrom free_claude_code.config.nim import NimSettingsfrom free_claude_code.config.provider_catalog import NVIDIA_NIM_DEFAULT_BASEfrom free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.openai_responses.models import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.admission import UPSTREAM_TRANSIENT_TOTAL_ATTEMPTSfrom free_claude_code.providers.nvidia_nim import NvidiaNimProvider@@ -193,6 +194,59 @@ async def test_build_request_body(provider_config):assert "reasoning_budget" not in body["extra_body"]+def test_responses_request_uses_nim_chat_policy(provider_config):+ original_name = "mcp__responses__" + "x" * 80+ provider = NvidiaNimProvider(+ provider_config,+ nim_settings=NimSettings(max_tokens=64, parallel_tool_calls=False),+ admission=immediate_admission(),+ )+ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "test-model",+ "input": "Hello",+ "max_output_tokens": 128,+ "tools": [+ {+ "type": "function",+ "name": original_name,+ "parameters": {+ "type": "object",+ "properties": {"type": {"type": "string"}},+ "required": ["type"],+ },+ }+ ],+ }+ )++ translated = provider._build_responses_request_body(request, reasoning=REASONING_ON)++ body = translated.body+ tools = body["tools"]+ assert isinstance(tools, list)+ function = tools[0]["function"]+ assert isinstance(function, dict)+ wire_name = function["name"]+ assert wire_name == translated.tool_names.encode(original_name)+ assert wire_name != original_name+ assert body["max_tokens"] == 64+ assert body["top_p"] == 0.95+ assert body["parallel_tool_calls"] is False+ assert body[NIM_TOOL_ARGUMENT_ALIASES_KEY] == {+ original_name: {"_fcc_arg_type": "type"}+ }+ parameters = function["parameters"]+ assert isinstance(parameters, dict)+ assert parameters["properties"] == {"_fcc_arg_type": {"type": "string"}}+ extra_body = body["extra_body"]+ assert isinstance(extra_body, dict)+ assert extra_body["chat_template_kwargs"] == {+ "thinking": True,+ "enable_thinking": True,+ }++@pytest.mark.asyncioasync def test_build_request_body_encodes_explicit_reasoning_off(provider_config,@@ -261,14 +315,14 @@ def test_preflight_and_build_request_issue_206_post_tool_text(nim_provider):),],)- nim_provider.preflight_stream(req, reasoning=REASONING_OFF)+ nim_provider.preflight_messages(req, reasoning=REASONING_OFF)body = nim_provider._build_request_body(req, reasoning=REASONING_OFF)assert "messages" in bodyassert any(m.get("role") == "tool" for m in body["messages"])@pytest.mark.asyncio-async def test_stream_response_text(nim_provider):+async def test_stream_messages_text(nim_provider):"""Test streaming text response."""req = make_request()@@ -299,7 +353,7 @@ async def test_stream_response_text(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]assert len(events) > 0assert "event: message_start" in events[0]@@ -317,7 +371,7 @@ async def test_stream_response_text(nim_provider):@pytest.mark.asyncio-async def test_stream_response_thinking_reasoning_content(nim_provider):+async def test_stream_messages_thinking_reasoning_content(nim_provider):"""Test streaming with native reasoning_content."""req = make_request()@@ -347,7 +401,7 @@ async def test_stream_response_thinking_reasoning_content(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]# Check for thinking_deltafound_thinking = False@@ -362,7 +416,7 @@ async def test_stream_response_thinking_reasoning_content(nim_provider):@pytest.mark.asyncio-async def test_stream_response_suppresses_thinking_when_disabled(provider_config):+async def test_stream_messages_suppresses_thinking_when_disabled(provider_config):provider = NvidiaNimProvider(provider_config,nim_settings=NimSettings(),@@ -390,7 +444,7 @@ async def test_stream_response_suppresses_thinking_when_disabled(provider_configmock_create.return_value = mock_stream()events = [- e async for e in provider.stream_response(req, reasoning=REASONING_OFF)+ e async for e in provider.stream_messages(req, reasoning=REASONING_OFF)]event_text = "".join(events)@@ -407,7 +461,7 @@ def _make_bad_request_error(message: str) -> openai.BadRequestError:@pytest.mark.asyncio-async def test_stream_response_retries_without_chat_template(provider_config):+async def test_stream_messages_retries_without_chat_template(provider_config):provider = NvidiaNimProvider(provider_config,nim_settings=NimSettings(chat_template="custom_template"),@@ -437,7 +491,7 @@ async def test_stream_response_retries_without_chat_template(provider_config):mock_create.side_effect = [first_error, mock_stream()]events = [- e async for e in provider.stream_response(req, reasoning=REASONING_ON)+ e async for e in provider.stream_messages(req, reasoning=REASONING_ON)]assert mock_create.await_count == 2@@ -462,7 +516,7 @@ async def test_stream_response_retries_without_chat_template(provider_config):@pytest.mark.asyncio-async def test_stream_response_retries_without_chat_template_kwargs_issue_993(+async def test_stream_messages_retries_without_chat_template_kwargs_issue_993(provider_config,):provider = NvidiaNimProvider(@@ -494,7 +548,7 @@ async def test_stream_response_retries_without_chat_template_kwargs_issue_993(mock_create.side_effect = [first_error, mock_stream()]events = [- e async for e in provider.stream_response(req, reasoning=REASONING_ON)+ e async for e in provider.stream_messages(req, reasoning=REASONING_ON)]assert mock_create.await_count == 2@@ -517,7 +571,7 @@ async def test_stream_response_retries_without_chat_template_kwargs_issue_993(@pytest.mark.asyncio-async def test_stream_response_does_not_retry_unrelated_bad_request(provider_config):+async def test_stream_messages_does_not_retry_unrelated_bad_request(provider_config):provider = NvidiaNimProvider(provider_config,nim_settings=NimSettings(chat_template="custom_template"),@@ -531,7 +585,7 @@ async def test_stream_response_does_not_retry_unrelated_bad_request(provider_conmock_create.side_effect = _make_bad_request_error("unrelated bad request")with pytest.raises(ExecutionFailure) as exc_info:- [e async for e in provider.stream_response(req)]+ [e async for e in provider.stream_messages(req)]assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@@ -566,7 +620,7 @@ async def test_tool_call_stream(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]starts = [e for e in events if "event: content_block_start" in e and '"tool_use"' in e@@ -608,7 +662,7 @@ async def test_native_minimax_tool_markup_becomes_anthropic_tool_use(nim_provide) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in nim_provider.stream_response(req)]+ events = [event async for event in nim_provider.stream_messages(req)]event_text = "".join(events)assert namespace not in event_text@@ -656,7 +710,7 @@ async def test_native_minimax_reasoning_markup_becomes_anthropic_tool_use() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in nim_provider.stream_response(req)]+ events = [event async for event in nim_provider.stream_messages(req)]event_text = "".join(events)assert namespace not in event_text@@ -692,7 +746,7 @@ async def test_native_minimax_markup_without_tools_retries_without_leaking() as mock_create:mock_create.side_effect = attempts- events = [event async for event in nim_provider.stream_response(req)]+ events = [event async for event in nim_provider.stream_messages(req)]event_text = "".join(events)assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS@@ -737,7 +791,7 @@ async def test_native_minimax_tool_markup_restores_nim_argument_aliases(nim_prov) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in nim_provider.stream_response(req)]+ events = [event async for event in nim_provider.stream_messages(req)]assert json.loads(_input_json_deltas(events)[0]) == {"pattern": "needle",@@ -788,7 +842,7 @@ async def test_malformed_native_minimax_tool_call_retries_without_leaking() as mock_create:mock_create.side_effect = [malformed_stream(), recovered_stream()]- events = [event async for event in nim_provider.stream_response(req)]+ events = [event async for event in nim_provider.stream_messages(req)]assert mock_create.await_count == 2event_text = "".join(events)@@ -854,7 +908,7 @@ async def test_midstream_native_tool_suffix_failure_recovers_without_duplication):mock_create.side_effect = [malformed_stream(), recovered_stream()]- events = [event async for event in nim_provider.stream_response(req)]+ events = [event async for event in nim_provider.stream_messages(req)]assert mock_create.await_count == 2event_text = "".join(events)@@ -866,7 +920,7 @@ async def test_midstream_native_tool_suffix_failure_recovers_without_duplication@pytest.mark.asyncio-async def test_stream_response_restores_aliased_tool_arguments(nim_provider):+async def test_stream_messages_restores_aliased_tool_arguments(nim_provider):"""NIM-safe argument aliases are restored before Anthropic SSE emission."""req = make_request(tools=[@@ -898,7 +952,7 @@ async def test_stream_response_restores_aliased_tool_arguments(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]await_args = mock_create.await_argsassert await_args is not None@@ -917,7 +971,7 @@ async def test_stream_response_restores_aliased_tool_arguments(nim_provider):@pytest.mark.asyncio-async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provider):+async def test_stream_messages_buffers_chunked_aliased_tool_arguments(nim_provider):"""Chunked aliased args are emitted once as restored Claude Code args."""req = make_request(tools=[@@ -955,7 +1009,7 @@ async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provid) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -963,7 +1017,7 @@ async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provid@pytest.mark.asyncio-async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provider):+async def test_stream_messages_restores_nested_aliased_tool_arguments(nim_provider):req = make_request(tools=[tool(@@ -1001,7 +1055,7 @@ async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provid) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1009,7 +1063,7 @@ async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provid@pytest.mark.asyncio-async def test_stream_response_task_tool_still_forces_background_false(nim_provider):+async def test_stream_messages_task_tool_still_forces_background_false(nim_provider):req = make_request(tools=[tool(@@ -1047,7 +1101,7 @@ async def test_stream_response_task_tool_still_forces_background_false(nim_provi) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1055,7 +1109,7 @@ async def test_stream_response_task_tool_still_forces_background_false(nim_provi@pytest.mark.asyncio-async def test_stream_response_retries_without_reasoning_budget(nim_provider):+async def test_stream_messages_retries_without_reasoning_budget(nim_provider):req = make_request()mock_chunk = MagicMock()@@ -1079,7 +1133,7 @@ async def test_stream_response_retries_without_reasoning_budget(nim_provider):events = [e- async for e in nim_provider.stream_response(+ async for e in nim_provider.stream_messages(req,reasoning=ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),)@@ -1097,7 +1151,7 @@ async def test_stream_response_retries_without_reasoning_budget(nim_provider):@pytest.mark.asyncio-async def test_stream_response_retries_without_budget_for_thinking_token_error(+async def test_stream_messages_retries_without_budget_for_thinking_token_error(nim_provider,):req = make_request(model="meta/llama-3.3-70b-instruct")@@ -1126,7 +1180,7 @@ async def test_stream_response_retries_without_budget_for_thinking_token_error(events = [e- async for e in nim_provider.stream_response(+ async for e in nim_provider.stream_messages(req, reasoning=ReasoningPolicy.on(budget_tokens=77))]@@ -1144,7 +1198,7 @@ async def test_stream_response_retries_without_budget_for_thinking_token_error(@pytest.mark.asyncio-async def test_stream_response_retries_without_reasoning_content(nim_provider):+async def test_stream_messages_retries_without_reasoning_content(nim_provider):req = make_request(system=None,messages=[@@ -1192,7 +1246,7 @@ async def test_stream_response_retries_without_reasoning_content(nim_provider):) as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [e async for e in nim_provider.stream_response(req)]+ events = [e async for e in nim_provider.stream_messages(req)]assert mock_create.await_count == 2first_call = mock_create.await_args_list[0].kwargs@@ -1205,7 +1259,7 @@ async def test_stream_response_retries_without_reasoning_content(nim_provider):@pytest.mark.asyncio-async def test_stream_response_bad_request_without_reasoning_budget_does_not_retry(+async def test_stream_messages_bad_request_without_reasoning_budget_does_not_retry(nim_provider,):req = make_request()@@ -1217,14 +1271,14 @@ async def test_stream_response_bad_request_without_reasoning_budget_does_not_retmock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in nim_provider.stream_response(req)]+ [e async for e in nim_provider.stream_messages(req)]assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@pytest.mark.asyncio-async def test_stream_response_unrelated_internal_error_does_not_downgrade(+async def test_stream_messages_unrelated_internal_error_does_not_downgrade(nim_provider,):req = make_request()@@ -1236,7 +1290,7 @@ async def test_stream_response_unrelated_internal_error_does_not_downgrade(mock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in nim_provider.stream_response(req)]+ [e async for e in nim_provider.stream_messages(req)]assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTSassert all(@@ -1247,7 +1301,7 @@ async def test_stream_response_unrelated_internal_error_does_not_downgrade(@pytest.mark.asyncio-async def test_stream_response_internal_reasoning_content_error_does_not_downgrade(+async def test_stream_messages_internal_reasoning_content_error_does_not_downgrade(nim_provider,):req = make_request()@@ -1261,7 +1315,7 @@ async def test_stream_response_internal_reasoning_content_error_does_not_downgramock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in nim_provider.stream_response(req)]+ [e async for e in nim_provider.stream_messages(req)]assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTSassert all(diff --git a/tests/providers/test_nvidia_nim_degraded_retry.py b/tests/providers/test_nvidia_nim_degraded_retry.pyindex df64b781..c1912b92 100644--- a/tests/providers/test_nvidia_nim_degraded_retry.py+++ b/tests/providers/test_nvidia_nim_degraded_retry.py@@ -138,7 +138,7 @@ async def test_degraded_function_retries_unchanged_request_then_succeeds() -> No):events = [event- async for event in provider.stream_response(+ async for event in provider.stream_messages(make_messages_request(), request_id="req_recovered")]@@ -174,7 +174,7 @@ async def test_degraded_function_exhaustion_is_detailed_redacted_overload() -> N):[event- async for event in provider.stream_response(+ async for event in provider.stream_messages(make_messages_request(), request_id="req_degraded")]@@ -221,7 +221,7 @@ async def test_negative_derived_max_tokens_is_context_window_failure():[event- async for event in provider.stream_response(+ async for event in provider.stream_messages(make_messages_request(), request_id="req_context")]@@ -257,7 +257,7 @@ async def test_negative_derived_max_tokens_is_context_window_failure_on_500():[event- async for event in provider.stream_response(+ async for event in provider.stream_messages(make_messages_request(), request_id="req_context_500")]@@ -299,7 +299,7 @@ async def test_other_nim_max_token_errors_remain_invalid_requests() as create,pytest.raises(ExecutionFailure) as exc_info,):- [event async for event in provider.stream_response(make_messages_request())]+ [event async for event in provider.stream_messages(make_messages_request())]assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUEST@@ -330,7 +330,7 @@ async def test_unrelated_nim_bad_request_is_not_retried(detail: str) -> None:) as create,pytest.raises(ExecutionFailure) as exc_info,):- [event async for event in provider.stream_response(make_messages_request())]+ [event async for event in provider.stream_messages(make_messages_request())]assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUEST@@ -357,7 +357,7 @@ async def test_degraded_wording_remains_non_retryable_for_other_providers() -> N) as create,pytest.raises(ExecutionFailure) as exc_info,):- [event async for event in provider.stream_response(make_messages_request())]+ [event async for event in provider.stream_messages(make_messages_request())]assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUESTdiff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.pyindex 1fa5a0b2..789910de 100644--- a/tests/providers/test_ollama.py+++ b/tests/providers/test_ollama.py@@ -168,7 +168,7 @@ def test_replay_is_independent_of_disabled_current_turn_reasoning(provider) -> N@pytest.mark.asyncio-async def test_stream_response_uses_shared_openai_chat_provider() -> None:+async def test_stream_messages_uses_shared_openai_chat_provider() -> None:provider = _provider()chunk = MagicMock()chunk.choices = [@@ -195,7 +195,7 @@ async def test_stream_response_uses_shared_openai_chat_provider() -> None:output = "".join([event- async for event in provider.stream_response(+ async for event in provider.stream_messages(make_messages_request(OLLAMA_MODEL))]@@ -235,7 +235,7 @@ async def test_cloud_stream_maps_ollama_reasoning_delta_to_anthropic_thinking()output = "".join([event- async for event in client.stream_response(+ async for event in client.stream_messages(make_messages_request(OLLAMA_CLOUD_MODEL))]diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.pyindex 1c9c5338..df0ac23d 100644--- a/tests/providers/test_open_router.py+++ b/tests/providers/test_open_router.py@@ -319,7 +319,7 @@ async def test_stream_maps_reasoning_content_and_details(open_router_provider):):events = [event- async for event in open_router_provider.stream_response(make_request())+ async for event in open_router_provider.stream_messages(make_request())]event_text = "".join(events)diff --git a/tests/providers/test_openai_chat_stream_output.py b/tests/providers/test_openai_chat_stream_output.pynew file mode 100644index 00000000..8df42f1e--- /dev/null+++ b/tests/providers/test_openai_chat_stream_output.py@@ -0,0 +1,307 @@+import json++from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.openai_responses.models import OpenAIResponsesRequest+from free_claude_code.providers.openai_chat.stream_output import (+ AnthropicChatStreamOutput,+ ChatStreamUsage,+ ResponsesChatStreamOutput,+)+++def _parse_frame(frame: str) -> tuple[str, dict[str, object]]:+ lines = frame.strip().splitlines()+ return lines[0].removeprefix("event: "), json.loads(lines[1].removeprefix("data: "))+++def _object_dict(value: object) -> dict[str, object]:+ assert isinstance(value, dict)+ return value+++def test_anthropic_chat_output_preserves_existing_wire_lifecycle() -> None:+ output = AnthropicChatStreamOutput(+ message_id="msg_test",+ model="public-model",+ input_tokens=7,+ )++ frames = [*output.start_events()]+ frames.extend(output.ensure_reasoning_block())+ frames.append(output.emit_reasoning_delta("think"))+ frames.extend(output.ensure_text_block())+ frames.append(output.emit_text_delta("answer"))+ frames.extend(output.close_content_blocks())+ output.ensure_tool_state(0)+ output.register_tool_name(0, "lookup")+ frames.append(output.start_tool_block(0, "call_1", "lookup"))+ frames.append(output.emit_tool_delta(0, '{"q":"fcc"}'))+ frames.extend(output.close_all_blocks())+ frames.extend(+ output.finish_success(+ stop_reason="tool_use",+ usage=ChatStreamUsage(input_tokens=9, output_tokens=4),+ )+ )++ events = [_parse_frame(frame) for frame in frames]+ assert [event_type for event_type, _ in events] == [+ "message_start",+ "content_block_start",+ "content_block_delta",+ "content_block_stop",+ "content_block_start",+ "content_block_delta",+ "content_block_stop",+ "content_block_start",+ "content_block_delta",+ "content_block_stop",+ "message_delta",+ "message_stop",+ ]+ assert _object_dict(events[0][1]["message"])["id"] == "msg_test"+ assert events[-2][1]["usage"] == {"input_tokens": 9, "output_tokens": 4}+ assert output.accumulated_reasoning == "think"+ assert output.accumulated_text == "answer"+ tool_block = output.tool_block_for_tool_index(0)+ assert tool_block is not None+ assert tool_block.content == '{"q":"fcc"}'+++def test_responses_chat_output_emits_one_native_lifecycle_with_exact_usage() -> None:+ output = ResponsesChatStreamOutput(+ OpenAIResponsesRequest.model_validate(+ {+ "model": "public-model",+ "input": "Hello",+ "parallel_tool_calls": False,+ "tool_choice": "auto",+ "tools": [+ {+ "type": "namespace",+ "name": "mcp",+ "tools": [+ {+ "type": "function",+ "name": "lookup",+ "parameters": {"type": "object"},+ }+ ],+ }+ ],+ }+ ),+ input_tokens=7,+ )++ frames = [*output.start_events()]+ frames.extend(output.ensure_reasoning_block())+ frames.append(output.emit_reasoning_delta("think"))+ frames.extend(output.ensure_text_block())+ frames.append(output.emit_text_delta("answer"))+ frames.extend(output.close_content_blocks())+ output.ensure_tool_state(0)+ output.register_tool_name(0, "mcp__lookup")+ frames.append(output.start_tool_block(0, "call_1", "mcp__lookup"))+ frames.append(output.emit_tool_delta(0, '{"q":"fcc"}'))+ frames.extend(output.close_all_blocks())+ frames.extend(+ output.finish_success(+ stop_reason="tool_calls",+ usage=ChatStreamUsage(+ input_tokens=20,+ output_tokens=8,+ cached_tokens=5,+ reasoning_tokens=3,+ ),+ )+ )++ events = [_parse_frame(frame) for frame in frames if frame]+ event_types = [event_type for event_type, _ in events]+ assert event_types.count("response.created") == 1+ assert event_types.count("response.completed") == 1+ assert not any(event_type.startswith("message_") for event_type in event_types)+ assert event_types.index("response.reasoning_text.delta") < event_types.index(+ "response.output_text.delta"+ )+ assert event_types.index("response.output_text.delta") < event_types.index(+ "response.function_call_arguments.done"+ )++ final = _object_dict(events[-1][1]["response"])+ assert final["model"] == "public-model"+ assert final["status"] == "completed"+ assert final["usage"] == {+ "input_tokens": 20,+ "input_tokens_details": {"cached_tokens": 5},+ "output_tokens": 8,+ "output_tokens_details": {"reasoning_tokens": 3},+ "total_tokens": 28,+ }+ final_output = final["output"]+ assert isinstance(final_output, list)+ tool = next(+ item+ for value in final_output+ if isinstance(value, dict)+ and (item := _object_dict(value))["type"] == "function_call"+ )+ assert tool == {+ "id": tool["id"],+ "type": "function_call",+ "status": "completed",+ "call_id": "call_1",+ "name": "lookup",+ "namespace": "mcp",+ "arguments": '{"q":"fcc"}',+ }+++def test_responses_chat_output_finishes_committed_failure_once() -> None:+ output = ResponsesChatStreamOutput(+ OpenAIResponsesRequest.model_validate(+ {"model": "public-model", "input": "Hello"}+ ),+ input_tokens=1,+ )+ frames = [*output.start_events(), *output.ensure_text_block()]+ frames.append(output.emit_text_delta("partial"))+ failure = ExecutionFailure(+ kind=FailureKind.UPSTREAM,+ status_code=502,+ message="Provider failed safely.",+ retryable=True,+ )+ frames.extend(output.finish_failure(failure))+ frames.extend(output.finish_failure(failure))++ events = [_parse_frame(frame) for frame in frames if frame]+ assert [event_type for event_type, _ in events].count("response.failed") == 1+ final = _object_dict(events[-1][1]["response"])+ assert final["status"] == "failed"+ assert _object_dict(final["error"])["message"] == "Provider failed safely."+ assert output.consumes_terminal_failure is True+++def test_responses_chat_output_preserves_options_on_incomplete_terminal() -> None:+ output = ResponsesChatStreamOutput(+ OpenAIResponsesRequest.model_validate(+ {+ "model": "public-model",+ "input": "Hello",+ "temperature": 0.25,+ "top_p": 0.75,+ "max_output_tokens": 12,+ }+ ),+ input_tokens=1,+ )++ frames = [*output.start_events(), *output.ensure_text_block()]+ frames.append(output.emit_text_delta("partial"))+ frames.extend(+ output.finish_success(+ stop_reason="max_tokens",+ usage=ChatStreamUsage(input_tokens=4, output_tokens=12),+ )+ )++ events = [_parse_frame(frame) for frame in frames if frame]+ assert [event_type for event_type, _ in events].count("response.created") == 1+ assert [event_type for event_type, _ in events].count("response.incomplete") == 1+ final = _object_dict(events[-1][1]["response"])+ assert final["status"] == "incomplete"+ assert final["incomplete_details"] == {"reason": "max_output_tokens"}+ assert final["parallel_tool_calls"] is True+ assert final["tool_choice"] == "auto"+ assert final["temperature"] == 0.25+ assert final["top_p"] == 0.75+ assert final["max_output_tokens"] == 12+++def test_responses_chat_output_preserves_custom_tool_free_form_input() -> None:+ output = ResponsesChatStreamOutput(+ OpenAIResponsesRequest.model_validate(+ {+ "model": "public-model",+ "input": "Patch the file",+ "tools": [+ {+ "type": "custom",+ "name": "apply_patch",+ "format": {"type": "text"},+ }+ ],+ }+ ),+ input_tokens=1,+ )++ frames = [*output.start_events()]+ frames.append(output.start_tool_block(0, "call_patch", "apply_patch"))+ frames.append(output.emit_tool_delta(0, "*** Begin Patch\n*** End Patch"))+ frames.extend(+ output.finish_success(+ stop_reason="tool_calls",+ usage=ChatStreamUsage(input_tokens=3, output_tokens=2),+ )+ )++ events = [_parse_frame(frame) for frame in frames if frame]+ final = _object_dict(events[-1][1]["response"])+ final_output = final["output"]+ assert isinstance(final_output, list)+ assert final_output == [+ {+ "id": _object_dict(final_output[0])["id"],+ "type": "custom_tool_call",+ "status": "completed",+ "call_id": "call_patch",+ "name": "apply_patch",+ "input": "*** Begin Patch\n*** End Patch",+ }+ ]+++def test_responses_chat_output_fails_malformed_function_call_once() -> None:+ output = ResponsesChatStreamOutput(+ OpenAIResponsesRequest.model_validate(+ {+ "model": "public-model",+ "input": "Call lookup",+ "tools": [+ {+ "type": "function",+ "name": "lookup",+ "parameters": {"type": "object"},+ }+ ],+ }+ ),+ input_tokens=1,+ )++ frames = [*output.start_events()]+ frames.append(output.start_tool_block(0, "call_bad", "lookup"))+ frames.append(output.emit_tool_delta(0, '{"q":'))+ frames.extend(+ output.finish_success(+ stop_reason="tool_calls",+ usage=ChatStreamUsage(input_tokens=3, output_tokens=1),+ )+ )+ frames.extend(+ output.finish_success(+ stop_reason="tool_calls",+ usage=ChatStreamUsage(input_tokens=3, output_tokens=1),+ )+ )++ events = [_parse_frame(frame) for frame in frames if frame]+ event_types = [event_type for event_type, _ in events]+ assert event_types.count("response.failed") == 1+ assert "response.completed" not in event_types+ final = _object_dict(events[-1][1]["response"])+ assert final["status"] == "failed"+ assert _object_dict(final["error"])["type"] == "api_error"diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.pyindex d87b5e63..772fa544 100644--- a/tests/providers/test_openai_chat_usage.py+++ b/tests/providers/test_openai_chat_usage.py@@ -183,7 +183,7 @@ async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokenswith patch.object(provider._client.chat.completions, "create", create):events = [- event async for event in provider.stream_response(request, input_tokens=7)+ event async for event in provider.stream_messages(request, input_tokens=7)]create.assert_awaited_once()@@ -219,7 +219,7 @@ async def test_openai_chat_stream_keeps_response_model_separate_from_upstream_mowith patch.object(provider._client.chat.completions, "create", create):events = [event- async for event in provider.stream_response(+ async for event in provider.stream_messages(request,response_model="anthropic/test/upstream/model",)diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.pyindex bd54e995..746cb797 100644--- a/tests/providers/test_openai_codex_provider.py+++ b/tests/providers/test_openai_codex_provider.py@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.core.diagnostics import ERROR_DETAIL_DISPLAY_CAP_BYTESfrom free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -106,6 +107,21 @@ def _request() -> MessagesRequest:)+def _responses_request() -> OpenAIResponsesRequest:+ return OpenAIResponsesRequest.model_validate(+ {+ "model": "gpt-test",+ "input": [{"role": "user", "content": "hello"}],+ "stream": False,+ "store": True,+ "previous_response_id": "resp_previous",+ "max_output_tokens": 1024,+ "metadata": {"source": "test"},+ "future_option": {"enabled": True},+ }+ )++def _client_control_request() -> MessagesRequest:return MessagesRequest.model_validate({@@ -202,7 +218,7 @@ async def test_provider_uses_subscription_headers_and_visible_model_catalog() ->infos = await provider.list_model_infos()body = await _collect(- provider.stream_response(+ provider.stream_messages(_request(),input_tokens=3,request_id="req_test",@@ -298,11 +314,11 @@ async def test_generation_close_failure_preserves_success_and_permit() -> None:)first = await asyncio.wait_for(- _collect(provider.stream_response(_request(), response_model="claude-opus-4")),+ _collect(provider.stream_messages(_request(), response_model="claude-opus-4")),timeout=1,)second = await asyncio.wait_for(- _collect(provider.stream_response(_request(), response_model="claude-opus-4")),+ _collect(provider.stream_messages(_request(), response_model="claude-opus-4")),timeout=1,)@@ -336,7 +352,7 @@ async def test_generation_close_failure_preserves_provider_failure() -> None:with pytest.raises(ExecutionFailure) as exc_info:await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_close_failure",response_model="claude-opus-4",@@ -374,11 +390,11 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> Noriginal_request = request.model_dump()reasoning = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)- provider.preflight_stream(request, reasoning=reasoning)+ provider.preflight_messages(request, reasoning=reasoning)assert requests == []body = await _collect(- provider.stream_response(+ provider.stream_messages(request,request_id="req_client_controls",response_model="claude-opus-4",@@ -401,6 +417,64 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> Nawait client.aclose()+async def test_provider_relays_native_responses_with_private_field_policy() -> None:+ requests: list[httpx.Request] = []++ def handler(request: httpx.Request) -> httpx.Response:+ requests.append(request)+ return httpx.Response(+ 200,+ text=_complete_stream("hello"),+ headers={"content-type": "text/event-stream"},+ request=request,+ )++ client = httpx.AsyncClient(+ base_url="https://chatgpt.com/backend-api/codex/",+ transport=httpx.MockTransport(handler),+ )+ provider = OpenAICodexProvider(+ _config(), auth=_FakeAuth(), admission=_admission(), client=client+ )+ request = _responses_request()+ original = request.model_dump()++ provider.preflight_responses(request)+ assert requests == []+ body = await _collect(+ provider.stream_responses(+ request,+ request_id="req_native_responses",+ response_model="openai/gpt-test",+ )+ )++ assert len(requests) == 1+ upstream = json.loads(requests[0].content)+ assert upstream["model"] == "gpt-test"+ assert upstream["input"] == [{"role": "user", "content": "hello"}]+ assert upstream["stream"] is True+ assert upstream["store"] is False+ assert upstream["future_option"] == {"enabled": True}+ assert "previous_response_id" not in upstream+ assert "max_output_tokens" not in upstream+ assert "metadata" not in upstream+ assert request.model_dump() == original++ events = parse_sse_text(body)+ assert [event.event for event in events] == [+ "response.created",+ "response.output_text.delta",+ "response.completed",+ ]+ assert events[0].data["response"]["id"] == "resp_1"+ assert events[0].data["response"]["model"] == "openai/gpt-test"+ assert events[-1].data["response"]["id"] == "resp_1"+ assert events[-1].data["response"]["model"] == "openai/gpt-test"+ await client.aclose()++@pytest.mark.asyncio@pytest.mark.parametrize(("field", "value", "error_path"),@@ -449,7 +523,7 @@ async def test_provider_preflight_rejects_unrepresentable_client_controls(}with pytest.raises(InvalidRequestError, match=error_path):- provider.preflight_stream(MessagesRequest.model_validate(payload))+ provider.preflight_messages(MessagesRequest.model_validate(payload))assert requests == []await client.aclose()@@ -530,7 +604,7 @@ async def test_provider_round_trips_portable_tool_name_alias() -> None:_config(), auth=_FakeAuth(), admission=_admission(), client=client)- body = await _collect(provider.stream_response(request))+ body = await _collect(provider.stream_messages(request))payload = payloads[0]alias = payload["tools"][0]["name"]@@ -585,7 +659,7 @@ async def test_early_truncated_attempt_is_retried_without_duplicate_output() ->)body = await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_retry",response_model="claude-opus-4",@@ -629,7 +703,7 @@ async def test_pre_stream_retry_discards_held_message_start() -> None:)body = await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_pre_stream",response_model="claude-opus-4",@@ -674,7 +748,7 @@ async def test_non_streaming_success_is_retried_then_reports_bounded_body() -> Nwith pytest.raises(ExecutionFailure) as exc_info:await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_non_stream",response_model="claude-opus-4",@@ -728,7 +802,7 @@ async def test_truncated_attempt_after_commit_is_not_retried_or_duplicated() ->chunks: list[str] = []with pytest.raises(ExecutionFailure):- async for chunk in provider.stream_response(+ async for chunk in provider.stream_messages(_request(),request_id="req_committed",response_model="claude-opus-4",@@ -774,7 +848,7 @@ async def test_unauthorized_response_forces_one_auth_refresh() -> None:)body = await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_auth",response_model="claude-opus-4",@@ -888,7 +962,7 @@ async def test_auth_refresh_failure_does_not_repeat_rejected_provider_call() ->with pytest.raises(ExecutionFailure, match="refresh interrupted") as exc_info:await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_auth_transient",response_model="claude-opus-4",@@ -924,7 +998,7 @@ async def test_second_unauthorized_response_is_terminal_without_refresh_loop() -with pytest.raises(ExecutionFailure) as exc_info:await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_auth_terminal",response_model="claude-opus-4",@@ -962,7 +1036,7 @@ async def test_final_attempt_unauthorized_preserves_the_provider_401() -> None:with pytest.raises(ExecutionFailure) as exc_info:await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_final_401",response_model="claude-opus-4",@@ -1014,7 +1088,7 @@ async def test_stream_failure_redacts_credentials_from_customer_diagnostic() ->with pytest.raises(ExecutionFailure) as exc_info:await _collect(- provider.stream_response(+ provider.stream_messages(_request(),request_id="req_redaction",response_model="claude-opus-4",diff --git a/tests/providers/test_openai_compat_5xx_retry.py b/tests/providers/test_openai_compat_5xx_retry.pyindex 8fa1f323..81a7e8f1 100644--- a/tests/providers/test_openai_compat_5xx_retry.py+++ b/tests/providers/test_openai_compat_5xx_retry.py@@ -72,7 +72,7 @@ async def test_nim_stream_retries_on_openai_5xx_then_streams(status_code):) as mock_create,):mock_create.side_effect = [_internal_5xx(status_code), mock_stream()]- events = [e async for e in provider.stream_response(req)]+ events = [e async for e in provider.stream_messages(req)]assert mock_create.await_count == 2assert any("Hi" in e for e in events)@@ -116,7 +116,7 @@ async def test_nim_stream_retries_on_pre_stream_connection_error_then_streams():) as mock_create,):mock_create.side_effect = [_connection_error(), mock_stream()]- events = [e async for e in provider.stream_response(req)]+ events = [e async for e in provider.stream_messages(req)]assert mock_create.await_count == 2assert any("Recovered" in e for e in events)@@ -151,7 +151,7 @@ async def test_nim_stream_connection_error_exhausted_emits_cause_chain():patch("free_claude_code.providers.openai_chat.provider.trace_event") as trace,pytest.raises(ExecutionFailure) as exc_info,):- [e async for e in provider.stream_response(req, request_id="req_conn")]+ [e async for e in provider.stream_messages(req, request_id="req_conn")]assert mock_create.await_count == 5error_traces = [@@ -204,7 +204,7 @@ async def test_nim_stream_openai_5xx_exhausted_emits_user_message():mock_create.side_effect = _internal_5xx(status_code)with pytest.raises(ExecutionFailure) as exc_info:- [e async for e in provider.stream_response(req)]+ [e async for e in provider.stream_messages(req)]assert mock_create.await_count == 5assert expect_substr in exc_info.value.message.lower()diff --git a/tests/providers/test_openai_responses_transport.py b/tests/providers/test_openai_responses_transport.pyindex 4ad987dc..3e21660c 100644--- a/tests/providers/test_openai_responses_transport.py+++ b/tests/providers/test_openai_responses_transport.py@@ -2,7 +2,7 @@import asyncioimport json-from collections.abc import Callable+from collections.abc import Callable, Mappingimport httpx2import pytest@@ -17,6 +17,8 @@ from free_claude_code.core.anthropic.stream_contracts import (thinking_content,)from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.openai_responses import OpenAIResponsesTransportfrom tests.providers.support import REASONING_ON, immediate_admission@@ -100,7 +102,7 @@ def _completed_event(*, sequence: int = 1) -> dict[str, object]:}-def _sse(*events: dict[str, object]) -> str:+def _sse(*events: Mapping[str, object]) -> str:return "".join(f"data: {json.dumps(event)}\n\n" for event in events)@@ -134,7 +136,7 @@ async def _collect() -> list[str]:return [chunk- async for chunk in transport.stream_response(+ async for chunk in transport.stream_messages(request or _request(),input_tokens=11,request_id="req_responses",@@ -144,6 +146,276 @@ async def _collect(]+async def _collect_native(+ transport: OpenAIResponsesTransport,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+) -> list[str]:+ return [+ chunk+ async for chunk in transport.stream_responses(+ request,+ input_tokens=11,+ request_id="req_native_responses",+ response_model="public-model",+ reasoning=reasoning,+ )+ ]+++async def test_native_responses_preserves_request_and_upstream_event_identity() -> None:+ captured: list[dict[str, object]] = []+ created_response = {+ **_completed_response(model="upstream-model"),+ "status": "in_progress",+ "output": [],+ "usage": None,+ }+ created = {+ "type": "response.created",+ "sequence_number": 0,+ "response": created_response,+ }+ delta = _text_delta("hello", sequence=1)+ completed = _completed_event(sequence=2)++ def handler(request: httpx2.Request) -> httpx2.Response:+ payload = json.loads(request.content)+ assert isinstance(payload, dict)+ captured.append(payload)+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(created, delta, completed),+ )++ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "upstream-model",+ "input": [{"role": "user", "content": "hello"}],+ "stream": False,+ "store": True,+ "previous_response_id": "resp_previous",+ "future_option": {"enabled": True},+ }+ )+ client = _client(handler)+ try:+ chunks = await _collect_native(_transport(client), request)+ finally:+ await client.close()++ assert captured == [+ {+ "model": "upstream-model",+ "input": [{"role": "user", "content": "hello"}],+ "stream": True,+ "store": False,+ "future_option": {"enabled": True},+ }+ ]+ events = parse_sse_text("".join(chunks))+ assert [event.event for event in events] == [+ "response.created",+ "response.output_text.delta",+ "response.completed",+ ]+ assert events[0].data["response"]["id"] == "resp_test"+ assert events[0].data["response"]["model"] == "public-model"+ assert events[1].data == delta+ assert events[2].data["response"]["model"] == "public-model"+++async def test_native_responses_applies_resolved_reasoning_override() -> None:+ captured: list[dict[str, object]] = []++ def handler(request: httpx2.Request) -> httpx2.Response:+ payload = json.loads(request.content)+ assert isinstance(payload, dict)+ captured.append(payload)+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(_completed_event()),+ )++ request = OpenAIResponsesRequest.model_validate(+ {+ "model": "upstream-model",+ "input": "hello",+ "reasoning": {"effort": "high", "summary": "detailed"},+ }+ )+ client = _client(handler)+ try:+ await _collect_native(+ _transport(client),+ request,+ reasoning=ReasoningPolicy.off(),+ )+ finally:+ await client.close()++ assert captured[0]["reasoning"] == {"effort": "none"}+++async def test_native_response_failed_retries_before_public_commitment() -> None:+ attempts = 0++ def handler(_request: httpx2.Request) -> httpx2.Response:+ nonlocal attempts+ attempts += 1+ created_response = {+ **_completed_response(),+ "id": f"resp_attempt_{attempts}",+ "status": "in_progress",+ "output": [],+ "usage": None,+ }+ created = {+ "type": "response.created",+ "sequence_number": 0,+ "response": created_response,+ }+ if attempts == 1:+ failed = {+ "type": "response.failed",+ "sequence_number": 1,+ "response": {+ **created_response,+ "status": "failed",+ "error": {+ "message": "temporary",+ "type": "server_error",+ "code": "server_error",+ },+ },+ }+ events = (created, failed)+ else:+ completed = {+ **_completed_event(sequence=1),+ "response": {+ **_completed_response(),+ "id": "resp_attempt_2",+ },+ }+ events = (created, completed)+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(*events),+ )++ client = _client(handler)+ request = OpenAIResponsesRequest(model="upstream-model", input="hello")+ try:+ chunks = await _collect_native(_transport(client, max_attempts=2), request)+ finally:+ await client.close()++ body = "".join(chunks)+ events = parse_sse_text(body)+ assert attempts == 2+ assert [event.event for event in events] == [+ "response.created",+ "response.completed",+ ]+ assert "resp_attempt_1" not in body+ assert events[0].data["response"]["id"] == "resp_attempt_2"+++async def test_native_committed_truncation_emits_one_failed_terminal() -> None:+ attempts = 0+ committed = "x" * 70_000+ created = {+ "type": "response.created",+ "sequence_number": 0,+ "response": {+ **_completed_response(),+ "status": "in_progress",+ "output": [],+ "usage": None,+ },+ }++ def handler(_request: httpx2.Request) -> httpx2.Response:+ nonlocal attempts+ attempts += 1+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(created, _text_delta(committed, sequence=1)),+ )++ client = _client(handler)+ request = OpenAIResponsesRequest(model="upstream-model", input="hello")+ try:+ chunks = await _collect_native(_transport(client, max_attempts=2), request)+ finally:+ await client.close()++ events = parse_sse_text("".join(chunks))+ assert attempts == 1+ assert [event.event for event in events][-1] == "response.failed"+ assert sum(event.event == "response.failed" for event in events) == 1+ assert events[-1].data["response"]["id"] == "resp_test"+ assert events[-1].data["response"]["model"] == "public-model"+ assert events[-1].data["response"]["status"] == "failed"+++async def test_native_response_incomplete_is_a_normal_terminal() -> None:+ incomplete = {+ "type": "response.incomplete",+ "sequence_number": 1,+ "response": {+ **_completed_response(),+ "status": "incomplete",+ "incomplete_details": {"reason": "max_output_tokens"},+ },+ }+ client = _client(+ lambda _request: httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(incomplete),+ )+ )+ request = OpenAIResponsesRequest(model="upstream-model", input="hello")+ try:+ chunks = await _collect_native(_transport(client), request)+ finally:+ await client.close()++ events = parse_sse_text("".join(chunks))+ assert [event.event for event in events] == ["response.incomplete"]+++async def test_native_response_stops_at_terminal_before_trailing_ping() -> None:+ client = _client(+ lambda _request: httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(_completed_event(), {"type": "ping"}),+ )+ )+ request = OpenAIResponsesRequest(model="upstream-model", input="hello")+ try:+ chunks = await _collect_native(_transport(client), request)+ finally:+ await client.close()++ events = parse_sse_text("".join(chunks))+ assert [event.event for event in events] == ["response.completed"]++@pytest.mark.asyncioasync def test_standard_responses_preserves_public_fields_and_usage() -> None:captured: list[dict[str, object]] = []@@ -369,7 +641,7 @@ async def test_post_commit_truncation_is_not_replayed() -> None:chunks: list[str] = []try:with pytest.raises(ExecutionFailure):- async for chunk in _transport(client).stream_response(+ async for chunk in _transport(client).stream_messages(_request(),input_tokens=1,request_id="req_committed",@@ -410,12 +682,12 @@ async def test_cancellation_closes_the_sdk_stream() -> None:))task = asyncio.create_task(_collect(_transport(client)))- await asyncio.wait_for(body.entered.wait(), timeout=1)+ await asyncio.wait_for(body.entered.wait(), timeout=5)task.cancel()try:with pytest.raises(asyncio.CancelledError):await task- await asyncio.wait_for(body.closed.wait(), timeout=1)+ await asyncio.wait_for(body.closed.wait(), timeout=5)finally:await client.close()@@ -428,6 +700,6 @@ async def test_preflight_rejects_fields_responses_cannot_represent() -> None:try:with pytest.raises(InvalidRequestError, match="stop_sequences"):- transport.preflight_stream(request, reasoning=REASONING_ON)+ transport.preflight_messages(request, reasoning=REASONING_ON)finally:await client.close()diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.pyindex 23108b31..43b943aa 100644--- a/tests/providers/test_opencode.py+++ b/tests/providers/test_opencode.py@@ -11,7 +11,15 @@ import pytestfrom openai import AsyncOpenAIfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.application.execution import ProviderExecutorfrom free_claude_code.application.model_metadata import ProviderModelInfo+from free_claude_code.application.routing import (+ ProviderModelTarget,+ ResolvedModelRoute,+ RoutedMessagesRequest,+ RoutedResponsesRequest,+)+from free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import (assert_anthropic_stream_contract,@@ -19,6 +27,8 @@ from free_claude_code.core.anthropic.stream_contracts import (text_content,)from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICYfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.opencode import (OpenCodeProvider,@@ -88,11 +98,72 @@ def _request(model: str, **overrides: object) -> MessagesRequest:return MessagesRequest.model_validate(payload)+def _responses_request(+ model: str,+ **overrides: object,+) -> OpenAIResponsesRequest:+ payload: dict[str, object] = {+ "model": model,+ "input": "hello",+ "max_output_tokens": 128,+ }+ payload.update(overrides)+ return OpenAIResponsesRequest.model_validate(payload)++def _responses_event_stream(text: str) -> str:+ completed_response: dict[str, object] = {+ "id": "resp_1",+ "object": "response",+ "created_at": 1,+ "status": "completed",+ "background": False,+ "billing": {"payer": "developer"},+ "error": None,+ "incomplete_details": None,+ "instructions": None,+ "max_output_tokens": 128,+ "max_tool_calls": None,+ "model": "responses-upstream",+ "output": [],+ "parallel_tool_calls": True,+ "previous_response_id": None,+ "prompt_cache_key": None,+ "prompt_cache_retention": None,+ "reasoning": {"effort": None, "summary": None},+ "safety_identifier": None,+ "service_tier": "default",+ "store": False,+ "temperature": 1.0,+ "text": {"format": {"type": "text"}, "verbosity": "medium"},+ "tool_choice": "auto",+ "tools": [],+ "top_logprobs": 0,+ "top_p": 1.0,+ "truncation": "disabled",+ "usage": {+ "input_tokens": 2,+ "input_tokens_details": {"cached_tokens": 0},+ "output_tokens": 1,+ "output_tokens_details": {"reasoning_tokens": 0},+ "total_tokens": 3,+ },+ "user": None,+ }events: tuple[dict[str, object], ...] = ({- "type": "response.output_text.delta",+ "type": "response.created","sequence_number": 0,+ "response": {+ **completed_response,+ "status": "in_progress",+ "output": [],+ "usage": None,+ },+ },+ {+ "type": "response.output_text.delta",+ "sequence_number": 1,"item_id": "item_text","output_index": 0,"content_index": 0,@@ -101,45 +172,8 @@ def _responses_event_stream(text: str) -> str:},{"type": "response.completed",- "sequence_number": 1,- "response": {- "id": "resp_1",- "object": "response",- "created_at": 1,- "status": "completed",- "background": False,- "billing": {"payer": "developer"},- "error": None,- "incomplete_details": None,- "instructions": None,- "max_output_tokens": 128,- "max_tool_calls": None,- "model": "responses-upstream",- "output": [],- "parallel_tool_calls": True,- "previous_response_id": None,- "prompt_cache_key": None,- "prompt_cache_retention": None,- "reasoning": {"effort": None, "summary": None},- "safety_identifier": None,- "service_tier": "default",- "store": False,- "temperature": 1.0,- "text": {"format": {"type": "text"}, "verbosity": "medium"},- "tool_choice": "auto",- "tools": [],- "top_logprobs": 0,- "top_p": 1.0,- "truncation": "disabled",- "usage": {- "input_tokens": 2,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens": 1,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 3,- },- "user": None,- },+ "sequence_number": 2,+ "response": completed_response,},)return "".join(f"data: {json.dumps(event)}\n\n" for event in events)@@ -186,12 +220,17 @@ def _chat_event_stream(text: str) -> str:def _provider_with_wire_transports(payload: dict[str, object],+ *,+ generation_response: Callable[[httpx2.Request], httpx2.Response] | None = None,+ max_attempts: int = 5,) -> tuple[OpenCodeProvider, list[httpx2.Request], list[httpx.Request]]:generation_requests: list[httpx2.Request] = []catalog_requests: list[httpx.Request] = []def generation_handler(request: httpx2.Request) -> httpx2.Response:generation_requests.append(request)+ if generation_response is not None:+ return generation_response(request)if request.url.path.endswith("/responses"):body = _responses_event_stream("responses-ok")elif request.url.path.endswith("/chat/completions"):@@ -223,7 +262,10 @@ def _provider_with_wire_transports(provider = create_opencode_provider("opencode_zen",_config(),- immediate_admission(provider_name="opencode_zen"),+ immediate_admission(+ provider_name="opencode_zen",+ max_attempts=max_attempts,+ ),catalog_client=_catalog_client(catalog_handler),)return provider, generation_requests, catalog_requests@@ -233,7 +275,7 @@ async def _collect(provider: OpenCodeProvider, model: str, **overrides: object)return "".join([chunk- async for chunk in provider.stream_response(+ async for chunk in provider.stream_messages(_request(model, **overrides),input_tokens=2,request_id="req_opencode",@@ -242,6 +284,23 @@ async def _collect(provider: OpenCodeProvider, model: str, **overrides: object))+async def _collect_responses(+ provider: OpenCodeProvider,+ model: str,+ **overrides: object,+) -> str:+ return "".join(+ [+ chunk+ async for chunk in provider.stream_responses(+ _responses_request(model, **overrides),+ input_tokens=2,+ request_id="req_opencode_responses",+ )+ ]+ )++@pytest.mark.parametrize("provider_id", ["opencode_zen", "opencode_go"])def test_client_identifies_as_first_party_opencode_user_agent(provider_id: str,@@ -519,6 +578,194 @@ async def test_chat_catalog_route_uses_existing_chat_transport_and_upstream_id()assert text_content(events) == "chat-ok"+async def test_responses_ingress_uses_catalog_responses_transport_natively() -> None:+ provider, generation_requests, catalog_requests = _provider_with_wire_transports(+ _catalog_payload()+ )+ try:+ body = await _collect_responses(provider, "responses-selector")+ finally:+ await provider.cleanup()++ assert len(catalog_requests) == 1+ assert [request.url.path for request in generation_requests] == [+ "/zen/v1/responses"+ ]+ payload = json.loads(generation_requests[0].content)+ assert payload["model"] == "responses-upstream"+ assert payload["input"] == "hello"+ assert payload["stream"] is True+ assert payload["store"] is False+ events = parse_sse_text(body)+ assert [event.event for event in events] == [+ "response.created",+ "response.output_text.delta",+ "response.completed",+ ]+ assert events[0].data["response"]["id"] == "resp_1"+ assert events[-1].data["response"]["model"] == "responses-selector"+++async def test_responses_ingress_uses_catalog_chat_transport_directly() -> None:+ provider, generation_requests, catalog_requests = _provider_with_wire_transports(+ _catalog_payload()+ )+ try:+ body = await _collect_responses(provider, "chat-selector")+ finally:+ await provider.cleanup()++ assert len(catalog_requests) == 1+ assert [request.url.path for request in generation_requests] == [+ "/zen/v1/chat/completions"+ ]+ payload = json.loads(generation_requests[0].content)+ assert payload["model"] == "chat-upstream"+ assert payload["messages"] == [{"role": "user", "content": "hello"}]+ events = parse_sse_text(body)+ assert events[0].event == "response.created"+ assert events[-1].event == "response.completed"+ assert events[-1].data["response"]["model"] == "chat-selector"+ assert events[-1].data["response"]["output"][0]["content"][0]["text"] == ("chat-ok")+++ (+ "wire_api",+ "primary_model",+ "fallback_model",+ "failed_path",+ "fallback_path",+ "fallback_text",+ ),+ (+ (+ "responses",+ "responses-selector",+ "chat-selector",+ "/zen/v1/responses",+ "/zen/v1/chat/completions",+ "chat-fallback",+ ),+ (+ "messages",+ "chat-selector",+ "responses-selector",+ "/zen/v1/chat/completions",+ "/zen/v1/responses",+ "responses-fallback",+ ),+ ),+)+async def test_candidate_fallback_resolves_each_opencode_transport(+ wire_api: str,+ primary_model: str,+ fallback_model: str,+ failed_path: str,+ fallback_path: str,+ fallback_text: str,+) -> None:+ def generation_response(request: httpx2.Request) -> httpx2.Response:+ if request.url.path == failed_path:+ return httpx2.Response(503, json={"error": "temporary overload"})+ if request.url.path == "/zen/v1/responses":+ body = _responses_event_stream(fallback_text)+ elif request.url.path == "/zen/v1/chat/completions":+ body = _chat_event_stream(fallback_text)+ else:+ raise AssertionError(f"unexpected generation path {request.url.path}")+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=body,+ )++ provider, generation_requests, catalog_requests = _provider_with_wire_transports(+ _catalog_payload(),+ generation_response=generation_response,+ max_attempts=2,+ )++ def target(model: str) -> ProviderModelTarget:+ return ProviderModelTarget(+ provider_id="opencode_zen",+ provider_model=model,+ provider_model_ref=f"opencode_zen/{model}",+ )++ def upstream_id(model: str) -> str:+ return (+ "responses-upstream" if model == "responses-selector" else "chat-upstream"+ )++ resolved = ResolvedModelRoute(+ original_model="public-model",+ primary=target(primary_model),+ fallbacks=(target(fallback_model),),+ reasoning_preference=ReasoningPreference.INHERIT,+ )+ executor = ProviderExecutor(+ lambda _provider_id: provider,+ progress_timeout_seconds=60.0,+ )++ try:+ if wire_api == "responses":+ stream = executor.stream_responses(+ RoutedResponsesRequest(+ request=_responses_request(primary_model),+ resolved=resolved,+ reasoning=DEFAULT_REASONING_POLICY,+ ),+ raw_log_payload={},+ request_id="req_opencode_cross_transport_responses",+ )+ else:+ stream = executor.stream_messages(+ RoutedMessagesRequest(+ request=_request(primary_model),+ resolved=resolved,+ reasoning=DEFAULT_REASONING_POLICY,+ ),+ raw_log_payload={},+ request_id="req_opencode_cross_transport_messages",+ )+ body = "".join([chunk async for chunk in stream])+ finally:+ await provider.cleanup()++ assert len(catalog_requests) == 1+ assert [request.url.path for request in generation_requests] == [+ failed_path,+ failed_path,+ fallback_path,+ ]+ payloads = [json.loads(request.content) for request in generation_requests]+ assert [payload["model"] for payload in payloads] == [+ upstream_id(primary_model),+ upstream_id(primary_model),+ upstream_id(fallback_model),+ ]+ events = parse_sse_text(body)+ if wire_api == "responses":+ assert [event.event for event in events].count("response.created") == 1+ assert [event.event for event in events].count("response.completed") == 1+ assert events[-1].data["response"]["model"] == "public-model"+ assert [+ event.data["delta"]+ for event in events+ if event.event == "response.output_text.delta"+ ] == [fallback_text]+ else:+ assert_anthropic_stream_contract(events)+ assert events[0].data["message"]["model"] == "public-model"+ assert text_content(events) == fallback_text+ assert "temporary overload" not in body++@pytest.mark.asyncioasync def test_unknown_model_rejects_before_either_generation_endpoint() -> None:provider, generation_requests, catalog_requests = _provider_with_wire_transports(@@ -582,9 +829,9 @@ async def test_warm_preflight_rejects_unknown_and_route_specific_fields() -> Nontry:await provider.list_model_infos()with pytest.raises(InvalidRequestError, match="does not advertise"):- provider.preflight_stream(_request("missing"))+ provider.preflight_messages(_request("missing"))with pytest.raises(InvalidRequestError, match="stop_sequences"):- provider.preflight_stream(+ provider.preflight_messages(_request("responses-selector", stop_sequences=["done"]))finally:diff --git a/tests/providers/test_preflight_contract.py b/tests/providers/test_preflight_contract.pyindex cfe4ae68..636d1ed2 100644--- a/tests/providers/test_preflight_contract.py+++ b/tests/providers/test_preflight_contract.py@@ -33,7 +33,7 @@ class ProviderWithoutPreflight(BaseProvider):async def list_model_infos(self) -> frozenset[ProviderModelInfo]:return frozenset()- async def stream_response(+ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -47,14 +47,14 @@ class ProviderWithoutPreflight(BaseProvider):def test_provider_base_requires_an_explicit_preflight_implementation() -> None:- with pytest.raises(TypeError, match="preflight_stream"):+ with pytest.raises(TypeError, match="preflight_messages"):ProviderWithoutPreflight(make_provider_config(api_key="test", base_url="https://test.invalid"))def test_openai_provider_owns_preflight() -> None:- assert OpenAIChatProvider.preflight_stream is not BaseProvider.preflight_stream+ assert OpenAIChatProvider.preflight_messages is not BaseProvider.preflight_messagesdef test_provider_preflight_calls_builder_and_preserves_policy() -> None:@@ -64,6 +64,6 @@ def test_provider_preflight_calls_builder_and_preserves_policy() -> None:messages=[Message(role="user", content="hello")],)- provider.preflight_stream(request, reasoning=ReasoningPolicy.off())+ provider.preflight_messages(request, reasoning=ReasoningPolicy.off())assert provider.build_calls == [(request, ReasoningPolicy.off())]diff --git a/tests/providers/test_provider_transport_logging.py b/tests/providers/test_provider_transport_logging.pyindex 047f3ab2..674e02f3 100644--- a/tests/providers/test_provider_transport_logging.py+++ b/tests/providers/test_provider_transport_logging.py@@ -42,7 +42,7 @@ async def test_stream_failure_default_logs_exclude_exception_text(caplog) -> Noncaplog.at_level(logging.ERROR),pytest.raises(ExecutionFailure),):- [event async for event in provider.stream_response(make_messages_request())]+ [event async for event in provider.stream_messages(make_messages_request())]messages = " | ".join(record.getMessage() for record in caplog.records)assert "SECRET_OPENAI_COMPAT" not in messages@@ -66,7 +66,7 @@ async def test_stream_failure_default_logs_cause_types_only(caplog) -> None:caplog.at_level(logging.ERROR),pytest.raises(ExecutionFailure),):- [event async for event in provider.stream_response(make_messages_request())]+ [event async for event in provider.stream_messages(make_messages_request())]messages = " | ".join(record.getMessage() for record in caplog.records)assert "SECRET_CAUSE_DETAIL" not in messages@@ -89,7 +89,7 @@ async def test_stream_failure_verbose_traceback_redacts_credentials(caplog) -> Ncaplog.at_level(logging.ERROR),pytest.raises(ExecutionFailure),):- [event async for event in provider.stream_response(make_messages_request())]+ [event async for event in provider.stream_messages(make_messages_request())]messages = " | ".join(record.getMessage() for record in caplog.records)assert "api_key=<redacted>" in messagesdiff --git a/tests/providers/test_sambanova.py b/tests/providers/test_sambanova.pyindex 9d9c5ada..f7fdbd8b 100644--- a/tests/providers/test_sambanova.py+++ b/tests/providers/test_sambanova.py@@ -106,7 +106,7 @@ def test_build_request_body_uses_only_documented_reasoning_efforts(@pytest.mark.asyncio-async def test_stream_response_text(sambanova_provider):+async def test_stream_messages_text(sambanova_provider):"""Text content deltas are emitted as text blocks."""mock_chunk = MagicMock()mock_chunk.choices = [@@ -130,7 +130,7 @@ async def test_stream_response_text(sambanova_provider):mock_create.return_value = mock_stream()events = [- event async for event in sambanova_provider.stream_response(make_request())+ event async for event in sambanova_provider.stream_messages(make_request())]assert any(@@ -139,7 +139,7 @@ async def test_stream_response_text(sambanova_provider):@pytest.mark.asyncio-async def test_stream_response_tool_call(sambanova_provider):+async def test_stream_messages_tool_call(sambanova_provider):mock_tc = MagicMock()mock_tc.index = 0mock_tc.id = "call_1"@@ -165,7 +165,7 @@ async def test_stream_response_tool_call(sambanova_provider):mock_create.return_value = mock_stream()events = [- event async for event in sambanova_provider.stream_response(make_request())+ event async for event in sambanova_provider.stream_messages(make_request())]assert any(@@ -177,7 +177,7 @@ async def test_stream_response_tool_call(sambanova_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning_content(sambanova_provider):+async def test_stream_messages_reasoning_content(sambanova_provider):"""reasoning_content deltas are emitted as thinking blocks."""mock_chunk = MagicMock()mock_chunk.choices = [@@ -201,7 +201,7 @@ async def test_stream_response_reasoning_content(sambanova_provider):mock_create.return_value = mock_stream()events = [- event async for event in sambanova_provider.stream_response(make_request())+ event async for event in sambanova_provider.stream_messages(make_request())]assert any(diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 6d8b16a1..b48c3ba7 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -11,16 +11,17 @@ import openaiimport pytestfrom free_claude_code.config.nim import NimSettings-from free_claude_code.core.anthropic import OpenAIToolNameCodecfrom free_claude_code.core.anthropic.stream_contracts import (parse_sse_text,)from free_claude_code.core.anthropic.streaming import (- AnthropicStreamLedger,make_response_recovery_body,make_text_recovery_body,+ tool_schemas_by_name,)from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import (UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS,@@ -29,12 +30,15 @@ from free_claude_code.providers.admission import (from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.openai_chat.provider import (_OpenAIChatStreamRunner,+ _reserved_anthropic_tool_ids,+)+from free_claude_code.providers.openai_chat.stream_output import (+ AnthropicChatStreamOutput,)from free_claude_code.providers.openai_chat.tool_calls import (OpenAIToolCallAssembler,OpenAIToolCallCollector,- has_committed_sse_output,- iter_heuristic_tool_use_sse,+ iter_heuristic_tool_use_events,)from free_claude_code.providers.stream_recovery import TruncatedProviderStreamErrorfrom tests.providers.request_factory import make_messages_request@@ -126,12 +130,21 @@ def _make_provider():def _make_tool_assembler(provider: NvidiaNimProvider, *, request=None) -> OpenAIToolCallAssembler:+ concrete_request = request or _make_request()return OpenAIToolCallAssembler(- request=request or _make_request(),+ reserved_tool_ids=_reserved_anthropic_tool_ids(concrete_request),record_extra_content=provider._record_tool_call_extra_content,)+def _make_anthropic_output() -> AnthropicChatStreamOutput:+ return AnthropicChatStreamOutput(+ message_id="msg_test",+ model="test-model",+ input_tokens=0,+ )++def _make_request(model: str = "test-model", stream: bool = True, **overrides: object):"""Create a concrete request matching the original streaming-test defaults."""request_overrides: dict[str, object] = {@@ -155,12 +168,17 @@ def _make_stream_runner(request=None,request_id: str | None = None,) -> _OpenAIChatStreamRunner:+ concrete_request = request or _make_request()return _OpenAIChatStreamRunner(provider,- request=request or _make_request(),+ body=provider._build_request_body(concrete_request),+ tool_names=OpenAIToolNameCodec.from_request(concrete_request),+ tool_schemas=tool_schemas_by_name(concrete_request),+ reserved_tool_ids=_reserved_anthropic_tool_ids(concrete_request),+ output_factory=_make_anthropic_output,input_tokens=0,request_id=request_id,- response_model=None,+ response_model=concrete_request.model,reasoning=DEFAULT_REASONING_POLICY,)@@ -215,12 +233,12 @@ async def _collect_stream(reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,):"""Collect all SSE events from a stream."""- return [e async for e in provider.stream_response(request, reasoning=reasoning)]+ return [e async for e in provider.stream_messages(request, reasoning=reasoning)]async def _collect_stream_error(provider, request, **kwargs) -> ExecutionFailure:with pytest.raises(ExecutionFailure) as exc_info:- [e async for e in provider.stream_response(request, **kwargs)]+ [e async for e in provider.stream_messages(request, **kwargs)]return exc_info.value@@ -229,7 +247,7 @@ async def _collect_stream_and_error() -> tuple[list[str], ExecutionFailure]:events: list[str] = []with pytest.raises(ExecutionFailure) as exc_info:- async for event in provider.stream_response(request, **kwargs):+ async for event in provider.stream_messages(request, **kwargs):events.extend((event,))return events, exc_info.value@@ -312,7 +330,7 @@ class TestStreamingExceptionHandling:assert stream.closed- """Tests for error paths during stream_response."""+ """Tests for error paths during stream_messages."""@pytest.mark.asyncioasync def test_pre_start_api_error_raises_provider_error(self):@@ -1203,6 +1221,76 @@ class TestStreamingExceptionHandling:assert parsed[0].event == "message_start"assert parsed[-1].event == "message_stop"+ @pytest.mark.asyncio+ async def test_responses_precommit_retry_emits_one_unduplicated_lifecycle(self):+ """Responses output also discards every frame from an abandoned attempt."""+ provider = _make_provider()+ request = OpenAIResponsesRequest(model="test-model", input="hello")+ first_stream = AsyncStreamMock(+ [_make_chunk(content="hidden")],+ error=httpx.ReadError("early cutoff"),+ )+ second_stream = AsyncStreamMock(+ [+ _make_chunk(content="visible"),+ _make_chunk(finish_reason="stop"),+ ]+ )++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ side_effect=[first_stream, second_stream],+ ) as create:+ events = [+ event+ async for event in provider.stream_responses(+ request,+ request_id="req_responses_retry",+ response_model="public-model",+ )+ ]++ event_text = "".join(events)+ parsed = parse_sse_text(event_text)+ event_names = [event.event for event in parsed]+ assert create.await_count == 2+ assert "hidden" not in event_text+ assert "visible" in event_text+ assert event_names.count("response.created") == 1+ assert event_names.count("response.completed") == 1+ assert "response.failed" not in event_names++ @pytest.mark.asyncio+ async def test_responses_cancellation_closes_upstream_without_retry(self):+ provider = _make_provider()+ request = OpenAIResponsesRequest(model="test-model", input="hello")+ stream = BlockingClosableAsyncStreamMock()++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream,+ ) as create:+ task = asyncio.create_task(+ anext(+ provider.stream_responses(+ request,+ request_id="req_responses_cancel",+ response_model="public-model",+ )+ )+ )+ await asyncio.wait_for(stream.entered.wait(), timeout=1)+ task.cancel()+ with pytest.raises(asyncio.CancelledError):+ await task++ assert create.await_count == 1+ assert stream.close_calls == 1+@pytest.mark.asyncioasync def test_precommit_retry_discards_abandoned_parser_and_usage_state(self):"""A replay owns fresh parsers and terminal usage metadata."""@@ -1816,11 +1904,11 @@ class TestStreamingExceptionHandling:_make_provider(), request=_make_request(), request_id="req_recovery")assembler = runner._new_stream_assembler(output_reasoning=True)- ledger = assembler.ledger- ledger.start_thinking_block()- ledger.emit_thinking_delta("hidden reasoning")- list(ledger.ensure_text_block())- ledger.emit_text_delta("visible answer")+ output = assembler.output+ output.ensure_reasoning_block()+ output.emit_reasoning_delta("hidden reasoning")+ output.ensure_text_block()+ output.emit_text_delta("visible answer")with patch.object(runner,@@ -2000,12 +2088,10 @@ class TestProcessToolCall:def test_heuristic_tool_use_sse_marks_committed_tool_output(self):"""Heuristic tool blocks are emitted content, even without OpenAI tool state."""- from free_claude_code.core.anthropic import AnthropicStreamLedger-- ledger = AnthropicStreamLedger("msg_test", "test-model")+ output = _make_anthropic_output()events = list(- iter_heuristic_tool_use_sse(- ledger,+ iter_heuristic_tool_use_events(+ output,{"id": "toolu_heuristic","name": "Read",@@ -2016,15 +2102,13 @@ class TestProcessToolCall:event_text = "".join(events)assert "tool_use" in event_text- assert ledger.has_emitted_tool_block()- assert has_committed_sse_output(ledger)+ assert output.has_emitted_tool_block()+ assert output.committed_outputdef test_tool_call_with_id(self):"""Tool call with id starts a tool block."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()tc = {"index": 0,"id": "call_123",@@ -2044,7 +2128,7 @@ class TestProcessToolCall:def test_missing_or_blank_tool_call_id_generates_public_id(self, missing_id):"""An absent identity never escapes as an empty Anthropic tool-use ID."""provider = _make_provider()- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()events = list(_make_tool_assembler(provider).process_tool_call(@@ -2089,7 +2173,7 @@ class TestProcessToolCall:},])- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()events = list(_make_tool_assembler(provider, request=request).process_tool_call(@@ -2112,7 +2196,7 @@ class TestProcessToolCall:def test_current_response_tool_call_id_collision_is_remapped(self):"""Two simultaneous calls cannot expose the same public identity."""provider = _make_provider()- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()assembler = _make_tool_assembler(provider)first = list(@@ -2150,7 +2234,7 @@ class TestProcessToolCall:)codec = OpenAIToolNameCodec.from_request(request)alias = codec.encode(original)- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()events = list(_make_tool_assembler(provider).process_tool_call(@@ -2193,7 +2277,7 @@ class TestProcessToolCall:])codec = OpenAIToolNameCodec.from_request(request)- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()events = list(_make_tool_assembler(provider).process_tool_call(@@ -2238,7 +2322,7 @@ class TestProcessToolCall:alias = codec.encode(original)split = len(alias) // 2buffers: dict[int, str] = {}- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()assembler = _make_tool_assembler(provider)first = list(@@ -2293,7 +2377,7 @@ class TestProcessToolCall:codec = OpenAIToolNameCodec.from_request(request)assert codec.is_alias_prefix(original)buffers: dict[int, str] = {}- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()assembler = _make_tool_assembler(provider)initial = list(@@ -2338,7 +2422,9 @@ class TestProcessToolCall:))- calls = collector.completed_calls(request, tool_names=codec)+ calls = collector.completed_calls(+ tool_schemas_by_name(request), tool_names=codec+ )assert calls is not Noneassert calls[0]["function"]["name"] == original@@ -2350,10 +2436,10 @@ class TestProcessToolCall:tools=[{"name": original, "input_schema": {"type": "object"}}])codec = OpenAIToolNameCodec.from_request(request)- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()events = list(- iter_heuristic_tool_use_sse(+ iter_heuristic_tool_use_events(sse,{"id": "call_heuristic",@@ -2371,9 +2457,7 @@ class TestProcessToolCall:def test_tool_call_id_arrives_before_name_still_emits_id_and_name(self):"""Split-stream tool: id (no name) then name then args; id preserved on start."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()t1 = {"index": 0,"id": "call_split",@@ -2401,9 +2485,7 @@ class TestProcessToolCall:def test_tool_call_arguments_buffered_until_name(self):"""Argument deltas before tool name are emitted after the block starts."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()t1 = {"index": 0,"id": "call_buf",@@ -2426,7 +2508,7 @@ class TestProcessToolCall:def test_late_upstream_id_cannot_overwrite_started_public_id(self):"""The identity emitted at block start stays authoritative."""provider = _make_provider()- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()assembler = _make_tool_assembler(provider)initial = list(@@ -2454,14 +2536,12 @@ class TestProcessToolCall:)assert later == []- assert sse.blocks.tool_states[0].tool_id == generated_id+ assert sse.tool_states[0].tool_id == generated_iddef test_task_tool_forces_background_false(self):"""Task tool with run_in_background=true is forced to false."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()args = json.dumps({"run_in_background": True, "prompt": "test"})tc = {"index": 0,@@ -2476,9 +2556,7 @@ class TestProcessToolCall:def test_task_tool_chunked_args_forces_background_false(self):"""Chunked Task args are buffered until valid JSON, then forced to false."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()tc1 = {"index": 0,"id": "call_task_chunked",@@ -2502,9 +2580,7 @@ class TestProcessToolCall:def test_task_tool_invalid_json_logs_warning_on_flush(self, caplog):"""Invalid JSON args for Task tool emits {} on flush and logs a warning."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()tc = {"index": 0,"id": "call_task2",@@ -2523,9 +2599,7 @@ class TestProcessToolCall:def test_negative_tool_index_fallback(self):"""tc_index < 0 uses len(tool_indices) as fallback."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()tc = {"index": -1,"id": "call_neg",@@ -2538,9 +2612,7 @@ class TestProcessToolCall:def test_none_tool_index_defaults_to_zero(self):"""Gemini may stream tool_call deltas with a null index."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()tc = {"index": None,"id": "call_none",@@ -2555,9 +2627,7 @@ class TestProcessToolCall:def test_tool_args_emitted_as_delta(self):"""Arguments are emitted as input_json_delta events."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()tc = {"index": 0,"id": "call_args",@@ -2654,9 +2724,7 @@ class TestStreamChunkEdgeCases:def test_stream_malformed_tool_args_chunked(self):"""Chunked tool args that never form valid JSON are flushed with {}."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _make_anthropic_output()tc1 = {"index": 0,"id": "call_malformed",diff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.pyindex 91212c41..68cefef3 100644--- a/tests/providers/test_subagent_interception.py+++ b/tests/providers/test_subagent_interception.py@@ -1,68 +1,32 @@import json-from unittest.mock import MagicMock-import pytest--from free_claude_code.config.nim import NimSettings-from free_claude_code.config.provider_catalog import NVIDIA_NIM_DEFAULT_BASE-from free_claude_code.core.anthropic import StreamBlockLedger-from free_claude_code.providers.nvidia_nim import NvidiaNimProvider-from free_claude_code.providers.openai_chat.tool_calls import (- OpenAIToolCallAssembler,+from free_claude_code.providers.openai_chat.stream_output import (+ AnthropicChatStreamOutput,)-from tests.providers.request_factory import make_messages_request-from tests.providers.support import (- immediate_admission,- make_provider_config,+from free_claude_code.providers.openai_chat.tool_calls import (+ iter_heuristic_tool_use_events,)-async def test_task_tool_interception():- # Setup provider- config = make_provider_config(api_key="test", base_url=NVIDIA_NIM_DEFAULT_BASE)- provider = NvidiaNimProvider(- config,- nim_settings=NimSettings(),- admission=immediate_admission(),+def test_task_tool_interception() -> None:+ output = AnthropicChatStreamOutput(+ message_id="msg_test",+ model="test-model",+ input_tokens=1,)-- request = make_messages_request("test-model")-- sse = MagicMock()- sse.blocks = StreamBlockLedger()-- # Tool call data (Task tool)- tc = {- "index": 0,+ tool_use = {+ "type": "tool_use","id": "tool_123",- "function": {- "name": "Task",- "arguments": json.dumps(- {- "description": "test task",- "prompt": "do something",- "run_in_background": True,- }- ),+ "name": "Task",+ "input": {+ "description": "test task",+ "prompt": "do something",+ "run_in_background": True,},}- tool_calls = OpenAIToolCallAssembler(- request=request, record_extra_content=provider._record_tool_call_extra_content- )-- # Call the assembler (consume generator to trigger side effects)- list(tool_calls.process_tool_call(tc, sse))-- # Find the emit_tool_delta call and check args- calls = sse.emit_tool_delta.call_args_list- assert len(calls) > 0- args_passed = json.loads(calls[0][0][1])+ events = list(iter_heuristic_tool_use_events(output, tool_use))+ delta = next(event for event in events if '"type": "input_json_delta"' in event)+ payload = json.loads(delta.split("data: ", 1)[1])+ args_passed = json.loads(payload["delta"]["partial_json"])assert args_passed["run_in_background"] is False---if __name__ == "__main__":- import asyncio-- asyncio.run(test_task_tool_interception())diff --git a/tests/providers/test_vercel.py b/tests/providers/test_vercel.pyindex 48b1370c..6c245ff2 100644--- a/tests/providers/test_vercel.py+++ b/tests/providers/test_vercel.py@@ -95,7 +95,7 @@ def test_build_request_body_preserves_caller_extra_body(vercel_provider):@pytest.mark.asyncio-async def test_stream_response_text(vercel_provider):+async def test_stream_messages_text(vercel_provider):mock_chunk = MagicMock()mock_chunk.choices = [MagicMock(@@ -118,7 +118,7 @@ async def test_stream_response_text(vercel_provider):mock_create.return_value = mock_stream()events = [- event async for event in vercel_provider.stream_response(make_request())+ event async for event in vercel_provider.stream_messages(make_request())]assert any(@@ -127,7 +127,7 @@ async def test_stream_response_text(vercel_provider):@pytest.mark.asyncio-async def test_stream_response_reasoning_content(vercel_provider):+async def test_stream_messages_reasoning_content(vercel_provider):mock_chunk = MagicMock()mock_chunk.choices = [MagicMock(@@ -150,7 +150,7 @@ async def test_stream_response_reasoning_content(vercel_provider):mock_create.return_value = mock_stream()events = [- event async for event in vercel_provider.stream_response(make_request())+ event async for event in vercel_provider.stream_messages(make_request())]assert any(diff --git a/tests/providers/test_zenmux.py b/tests/providers/test_zenmux.pyindex 4db5abd3..8621a42e 100644--- a/tests/providers/test_zenmux.py+++ b/tests/providers/test_zenmux.py@@ -333,7 +333,7 @@ async def test_stream_preserves_signed_details_without_duplicating_reasoning(return_value=stream,):event_text = "".join(- [event async for event in zenmux_provider.stream_response(_request())]+ [event async for event in zenmux_provider.stream_messages(_request())])events = parse_sse_text(event_text)diff --git a/tests/runtime/test_application_runtime.py b/tests/runtime/test_application_runtime.pyindex be5e19c4..d5e47393 100644--- a/tests/runtime/test_application_runtime.py+++ b/tests/runtime/test_application_runtime.py@@ -16,6 +16,7 @@ from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.admin.persistence import PreparedAdminUpdatefrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.messaging.command_context import StopOutcomefrom free_claude_code.messaging.platforms.ports import (@@ -58,7 +59,7 @@ class AdminModelProvider(BaseProvider):self._model_infos = model_infosself._error = error- def preflight_stream(+ def preflight_messages(self,request: MessagesRequest,*,@@ -66,6 +67,14 @@ class AdminModelProvider(BaseProvider):) -> None:return None+ def preflight_responses(+ self,+ request: OpenAIResponsesRequest,+ *,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> None:+ return None+async def cleanup(self) -> None:return None@@ -74,7 +83,7 @@ class AdminModelProvider(BaseProvider):raise self._errorreturn self._model_infos- async def stream_response(+ async def stream_messages(self,request: MessagesRequest,input_tokens: int = 0,@@ -86,6 +95,18 @@ class AdminModelProvider(BaseProvider):if False:yield ""+ async def stream_responses(+ self,+ request: OpenAIResponsesRequest,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ response_model: str | None = None,+ reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ ) -> AsyncIterator[str]:+ if False:+ yield ""+class TrackingFactory:def __init__(self) -> None:diff --git a/uv.lock b/uv.lockindex a478e188..927b14fc 100644--- a/uv.lock+++ b/uv.lock@@ -607,7 +607,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.14.8"+version = "5.14.9"source = { editable = "." }dependencies = [{ name = "aiohttp" },