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
Canonicalize request ingress (#1542)
Ali Khokhare508efa201ca
diff --git a/e2e/conftest.py b/e2e/conftest.pyindex a32e8a66..fe5e231f 100644--- a/e2e/conftest.py+++ b/e2e/conftest.py@@ -16,8 +16,11 @@ from free_claude_code.application.model_metadata import ProviderModelInfofrom 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_settings-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ InferenceStreamLedger,+)from 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@@ -52,8 +55,9 @@ class _ModelListingProvider(BaseProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:return None@@ -68,9 +72,10 @@ class _ModelListingProvider(BaseProvider):async def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,diff --git a/pyproject.toml b/pyproject.tomlindex ca921ecd..d25a09c6 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.14.2"+version = "5.14.3"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/smoke/lib/config.py b/smoke/lib/config.pyindex 55f61d55..ddd22d3c 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-120b","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 4547b52f..468b115a 100644--- a/src/free_claude_code/api/handlers/messages.py+++ b/src/free_claude_code/api/handlers/messages.py@@ -39,7 +39,7 @@ from free_claude_code.api.web_tools.streaming import stream_web_server_tool_respfrom free_claude_code.application.errors import ApplicationError, InvalidRequestErrorfrom free_claude_code.application.execution import ProviderExecutor, TokenCounterfrom free_claude_code.application.ports import ProviderResolver-from free_claude_code.application.routing import ModelRouter, RoutedMessagesRequest+from free_claude_code.application.routing import ModelRouter, RoutedInferenceRequestfrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import (MessagesRequest,@@ -49,12 +49,17 @@ from free_claude_code.core.anthropic import (anthropic_error_type_for_failure,anthropic_failure_payload,anthropic_status_for_error_type,- get_token_count,iter_anthropic_sse,+ messages_to_inference_request,+ validate_messages_field_policy,)from free_claude_code.core.diagnostics import safe_exception_messagefrom free_claude_code.core.failures import ExecutionFailure, find_execution_failure-from free_claude_code.core.inference import InferenceEvent+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ get_inference_token_count,+)from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicyfrom free_claude_code.core.trace import trace_event@@ -77,7 +82,7 @@ class _MessagesCompleteResult:_MessagesResult = (_MessagesEventResult | _MessagesWireStreamResult | _MessagesCompleteResult)-MessageIntercept = Callable[[RoutedMessagesRequest], _MessagesResult | None]+MessageIntercept = Callable[[MessagesRequest], _MessagesResult | None]class MessagesHandler:@@ -89,7 +94,7 @@ class MessagesHandler:provider_resolver: ProviderResolver,*,model_router: ModelRouter | None = None,- token_counter: TokenCounter = get_token_count,+ token_counter: TokenCounter = get_inference_token_count,provider_executor: ProviderExecutor | None = None,generation_id: int | None = None,) -> None:@@ -115,32 +120,47 @@ class MessagesHandler:request_id = request_id or new_request_id()try:require_non_empty_messages(request_data.messages)- routed = self._model_router.resolve_messages_request(request_data)- routed = self._apply_message_routing_policies(routed)+ self._validate_wire_request(request_data)automatic_search = plan_automatic_web_search(- routed.request,+ request_data,web_tools_enabled=self._settings.enable_web_server_tools,)if automatic_search is None:- self._reject_unsupported_server_tools(routed)- result = self._run_message_intercepts(routed)- else:- input_tokens = self._token_counter(- routed.request.messages,- routed.request.system,- routed.request.tools,- )+ self._reject_unsupported_server_tools(request_data)+ result = self._run_message_intercepts(request_data)+ if result is not None:+ return await self._to_public_response(+ result,+ stream=request_data.stream,+ request_id=request_id,+ )++ canonical = self._canonical_request(+ automatic_search.request+ if automatic_search is not None+ else request_data+ )+ routed = self._model_router.resolve_inference_request(canonical)+ routed = self._apply_message_routing_policies(+ routed,+ classifier_stop_sequence=detect_safety_classifier_stop_sequence(+ request_data+ ),+ )+ if automatic_search is not None:result = _MessagesWireStreamResult(stream_automatic_web_search_response(self._provider_executor,routed,automatic_search,request_id=request_id,- fallback_input_tokens=input_tokens,+ fallback_input_tokens=self._token_counter(routed.request),verbose_client_errors=self._settings.log_api_error_tracebacks,log_raw_events=self._settings.log_raw_sse_events,))+ else:+ result = Noneif result is None:logger.debug("No optimization matched, routing to provider")result = _MessagesEventResult(@@ -148,7 +168,7 @@ class MessagesHandler:routed,wire_api="messages",raw_log_label="FULL_PAYLOAD",- raw_log_payload=routed.request.model_dump(),+ raw_log_payload=request_data.model_dump(),request_id=request_id,))@@ -318,33 +338,43 @@ class MessagesHandler:),)- def _reject_unsupported_server_tools(self, routed: RoutedMessagesRequest) -> None:+ @staticmethod+ def _validate_wire_request(request: MessagesRequest) -> None:+ try:+ validate_messages_field_policy(request)+ except ValueError as exc:+ raise InvalidRequestError(str(exc)) from exc++ @staticmethod+ def _canonical_request(request: MessagesRequest) -> InferenceRequest:+ try:+ return messages_to_inference_request(request)+ except ValueError as exc:+ raise InvalidRequestError(str(exc)) from exc++ def _reject_unsupported_server_tools(self, request: MessagesRequest) -> None:tool_err = unsupported_server_tool_error(- routed.request,+ request,web_tools_enabled=self._settings.enable_web_server_tools,)if tool_err is not None:raise InvalidRequestError(tool_err)def _apply_message_routing_policies(- self, routed: RoutedMessagesRequest- ) -> RoutedMessagesRequest:- classifier_stop_sequence = detect_safety_classifier_stop_sequence(- routed.request- )+ self,+ routed: RoutedInferenceRequest,+ *,+ classifier_stop_sequence: str | None,+ ) -> RoutedInferenceRequest:if classifier_stop_sequence is None:return routedreasoning_changed = routed.reasoning.control is not ReasoningControl.OFFstop_sequences = routed.request.stop_sequences- remaining_stop_sequences = (- [- stop_sequence- for stop_sequence in stop_sequences- if stop_sequence != classifier_stop_sequence- ]- if stop_sequences is not None- else None+ remaining_stop_sequences = tuple(+ stop_sequence+ for stop_sequence in stop_sequences+ if stop_sequence != classifier_stop_sequence)stop_sequence_removed = remaining_stop_sequences != stop_sequencestrace_event(@@ -361,9 +391,7 @@ class MessagesHandler:request = routed.requestif stop_sequence_removed:- request = request.model_copy(- update={"stop_sequences": remaining_stop_sequences or None}- )+ request = request.with_stop_sequences(remaining_stop_sequences)return replace(routed,request=request,@@ -373,30 +401,32 @@ class MessagesHandler:)def _run_message_intercepts(- self, routed: RoutedMessagesRequest+ self, request: MessagesRequest) -> _MessagesResult | None:for intercept in self._message_intercepts:- result = intercept(routed)+ result = intercept(request)if result is not None:return resultreturn Nonedef _intercept_web_server_tool(- self, routed: RoutedMessagesRequest+ self, request: MessagesRequest) -> _MessagesResult | None:if not self._settings.enable_web_server_tools:return None- if not is_web_server_tool_request(routed.request):+ if not is_web_server_tool_request(request):return None- input_tokens = self._token_counter(- routed.request.messages, routed.request.system, routed.request.tools+ token_request = request.model_copy(+ update={"tools": None, "tool_choice": None},+ deep=True,)+ input_tokens = self._token_counter(self._canonical_request(token_request))trace_event(stage="routing",event="free_claude_code.api.optimization.web_server_tool",source="api",- model=routed.resolved.original_model,+ model=request.model,)egress = WebFetchEgressPolicy(allow_private_network_targets=self._settings.web_fetch_allow_private_networks,@@ -406,21 +436,21 @@ class MessagesHandler:)return _MessagesWireStreamResult(stream_web_server_tool_response(- routed.request,+ request,input_tokens=input_tokens,web_fetch_egress=egress,- response_model=routed.resolved.original_model,+ response_model=request.model,verbose_client_errors=self._settings.log_api_error_tracebacks,),)def _intercept_local_optimization(- self, routed: RoutedMessagesRequest+ self, request: MessagesRequest) -> _MessagesResult | None:optimized = try_optimizations(- routed.request,+ request,self._settings,- response_model=routed.resolved.original_model,+ response_model=request.model,)if optimized is None:return None@@ -428,7 +458,7 @@ class MessagesHandler:stage="routing",event="free_claude_code.api.optimization.short_circuit",source="api",- model=routed.resolved.original_model,+ model=request.model,)return _MessagesCompleteResult(optimized)diff --git a/src/free_claude_code/api/handlers/responses.py b/src/free_claude_code/api/handlers/responses.pyindex ac0eda59..d2e9380d 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,15 +18,17 @@ 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,+ ResponsesConversionError,iter_responses_sse_from_events,+ openai_error_payload,openai_error_type_for_failure,openai_failure_payload,+ responses_to_inference_request,)@@ -40,13 +41,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,@@ -66,12 +65,8 @@ class ResponsesHandler:)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)+ ingress = responses_to_inference_request(request_data)+ routed = self._model_router.resolve_inference_request(ingress.request)streamed = self._provider_executor.stream(routed,@@ -83,7 +78,7 @@ class ResponsesHandler:return await openai_responses_sse_streaming_response(iter_responses_sse_from_events(streamed,- request_data,+ ingress.presentation,on_post_start_terminal_failure=lambda exc: (self._trace_post_start_terminal_failure(exc,@@ -91,12 +86,12 @@ class ResponsesHandler:)),),- headers=self._responses_adapter.sse_headers,+ headers=OPENAI_RESPONSES_SSE_HEADERS,pre_start_error_response=lambda exc: self._pre_start_error_response(exc, request_id=request_id),)- except OpenAIResponsesAdapter.ConversionError as exc:+ except ResponsesConversionError as exc:raise InvalidRequestError(str(exc)) from excexcept ApplicationError:raise@@ -113,7 +108,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",),@@ -147,7 +142,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",),diff --git a/src/free_claude_code/api/handlers/token_count.py b/src/free_claude_code/api/handlers/token_count.pyindex f2bea621..dc3d53ef 100644--- a/src/free_claude_code/api/handlers/token_count.py+++ b/src/free_claude_code/api/handlers/token_count.py@@ -9,17 +9,20 @@ from free_claude_code.api.request_errors import (require_non_empty_messages,)from free_claude_code.api.request_ids import new_request_id-from free_claude_code.application.errors import ApplicationError+from free_claude_code.application.errors import ApplicationError, InvalidRequestErrorfrom free_claude_code.application.execution import TokenCounterfrom free_claude_code.application.routing import ModelRouterfrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import (TokenCountRequest,TokenCountResponse,- anthropic_request_snapshot,- get_token_count,+ token_count_to_inference_request,)from free_claude_code.core.diagnostics import safe_exception_message+from free_claude_code.core.inference import (+ get_inference_token_count,+ inference_request_snapshot,+)from free_claude_code.core.trace import trace_event@@ -31,7 +34,7 @@ class TokenCountHandler:settings: Settings,*,model_router: ModelRouter | None = None,- token_counter: TokenCounter = get_token_count,+ token_counter: TokenCounter = get_inference_token_count,) -> None:self._settings = settingsself._model_router = model_router or ModelRouter(settings)@@ -45,10 +48,12 @@ class TokenCountHandler:with logger.contextualize(request_id=request_id):try:require_non_empty_messages(request_data.messages)- routed = self._model_router.resolve_token_count_request(request_data)- tokens = self._token_counter(- routed.request.messages, routed.request.system, routed.request.tools- )+ try:+ canonical = token_count_to_inference_request(request_data)+ except ValueError as exc:+ raise InvalidRequestError(str(exc)) from exc+ routed = self._model_router.resolve_token_count_request(canonical)+ tokens = self._token_counter(routed.request)trace_event(stage="routing",event="free_claude_code.api.route.resolved",@@ -60,14 +65,13 @@ class TokenCountHandler:provider_model_ref=routed.resolved.primary.provider_model_ref,gateway_model=routed.resolved.original_model,)- request_snapshot = anthropic_request_snapshot(routed.request)- request_snapshot["model"] = routed.resolved.original_model+ request_snapshot = inference_request_snapshot(routed.request)trace_event(stage="ingress",event="free_claude_code.api.count_tokens.completed",source="api",request_id=request_id,- message_count=len(routed.request.messages),+ message_count=routed.request.message_count,input_tokens=tokens,snapshot=request_snapshot,)diff --git a/src/free_claude_code/api/routes.py b/src/free_claude_code/api/routes.pyindex e1db53bb..57bc7c6b 100644--- a/src/free_claude_code/api/routes.py+++ b/src/free_claude_code/api/routes.py@@ -10,8 +10,8 @@ from free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import (MessagesRequest,TokenCountRequest,- get_token_count,)+from free_claude_code.core.inference import get_inference_token_countfrom free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.trace import trace_event@@ -51,7 +51,7 @@ async def _create_messages_response(handler = MessagesHandler(lease.settings,provider_resolver=_provider_resolver(lease),- token_counter=get_token_count,+ token_counter=get_inference_token_count,generation_id=lease.generation_id,)response = await handler.create(request_data, request_id=request_id)@@ -154,7 +154,7 @@ async def count_tokens(_auth=Depends(require_proxy_auth),):"""Count tokens for a request."""- handler = TokenCountHandler(settings, token_counter=get_token_count)+ handler = TokenCountHandler(settings, token_counter=get_inference_token_count)return handler.count(request_data, request_id=get_request_id(request))diff --git a/src/free_claude_code/api/web_tools/automatic_search.py b/src/free_claude_code/api/web_tools/automatic_search.pyindex 6652ce16..1ee25e7f 100644--- a/src/free_claude_code/api/web_tools/automatic_search.py+++ b/src/free_claude_code/api/web_tools/automatic_search.py@@ -2,11 +2,10 @@import sysfrom collections.abc import AsyncIterator, Mapping-from dataclasses import replacefrom urllib.parse import urlsplitfrom free_claude_code.application.execution import ProviderExecutor-from free_claude_code.application.routing import RoutedMessagesRequest+from free_claude_code.application.routing import RoutedInferenceRequestfrom free_claude_code.core.anthropic import (aggregate_inference_events_to_message,iter_anthropic_sse,@@ -25,7 +24,7 @@ from .streaming import stream_selected_web_search_responseasync def stream_automatic_web_search_response(provider_executor: ProviderExecutor,- routed: RoutedMessagesRequest,+ routed: RoutedInferenceRequest,plan: AutomaticWebSearchPlan,*,request_id: str,@@ -34,7 +33,6 @@ async def stream_automatic_web_search_response(log_raw_events: bool,) -> AsyncIterator[str]:"""Buffer one model decision, then replay it or execute one local search."""- translated = replace(routed, request=plan.request)trace_event(stage="routing",event="free_claude_code.api.web_search.automatic_recognized",@@ -43,7 +41,7 @@ async def stream_automatic_web_search_response(model=routed.resolved.original_model,)provider_stream = provider_executor.stream(- translated,+ routed,wire_api="messages",raw_log_label="FULL_PAYLOAD",raw_log_payload=plan.request.model_dump(),diff --git a/src/free_claude_code/application/execution.py b/src/free_claude_code/application/execution.pyindex 42bf552b..ad105e08 100644--- a/src/free_claude_code/application/execution.py+++ b/src/free_claude_code/application/execution.py@@ -8,15 +8,14 @@ from typing import Literalfrom loguru import logger-from free_claude_code.core.anthropic import (- Message,- SystemContent,- Tool,- anthropic_request_snapshot,- get_token_count,-)from free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.inference import InferenceEvent, inference_event_size+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ get_inference_token_count,+ inference_event_size,+ inference_request_snapshot,+)from free_claude_code.core.trace import (close_stream_input,trace_event,@@ -24,24 +23,21 @@ from free_claude_code.core.trace import ()from .ports import ProviderResolver-from .routing import ProviderModelTarget, RoutedMessagesRequest+from .routing import ProviderModelTarget, RoutedInferenceRequest-TokenCounter = Callable[- [list[Message], str | list[SystemContent] | None, list[Tool] | None],- int,-]+TokenCounter = Callable[[InferenceRequest], int]WireApi = Literal["messages", "responses"]class ProviderExecutor:- """Resolve a provider and execute one routed Anthropic Messages stream."""+ """Resolve a provider and execute one routed canonical inference stream."""def __init__(self,provider_resolver: ProviderResolver,*,progress_timeout_seconds: float,- token_counter: TokenCounter = get_token_count,+ token_counter: TokenCounter = get_inference_token_count,generation_id: int | None = None,log_raw_payloads: bool = False,) -> None:@@ -143,7 +139,7 @@ class ProviderExecutor:def stream(self,- routed: RoutedMessagesRequest,+ routed: RoutedInferenceRequest,*,wire_api: WireApi,raw_log_label: str,@@ -153,9 +149,9 @@ class ProviderExecutor:"""Preflight synchronously, then return the traced provider stream."""primary = routed.resolved.primaryprimary_provider = self._provider_resolver(primary.provider_id)- primary_request = routed.request.model_copy(deep=True)primary_provider.preflight_stream(- primary_request,+ routed.request,+ provider_model=primary.provider_model,reasoning=routed.reasoning,)candidates = (primary, *routed.resolved.fallbacks)@@ -185,8 +181,7 @@ class ProviderExecutor:route_trace["generation_id"] = self._generation_idtrace_event(**route_trace)- request_snapshot = anthropic_request_snapshot(routed.request)- request_snapshot["model"] = gateway_model+ request_snapshot = inference_request_snapshot(routed.request)trace_event(stage="ingress",event=(@@ -195,7 +190,7 @@ class ProviderExecutor:else "free_claude_code.api.request.received"),source="api",- message_count=len(routed.request.messages),+ message_count=routed.request.message_count,snapshot=request_snapshot,request_id=request_id,)@@ -203,11 +198,7 @@ class ProviderExecutor: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,- )+ input_tokens = self._token_counter(routed.request)async def provider_body() -> AsyncIterator[InferenceEvent]:loop = asyncio.get_running_loop()@@ -218,17 +209,10 @@ class ProviderExecutor:if index == 0else 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,+ routed.request,+ provider_model=target.provider_model,reasoning=routed.reasoning,)@@ -237,7 +221,8 @@ class ProviderExecutor:advance_failure: ExecutionFailure | None = Nonetry:provider_stream = provider.stream_response(- candidate_request,+ routed.request,+ provider_model=target.provider_model,input_tokens=input_tokens,request_id=request_id,response_model=gateway_model,diff --git a/src/free_claude_code/application/ports.py b/src/free_claude_code/application/ports.pyindex 3e8b8196..d0aa03f7 100644--- a/src/free_claude_code/application/ports.py+++ b/src/free_claude_code/application/ports.py@@ -5,8 +5,7 @@ from dataclasses import dataclassfrom typing import Protocolfrom free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import MessagesRequest-from free_claude_code.core.inference import InferenceEvent+from free_claude_code.core.inference import InferenceEvent, InferenceRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom .model_metadata import ProviderModelInfo@@ -17,15 +16,17 @@ class ProviderPort(Protocol):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None: ...def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,input_tokens: int,request_id: str,response_model: str,diff --git a/src/free_claude_code/application/reasoning.py b/src/free_claude_code/application/reasoning.pyindex 14a5411b..dd0708d4 100644--- a/src/free_claude_code/application/reasoning.py+++ b/src/free_claude_code/application/reasoning.py@@ -1,9 +1,7 @@"""Resolve client reasoning input and FCC configuration exactly once."""-from collections.abc import Mapping-from free_claude_code.config.reasoning import ReasoningPreference-from free_claude_code.core.anthropic.models import MessagesRequest, ThinkingConfig+from free_claude_code.core.inference import ClientReasoningIntentfrom free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,@@ -12,7 +10,7 @@ from free_claude_code.core.reasoning import (def resolve_reasoning_policy(- request: MessagesRequest,+ intent: ClientReasoningIntent,preference: ReasoningPreference,) -> ReasoningPolicy:"""Apply one resolved configuration preference to the client request."""@@ -23,76 +21,23 @@ def resolve_reasoning_policy(return ReasoningPolicy.off()if preference is not ReasoningPreference.CLIENT:return ReasoningPolicy.on(effort=ReasoningEffort(preference.value))- return client_reasoning_policy(request)+ return client_reasoning_policy(intent)-def client_reasoning_policy(request: MessagesRequest) -> ReasoningPolicy:+def client_reasoning_policy(intent: ClientReasoningIntent) -> ReasoningPolicy:"""Return the lossless reasoning intent expressed by one client request."""- budget_tokens = _positive_budget(request.thinking)- thinking_control = _thinking_control(- request.thinking,- budget_tokens=budget_tokens,- )- effort, effort_disables = _output_effort(request.output_config)-- if effort_disables:- return ReasoningPolicy.off()- if thinking_control is ReasoningControl.OFF:+ if intent.control is ReasoningControl.OFF:return ReasoningPolicy(control=ReasoningControl.OFF,- effort=effort,+ effort=intent.effort,)- if thinking_control is ReasoningControl.ON or budget_tokens is not None:+ if intent.control is ReasoningControl.ON or intent.budget_tokens is not None:return ReasoningPolicy.on(- effort=effort,- budget_tokens=budget_tokens,+ effort=intent.effort,+ budget_tokens=intent.budget_tokens,)return ReasoningPolicy(control=ReasoningControl.DEFAULT,- effort=effort,+ effort=intent.effort,)---def _thinking_control(- thinking: ThinkingConfig | None,- *,- budget_tokens: int | None,-) -> ReasoningControl:- if thinking is None:- return ReasoningControl.DEFAULT- if thinking.type == "disabled" or (- "enabled" in thinking.model_fields_set and thinking.enabled is False- ):- return ReasoningControl.OFF- if (- thinking.type in {"adaptive", "enabled"}- or ("enabled" in thinking.model_fields_set and thinking.enabled is True)- or budget_tokens is not None- ):- return ReasoningControl.ON- return ReasoningControl.DEFAULT---def _output_effort(value: object) -> tuple[ReasoningEffort | None, bool]:- if not isinstance(value, Mapping):- return None, False- raw = value.get("effort")- if not isinstance(raw, str):- return None, False- normalized = raw.strip().lower()- if normalized == "none":- return None, True- try:- return ReasoningEffort(normalized), False- except ValueError:- return None, False---def _positive_budget(thinking: ThinkingConfig | None) -> int | None:- if thinking is None:- return None- value = thinking.budget_tokens- if isinstance(value, int) and not isinstance(value, bool) and value > 0:- return value- return Nonediff --git a/src/free_claude_code/application/routing.py b/src/free_claude_code/application/routing.pyindex 37b6a85e..fe7a2a56 100644--- a/src/free_claude_code/application/routing.py+++ b/src/free_claude_code/application/routing.py@@ -1,4 +1,4 @@-"""Model routing for Claude-compatible requests."""+"""Provider model routing for canonical inference requests."""from dataclasses import dataclass@@ -12,8 +12,8 @@ from free_claude_code.config.provider_catalog import ()from free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.config.settings import Settings-from 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.inference import InferenceRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom .reasoning import resolve_reasoning_policy@@ -46,15 +46,15 @@ class ResolvedModelRoute:@dataclass(frozen=True, slots=True)-class RoutedMessagesRequest:- request: MessagesRequest+class RoutedInferenceRequest:+ request: InferenceRequestresolved: ResolvedModelRoutereasoning: ReasoningPolicy@dataclass(frozen=True, slots=True)class RoutedTokenCountRequest:- request: TokenCountRequest+ request: InferenceRequestresolved: ResolvedModelRoute@@ -187,28 +187,23 @@ class ModelRouter:None,)- def resolve_messages_request(- self, request: MessagesRequest- ) -> RoutedMessagesRequest:+ def resolve_inference_request(+ self, request: InferenceRequest+ ) -> RoutedInferenceRequest:"""Return an internal routed request context."""resolved = self.resolve(request.model)- routed = request.model_copy(deep=True)- routed.model = resolved.primary.provider_model- return RoutedMessagesRequest(- request=routed,+ return RoutedInferenceRequest(+ request=request,resolved=resolved,reasoning=resolve_reasoning_policy(- routed,+ request.reasoning,resolved.reasoning_preference,),)def resolve_token_count_request(- self, request: TokenCountRequest+ self, request: InferenceRequest) -> RoutedTokenCountRequest:"""Return an internal token-count request context."""resolved = self.resolve(request.model)- routed = request.model_copy(- update={"model": resolved.primary.provider_model}, deep=True- )- return RoutedTokenCountRequest(request=routed, resolved=resolved)+ return RoutedTokenCountRequest(request=request, resolved=resolved)diff --git a/src/free_claude_code/core/anthropic/__init__.py b/src/free_claude_code/core/anthropic/__init__.pyindex b0a88fe1..d71ba752 100644--- a/src/free_claude_code/core/anthropic/__init__.py+++ b/src/free_claude_code/core/anthropic/__init__.py@@ -1,19 +1,18 @@"""Anthropic protocol helpers shared across API, providers, and integrations."""from .content import extract_text_from_content, get_block_attr, get_block_type-from .conversion import (- AnthropicToOpenAIConverter,- OpenAIConversionError,- ReasoningReplayMode,- build_base_request_body,- is_synthetic_openai_tool_turn_boundary,-)from .errors import (anthropic_error_payload,anthropic_error_type_for_failure,anthropic_failure_payload,anthropic_status_for_error_type,)+from .ingress import (+ AnthropicIngressError,+ messages_to_inference_request,+ token_count_to_inference_request,+ validate_messages_field_policy,+)from .models import (ContentBlockDocument,ContentBlockImage,@@ -35,27 +34,23 @@ from .models import (Tool,Usage,)-from .openai_tool_names import OpenAIToolNameCodecfrom .presenter import (AnthropicEventPresenter,aggregate_inference_events_to_message,iter_anthropic_sse,)-from .request_serialization import dump_messages_request, serialize_tool_result_content-from .request_snapshot import anthropic_request_snapshotfrom .sse_aggregation import aggregate_anthropic_sse_to_messagefrom .streaming import (format_sse_event,map_stop_reason,)from .thinking import ContentChunk, ContentType, ThinkTagParser-from .tokens import get_token_count-from .tools import FunctionTagToolParser, HeuristicToolParser+from .tools import HeuristicToolParserfrom .utils import set_if_not_none__all__ = ["AnthropicEventPresenter",- "AnthropicToOpenAIConverter",+ "AnthropicIngressError","ContentBlockDocument","ContentBlockImage","ContentBlockRedactedThinking",@@ -68,14 +63,10 @@ __all__ = ["ContentBlockWebSearchToolResult","ContentChunk","ContentType",- "FunctionTagToolParser","HeuristicToolParser","Message","MessagesRequest","MessagesResponse",- "OpenAIConversionError",- "OpenAIToolNameCodec",- "ReasoningReplayMode","SystemContent","ThinkTagParser","ThinkingConfig",@@ -88,18 +79,15 @@ __all__ = ["anthropic_error_payload","anthropic_error_type_for_failure","anthropic_failure_payload",- "anthropic_request_snapshot","anthropic_status_for_error_type",- "build_base_request_body",- "dump_messages_request","extract_text_from_content","format_sse_event","get_block_attr","get_block_type",- "get_token_count",- "is_synthetic_openai_tool_turn_boundary","iter_anthropic_sse","map_stop_reason",- "serialize_tool_result_content",+ "messages_to_inference_request","set_if_not_none",+ "token_count_to_inference_request",+ "validate_messages_field_policy",]diff --git a/src/free_claude_code/core/anthropic/conversion.py b/src/free_claude_code/core/anthropic/conversion.pydeleted file mode 100644index 24cc0bb2..00000000--- a/src/free_claude_code/core/anthropic/conversion.py+++ /dev/null@@ -1,794 +0,0 @@-"""Message and tool format converters."""--import json-from copy import deepcopy-from dataclasses import dataclass, field-from enum import StrEnum-from typing import Any--from .content import get_block_attr, get_block_type-from .models import MessagesRequest-from .request_serialization import serialize_tool_result_content-from .utils import set_if_not_none---class OpenAIConversionError(Exception):- """Raised when Anthropic content cannot be converted to OpenAI chat without data loss."""---class ReasoningReplayMode(StrEnum):- """How assistant reasoning history is replayed to OpenAI-compatible providers."""-- DISABLED = "disabled"- THINK_TAGS = "think_tags"- REASONING_CONTENT = "reasoning_content"- REASONING = "reasoning"---def resolve_anthropic_tool_choice(- tools: list[Any] | None,- tool_choice: dict[str, Any] | None,-) -> dict[str, Any] | None:- """Materialize Anthropic's automatic choice when tools are available."""- if tool_choice is not None:- return tool_choice- if tools:- return {"type": "auto"}- return None---def _reasoning_replay_field(mode: ReasoningReplayMode) -> str | None:- if mode in (- ReasoningReplayMode.REASONING_CONTENT,- ReasoningReplayMode.REASONING,- ):- return mode.value- return None---def _set_replayed_reasoning(- message: dict[str, Any], reasoning: str, mode: ReasoningReplayMode-) -> None:- field_name = _reasoning_replay_field(mode)- if field_name is not None:- message[field_name] = reasoning---def _openai_reject_native_only_top_level_fields(- request_data: MessagesRequest,-) -> None:- """OpenAI chat providers may only convert known top-level request fields.-- First-class model fields (e.g. ``context_management``) are not forwarded to- the OpenAI API but are allowed so clients do not hit spurious 400s.- Unknown extra keys (``__pydantic_extra__``) are still rejected.- """- extra = request_data.model_extra- if not extra:- return- raise OpenAIConversionError(- "OpenAI chat conversion does not support these top-level request fields: "- f"{sorted(str(k) for k in extra)}. Remove the unsupported fields."- )---def _tool_input_schema(tool: Any) -> dict[str, Any]:- schema = getattr(tool, "input_schema", None)- if isinstance(schema, dict):- return schema- return {"type": "object", "properties": {}}---def _clean_reasoning_content(value: Any) -> str | None:- if not isinstance(value, str):- return None- return value---def _think_tag_content(reasoning: str) -> str:- return f"<think>\n{reasoning}\n</think>"---def _tool_call_from_tool_use(block: Any) -> dict[str, Any]:- tool_input = get_block_attr(block, "input", {})- tool_call: dict[str, Any] = {- "id": get_block_attr(block, "id"),- "type": "function",- "function": {- "name": get_block_attr(block, "name"),- "arguments": json.dumps(tool_input)- if isinstance(tool_input, dict)- else str(tool_input),- },- }- extra_content = get_block_attr(block, "extra_content", None)- if isinstance(extra_content, dict) and extra_content:- tool_call["extra_content"] = deepcopy(extra_content)- return tool_call---@dataclass-class _PlainSegment:- messages: list[dict[str, Any]]---@dataclass-class _ToolTurnSegment:- assistant_message: dict[str, Any]- required_tool_ids: list[str]- deferred_blocks: list[Any] = field(default_factory=list)- top_level_reasoning: str | None = None- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS- assistant_emitted: bool = False---_TranscriptSegment = _PlainSegment | _ToolTurnSegment---def _tool_call_ids(tool_calls: list[dict[str, Any]]) -> list[str]:- ids: list[str] = []- for tool_call in tool_calls:- tool_id = tool_call.get("id")- if tool_id is not None and str(tool_id).strip() != "":- ids.append(str(tool_id))- return ids---def _index_first_tool_use(blocks: list[Any]) -> int | None:- for i, block in enumerate(blocks):- if get_block_type(block) == "tool_use":- return i- return None---def _iter_tool_uses_in_order(blocks: list[Any]) -> list[dict[str, Any]]:- return [- _tool_call_from_tool_use(block)- for block in blocks- if get_block_type(block) == "tool_use"- ]---def _deferred_post_tool_blocks(- content: list[Any], *, first_tool_index: int-) -> list[Any]:- return [- b- for i, b in enumerate(content)- if i > first_tool_index and get_block_type(b) != "tool_use"- ]---def _assert_no_forbidden_assistant_block(block: Any) -> None:- block_type = get_block_type(block)- if block_type == "image":- raise OpenAIConversionError(- "Assistant image blocks are not supported for OpenAI chat conversion."- )- if block_type in (- "server_tool_use",- "web_search_tool_result",- "web_fetch_tool_result",- ):- raise OpenAIConversionError(- "OpenAI chat conversion does not support Anthropic server tool blocks "- f"({block_type!r} in an assistant message). Remove the unsupported block."- )---def _openai_system_text(- content: Any,- *,- context: str,-) -> str | None:- """Return OpenAI-compatible system text without silently dropping blocks."""- if isinstance(content, str):- return content- if not isinstance(content, list):- raise OpenAIConversionError(- f"OpenAI chat conversion requires {context} content to be text."- )- if not content:- return None-- text_parts: list[str] = []- for block in content:- block_type = get_block_type(block)- if block_type != "text":- raise OpenAIConversionError(- f"OpenAI chat conversion cannot represent {context} content block "- f"{block_type!r} without data loss."- )- text_parts.append(str(get_block_attr(block, "text", "")))-- return "\n\n".join(text_parts)---def _openai_user_image_part(block: Any) -> dict[str, Any]:- """Convert one Anthropic user image block without performing I/O."""- source = get_block_attr(block, "source", {})- source_type = get_block_attr(source, "type")-- if source_type == "base64":- media_type = get_block_attr(source, "media_type")- if not isinstance(media_type, str) or not media_type.strip():- raise OpenAIConversionError(- "Base64 image source requires a non-empty media_type."- )- data = get_block_attr(source, "data")- if not isinstance(data, str) or not data.strip():- raise OpenAIConversionError("Base64 image source requires non-empty data.")- url = f"data:{media_type};base64,{data}"- elif source_type == "url":- url = get_block_attr(source, "url")- if not isinstance(url, str) or not url.strip():- raise OpenAIConversionError("URL image source requires a non-empty url.")- else:- raise OpenAIConversionError(- f"Unsupported image source type {source_type!r}; expected 'base64' or 'url'."- )-- return {"type": "image_url", "image_url": {"url": url}}---def _openai_user_content_parts(content: Any) -> list[dict[str, Any]]:- """Return an owned content-part list for one converted user message."""- if isinstance(content, str):- return [{"type": "text", "text": content}]- if isinstance(content, list) and all(isinstance(part, dict) for part in content):- return deepcopy(content)- raise OpenAIConversionError(- "OpenAI chat conversion produced unsupported user message content."- )---def _merge_openai_user_content(first: Any, second: Any) -> str | list[dict[str, Any]]:- """Combine adjacent user content while preserving multimodal part order."""- if isinstance(first, str) and isinstance(second, str):- return f"{first}\n\n{second}"-- first_parts = _openai_user_content_parts(first)- second_parts = _openai_user_content_parts(second)- first_ends_in_text = bool(first_parts) and first_parts[-1].get("type") == "text"- second_starts_with_text = (- bool(second_parts) and second_parts[0].get("type") == "text"- )- if first_ends_in_text and second_starts_with_text:- first_text = first_parts[-1].get("text", "")- second_text = second_parts.pop(0).get("text", "")- first_parts[-1]["text"] = f"{first_text}\n\n{second_text}"- return [*first_parts, *second_parts]---def _coalesce_openai_user_messages(- messages: list[dict[str, Any]],-) -> list[dict[str, Any]]:- """Combine adjacent user messages after transcript ordering is complete."""- result: list[dict[str, Any]] = []- for message in messages:- if (- message.get("role") == "user"- and result- and result[-1].get("role") == "user"- ):- previous = result[-1]- previous["content"] = _merge_openai_user_content(- previous.get("content"), message.get("content")- )- continue- result.append(message)- return result---class _SyntheticOpenAIToolTurnBoundary(dict[str, Any]):- """Identify an FCC-inserted assistant boundary until wire serialization."""-- __slots__ = ()---def is_synthetic_openai_tool_turn_boundary(message: object) -> bool:- """Return whether FCC inserted this message to close an OpenAI tool turn."""- return isinstance(message, _SyntheticOpenAIToolTurnBoundary)---def _close_openai_tool_result_turns(- messages: list[dict[str, Any]],-) -> list[dict[str, Any]]:- """Close completed tool rounds before subsequent user input."""- result: list[dict[str, Any]] = []- for message in messages:- if (- message.get("role") == "user"- and result- and result[-1].get("role") == "tool"- ):- # Some OpenAI-compatible chat templates reject a user role directly- # after tool output. Non-empty whitespace closes the assistant turn- # without inventing model content.- result.append(- _SyntheticOpenAIToolTurnBoundary(role="assistant", content=" ")- )- result.append(message)- return result---class _OpenAIChatHistoryLedger:- """Assemble OpenAI chat history while respecting tool-result dependencies."""-- def __init__(self) -> None:- self._output: list[dict[str, Any]] = []- self._segments: list[_TranscriptSegment] = []- self._tool_results: dict[str, dict[str, Any]] = {}-- def add_plain(self, messages: list[dict[str, Any]]) -> None:- if messages:- self._segments.append(_PlainSegment(messages))- self._drain_ready_segments()-- def add_tool_turn(self, segment: _ToolTurnSegment) -> None:- self._segments.append(segment)- self._drain_ready_segments()-- def add_user_blocks(self, blocks: list[Any]) -> None:- text_blocks: list[Any] = []- for block in blocks:- block_type = get_block_type(block)- if block_type == "tool_result":- self._add_text_blocks(text_blocks)- self._record_tool_result(block)- else:- text_blocks.append(block)- self._add_text_blocks(text_blocks)- self._drain_ready_segments()-- def finish(self) -> list[dict[str, Any]]:- self._drain_ready_segments()- missing = self._missing_required_tool_ids()- if missing:- raise OpenAIConversionError(- "OpenAI chat conversion cannot replay incomplete tool history; "- f"missing tool_result blocks for tool_use ids: {missing}"- )- while self._segments:- segment = self._segments.pop(0)- if isinstance(segment, _PlainSegment):- self._output.extend(segment.messages)- continue- self._emit_tool_turn(segment)- return self._output-- def _add_text_blocks(self, blocks: list[Any]) -> None:- if not blocks:- return- self.add_plain(AnthropicToOpenAIConverter._convert_user_message(blocks))- blocks.clear()-- def _record_tool_result(self, block: Any) -> None:- tuid = get_block_attr(block, "tool_use_id")- tuid_s = str(tuid) if tuid is not None else ""- if not tuid_s:- self.add_plain(AnthropicToOpenAIConverter._convert_user_message([block]))- return- tool_content = get_block_attr(block, "content", "")- serialized = serialize_tool_result_content(tool_content)- tool_message = {- "role": "tool",- "tool_call_id": tuid,- "content": serialized if serialized else "",- }- if self._has_pending_tool_id(tuid_s):- self._tool_results[tuid_s] = tool_message- else:- self.add_plain([tool_message])-- def _drain_ready_segments(self) -> None:- while self._segments:- segment = self._segments[0]- if isinstance(segment, _PlainSegment):- self._output.extend(segment.messages)- self._segments.pop(0)- continue-- if not segment.assistant_emitted:- self._output.append(segment.assistant_message)- segment.assistant_emitted = True-- missing = [- tool_id- for tool_id in segment.required_tool_ids- if tool_id not in self._tool_results- ]- if missing:- break-- self._segments.pop(0)- for tool_id in segment.required_tool_ids:- self._output.append(self._tool_results.pop(tool_id))- deferred_messages = (- AnthropicToOpenAIConverter._deferred_post_tool_to_messages(segment)- )- self._output.extend(deferred_messages)-- def _emit_tool_turn(self, segment: _ToolTurnSegment) -> None:- if not segment.assistant_emitted:- self._output.append(segment.assistant_message)- segment.assistant_emitted = True- for tool_id in segment.required_tool_ids:- tool_result = self._tool_results.pop(tool_id, None)- if tool_result is not None:- self._output.append(tool_result)- self._output.extend(- AnthropicToOpenAIConverter._deferred_post_tool_to_messages(segment)- )-- def _missing_required_tool_ids(self) -> list[str]:- missing: list[str] = []- for segment in self._segments:- if not isinstance(segment, _ToolTurnSegment):- continue- missing.extend(- tool_id- for tool_id in segment.required_tool_ids- if tool_id not in self._tool_results- )- return missing-- def _has_pending_tool_id(self, tool_id: str) -> bool:- return any(- isinstance(segment, _ToolTurnSegment)- and tool_id in segment.required_tool_ids- for segment in self._segments- )---class AnthropicToOpenAIConverter:- """Convert Anthropic message format to OpenAI-compatible format."""-- @staticmethod- def convert_messages(- messages: list[Any],- *,- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,- ) -> list[dict[str, Any]]:- ledger = _OpenAIChatHistoryLedger()-- for msg in messages:- role = msg.role- content = msg.content- reasoning_content = _clean_reasoning_content(- getattr(msg, "reasoning_content", None)- )-- if role == "user" and isinstance(content, list):- ledger.add_user_blocks(content)- continue-- segments = AnthropicToOpenAIConverter._convert_message_to_segments(- role,- content,- reasoning_content=reasoning_content,- reasoning_replay=reasoning_replay,- )- for segment in segments:- if isinstance(segment, _PlainSegment):- ledger.add_plain(segment.messages)- else:- ledger.add_tool_turn(segment)-- ordered_messages = ledger.finish()- closed_messages = _close_openai_tool_result_turns(ordered_messages)- return _coalesce_openai_user_messages(closed_messages)-- @staticmethod- def _convert_message_to_segments(- role: str,- content: Any,- *,- reasoning_content: str | None,- reasoning_replay: ReasoningReplayMode,- ) -> list[_TranscriptSegment]:- if role == "system":- system_text = _openai_system_text(- content,- context="an inline Anthropic system message",- )- if system_text is None:- raise OpenAIConversionError(- "OpenAI chat conversion requires an inline Anthropic system "- "message to contain text."- )- # Reserve the downstream system role for request.system at index zero.- return [_PlainSegment([{"role": "user", "content": system_text}])]- if role == "assistant" and isinstance(content, list):- if (first_i := _index_first_tool_use(content)) is not None:- for block in content:- if get_block_type(block) == "tool_use":- continue- _assert_no_forbidden_assistant_block(block)- return [- AnthropicToOpenAIConverter._convert_assistant_message_with_split(- content,- first_tool_index=first_i,- reasoning_content=reasoning_content,- reasoning_replay=reasoning_replay,- )- ]- for block in content:- _assert_no_forbidden_assistant_block(block)- return [- _PlainSegment(- AnthropicToOpenAIConverter._convert_assistant_message(- content,- reasoning_content=reasoning_content,- reasoning_replay=reasoning_replay,- )- )- ]- if role == "user" and isinstance(content, list):- return [- _PlainSegment(AnthropicToOpenAIConverter._convert_user_message(content))- ]- if isinstance(content, str):- converted = {"role": role, "content": content}- if role == "assistant" and reasoning_content is not None:- if _reasoning_replay_field(reasoning_replay) is not None:- _set_replayed_reasoning(- converted, reasoning_content, reasoning_replay- )- elif (- reasoning_replay == ReasoningReplayMode.THINK_TAGS- and reasoning_content- ):- content_parts = [_think_tag_content(reasoning_content)]- if content:- content_parts.append(content)- converted["content"] = "\n\n".join(content_parts)- return [_PlainSegment([converted])]- if isinstance(content, list):- return []- return [_PlainSegment([{"role": role, "content": str(content)}])]-- @staticmethod- def _convert_assistant_message_with_split(- content: list[Any],- *,- first_tool_index: int,- reasoning_content: str | None,- reasoning_replay: ReasoningReplayMode,- ) -> _ToolTurnSegment:- pre = content[:first_tool_index]- tool_calls = _iter_tool_uses_in_order(content)- if not tool_calls:- return _ToolTurnSegment(- assistant_message=AnthropicToOpenAIConverter._convert_assistant_message(- content,- reasoning_content=reasoning_content,- reasoning_replay=reasoning_replay,- )[0],- required_tool_ids=[],- )- deferred_blocks = _deferred_post_tool_blocks(- content, first_tool_index=first_tool_index- )-- pre_msg: dict[str, Any]- if not pre:- pre_msg = {- "role": "assistant",- "content": "",- }- if reasoning_content is not None:- _set_replayed_reasoning(pre_msg, reasoning_content, reasoning_replay)- else:- pre_msg = AnthropicToOpenAIConverter._convert_assistant_message(- pre,- reasoning_content=reasoning_content,- reasoning_replay=reasoning_replay,- )[0]- pre_msg["tool_calls"] = tool_calls- if reasoning_replay is ReasoningReplayMode.REASONING_CONTENT:- pre_msg.setdefault("reasoning_content", "")- if tool_calls and pre_msg.get("content") == " ":- pre_msg["content"] = ""- return _ToolTurnSegment(- assistant_message=pre_msg,- required_tool_ids=_tool_call_ids(tool_calls),- deferred_blocks=deferred_blocks,- top_level_reasoning=reasoning_content,- reasoning_replay=reasoning_replay,- )-- @staticmethod- def _convert_assistant_message(- content: list[Any],- *,- reasoning_content: str | None = None,- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,- ) -> list[dict[str, Any]]:- content_parts: list[str] = []- thinking_parts: list[str] = []- thinking_seen = False- tool_calls: list[dict[str, Any]] = []- for block in content:- block_type = get_block_type(block)- if block_type == "text":- content_parts.append(get_block_attr(block, "text", ""))- elif block_type == "thinking":- if reasoning_replay == ReasoningReplayMode.DISABLED:- continue- thinking = get_block_attr(block, "thinking", "")- if reasoning_replay == ReasoningReplayMode.THINK_TAGS:- content_parts.append(_think_tag_content(thinking))- elif reasoning_content is None:- thinking_seen = True- thinking_parts.append(thinking)- elif block_type == "redacted_thinking":- # Opaque provider continuation data; do not materialize as model-visible text- # or native reasoning fields for OpenAI chat upstreams.- continue- elif block_type == "tool_use":- tool_calls.append(_tool_call_from_tool_use(block))- else:- _assert_no_forbidden_assistant_block(block)-- content_str = "\n\n".join(content_parts)- if not content_str and not tool_calls:- content_str = " "-- msg: dict[str, Any] = {- "role": "assistant",- "content": content_str,- }- if tool_calls:- msg["tool_calls"] = tool_calls- if _reasoning_replay_field(reasoning_replay) is not None:- if reasoning_content is not None:- _set_replayed_reasoning(msg, reasoning_content, reasoning_replay)- elif thinking_seen:- _set_replayed_reasoning(- msg, "\n".join(thinking_parts), reasoning_replay- )-- return [msg]-- @staticmethod- def _deferred_post_tool_to_messages(- pending: _ToolTurnSegment,- ) -> list[dict[str, Any]]:- if not pending.deferred_blocks:- return []- return AnthropicToOpenAIConverter._convert_assistant_message(- pending.deferred_blocks,- reasoning_content=pending.top_level_reasoning,- reasoning_replay=pending.reasoning_replay,- )-- @staticmethod- def _convert_user_message(content: list[Any]) -> list[dict[str, Any]]:- result: list[dict[str, Any]] = []- content_parts: list[dict[str, Any]] = []-- def flush_content() -> None:- if not content_parts:- return- if all(part["type"] == "text" for part in content_parts):- message_content: str | list[dict[str, Any]] = "\n".join(- part["text"] for part in content_parts- )- else:- message_content = list(content_parts)- result.append({"role": "user", "content": message_content})- content_parts.clear()-- for block in content:- block_type = get_block_type(block)-- if block_type == "text":- content_parts.append(- {"type": "text", "text": get_block_attr(block, "text", "")}- )- elif block_type == "image":- content_parts.append(_openai_user_image_part(block))- elif block_type == "tool_result":- flush_content()- tool_content = get_block_attr(block, "content", "")- serialized = serialize_tool_result_content(tool_content)- result.append(- {- "role": "tool",- "tool_call_id": get_block_attr(block, "tool_use_id"),- "content": serialized if serialized else "",- }- )-- flush_content()- return result-- @staticmethod- def convert_tools(tools: list[Any]) -> list[dict[str, Any]]:- return [- {- "type": "function",- "function": {- "name": tool.name,- "description": tool.description or "",- "parameters": _tool_input_schema(tool),- },- }- for tool in tools- ]-- @staticmethod- def convert_tool_choice(tool_choice: Any) -> Any:- if not isinstance(tool_choice, dict):- return tool_choice-- choice_type = tool_choice.get("type")- if choice_type == "tool":- name = tool_choice.get("name")- if name:- return {"type": "function", "function": {"name": name}}- if choice_type == "any":- return "required"- if choice_type in {"auto", "none", "required"}:- return choice_type- if choice_type == "function" and isinstance(tool_choice.get("function"), dict):- return tool_choice-- return tool_choice-- @staticmethod- def convert_system_prompt(system: Any) -> dict[str, str] | None:- if system is None:- return None- system_text = _openai_system_text(- system,- context="the top-level Anthropic system prompt",- )- if system_text is None:- return None- if isinstance(system, list):- system_text = system_text.strip()- return {"role": "system", "content": system_text}---def build_base_request_body(- request_data: MessagesRequest,- *,- default_max_tokens: int | None = None,- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,-) -> dict[str, Any]:- """Build the common parts of an OpenAI-format request body."""- _openai_reject_native_only_top_level_fields(request_data)- messages = AnthropicToOpenAIConverter.convert_messages(- request_data.messages,- reasoning_replay=reasoning_replay,- )-- system = request_data.system- if system:- system_msg = AnthropicToOpenAIConverter.convert_system_prompt(system)- if system_msg:- messages.insert(0, system_msg)-- body: dict[str, Any] = {"model": request_data.model, "messages": messages}-- max_tokens = request_data.max_tokens- set_if_not_none(body, "max_tokens", max_tokens or default_max_tokens)- set_if_not_none(body, "temperature", request_data.temperature)- set_if_not_none(body, "top_p", request_data.top_p)-- stop_sequences = request_data.stop_sequences- if stop_sequences:- body["stop"] = stop_sequences-- tools = request_data.tools- if tools:- body["tools"] = AnthropicToOpenAIConverter.convert_tools(tools)- tool_choice = resolve_anthropic_tool_choice(tools, request_data.tool_choice)- if tool_choice:- body["tool_choice"] = AnthropicToOpenAIConverter.convert_tool_choice(- tool_choice- )-- return bodydiff --git a/src/free_claude_code/core/anthropic/ingress.py b/src/free_claude_code/core/anthropic/ingress.pynew file mode 100644index 00000000..b051884b--- /dev/null+++ b/src/free_claude_code/core/anthropic/ingress.py@@ -0,0 +1,898 @@+"""Anthropic Messages ingress conversion to canonical inference semantics."""++from collections.abc import Mapping, Sequence+from typing import cast++from pydantic import BaseModel++from free_claude_code.core.inference import (+ Base64MediaSource,+ CacheControl,+ CacheControlType,+ CacheTTL,+ ClientReasoningIntent,+ DocumentContent,+ FileMediaSource,+ FunctionTool,+ ImageContent,+ InferenceItem,+ InferenceRequest,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MessageItem,+ MessageRole,+ OpenAIChatExtension,+ ReasoningItem,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolChoice,+ ToolChoiceMode,+ ToolResultItem,+ UrlMediaSource,+)+from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort+from free_claude_code.core.replay_envelope import (+ ReplayEnvelopeError,+ decode_replay_envelope,+)++from .models import (+ ContentBlockDocument,+ ContentBlockImage,+ ContentBlockRedactedThinking,+ ContentBlockServerToolUse,+ ContentBlockText,+ ContentBlockThinking,+ ContentBlockToolResult,+ ContentBlockToolUse,+ ContentBlockWebFetchToolResult,+ ContentBlockWebSearchToolResult,+ MessagesRequest,+ SystemContent,+ TokenCountRequest,+ Tool,+)++_NOOP_CONTEXT_EDIT = {"type": "clear_thinking_20251015", "keep": "all"}+_ALLOWED_BLOCK_EXTRAS = frozenset({"cache_control"})+++class AnthropicIngressError(ValueError):+ """An Anthropic request cannot be represented without semantic loss."""+++def messages_to_inference_request(request: MessagesRequest) -> InferenceRequest:+ """Validate and convert one Messages request exactly once."""++ validate_messages_field_policy(request)+ items = [*_system_items(request.system), *_message_items(request.messages)]+ tools = tuple(+ _function_tool(tool, index=index)+ for index, tool in enumerate(request.tools or ())+ )+ tool_choice, parallel_tool_calls = _tool_choice(request.tool_choice)+ extensions = (+ (OpenAIChatExtension(_json_object(request.extra_body, path="extra_body")),)+ if request.extra_body+ else ()+ )+ metadata = (+ _json_object(request.metadata, path="metadata")+ if request.metadata is not None+ else None+ )+ return InferenceRequest(+ model=request.model,+ items=tuple(items),+ tools=tools,+ tool_choice=tool_choice,+ parallel_tool_calls=parallel_tool_calls,+ max_output_tokens=request.max_tokens,+ temperature=request.temperature,+ top_p=request.top_p,+ top_k=request.top_k,+ stop_sequences=tuple(request.stop_sequences or ()),+ reasoning=_reasoning_intent(request),+ metadata=metadata,+ extensions=extensions,+ )+++def token_count_to_inference_request(request: TokenCountRequest) -> InferenceRequest:+ """Convert the token-count product through the same canonical transcript."""++ _validate_token_count_top_level(request)+ items = [*_system_items(request.system), *_message_items(request.messages)]+ tools = tuple(+ _function_tool(tool, index=index)+ for index, tool in enumerate(request.tools or ())+ )+ tool_choice, parallel_tool_calls = _tool_choice(request.tool_choice)+ return InferenceRequest(+ model=request.model,+ items=tuple(items),+ tools=tools,+ tool_choice=tool_choice,+ parallel_tool_calls=parallel_tool_calls,+ reasoning=_reasoning_intent(request),+ )+++def validate_messages_field_policy(request: MessagesRequest) -> None:+ """Validate protocol-wide policy before local Messages short circuits."""++ _validate_top_level(request)+ _validate_system(request.system)+ _validate_messages(request.messages)+ for index, tool in enumerate(request.tools or ()):+ _validate_wire_tool(tool, path=f"tools[{index}]")+ _tool_choice(request.tool_choice)+++def _validate_top_level(request: MessagesRequest) -> None:+ _reject_model_extras(request, path="request")+ _validate_thinking(request.thinking)+ _validate_common_controls(+ context_management=request.context_management,+ output_config=request.output_config,+ mcp_servers=request.mcp_servers,+ )+++def _validate_token_count_top_level(request: TokenCountRequest) -> None:+ _reject_model_extras(request, path="request")+ _validate_thinking(request.thinking)+ _validate_common_controls(+ context_management=request.context_management,+ output_config=request.output_config,+ mcp_servers=request.mcp_servers,+ )+ _validate_system(request.system)+ _validate_messages(request.messages)+ for index, tool in enumerate(request.tools or ()):+ _validate_tool(tool, path=f"tools[{index}]")+++def _validate_common_controls(+ *,+ context_management: dict[str, object] | None,+ output_config: dict[str, object] | None,+ mcp_servers: list[dict[str, object]] | None,+) -> None:+ if not _is_noop_context_management(context_management):+ raise AnthropicIngressError(+ "context_management contains unsupported active semantics"+ )+ if output_config:+ unsupported = sorted(str(key) for key in output_config if key != "effort")+ if unsupported:+ raise AnthropicIngressError(+ f"output_config.{unsupported[0]} is not supported"+ )+ _reasoning_effort(output_config.get("effort"), path="output_config.effort")+ if mcp_servers:+ raise AnthropicIngressError("mcp_servers must be omitted or empty")+++def _is_noop_context_management(value: Mapping[str, object] | None) -> bool:+ if not value:+ return True+ if set(value) != {"edits"}:+ return False+ edits = value.get("edits")+ return isinstance(edits, list) and all(edit == _NOOP_CONTEXT_EDIT for edit in edits)+++def _validate_thinking(value: BaseModel | None) -> None:+ if value is None:+ return+ extras = _block_extras(value)+ unknown = set(extras) - {"display"}+ if unknown:+ raise AnthropicIngressError(+ f"thinking.{sorted(str(key) for key in unknown)[0]} is not supported"+ )+ if "display" in extras and extras["display"] != "omitted":+ raise AnthropicIngressError(+ f"thinking.display has unsupported value {extras['display']!r}"+ )+ thinking_type = getattr(value, "type", None)+ if thinking_type not in {None, "adaptive", "disabled", "enabled"}:+ raise AnthropicIngressError(+ f"thinking.type has unsupported value {thinking_type!r}"+ )+++def _system_items(value: str | list[SystemContent] | None) -> list[InstructionItem]:+ if value is None:+ return []+ if isinstance(value, str):+ return [+ InstructionItem(+ text=value,+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ )+ ]+ return [+ InstructionItem(+ text=block.text,+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ cache_control=_cache_control(block, path=f"system[{index}]"),+ )+ for index, block in enumerate(value)+ ]+++def _message_items(messages: Sequence[object]) -> list[InferenceItem]:+ items: list[InferenceItem] = []+ for index, raw_message in enumerate(messages):+ role = getattr(raw_message, "role", None)+ content = getattr(raw_message, "content", None)+ reasoning_content = getattr(raw_message, "reasoning_content", None)+ turn_id = f"turn_{index}"+ path = f"messages[{index}]"+ if role == "system":+ items.extend(_inline_instruction_items(content, turn_id=turn_id, path=path))+ continue+ if role not in {"user", "assistant"}:+ raise AnthropicIngressError(f"{path}.role is unsupported")+ message_role = MessageRole(role)+ if role == "assistant" and isinstance(reasoning_content, str):+ items.append(ReasoningItem(turn_id=turn_id, reasoning=reasoning_content))+ if isinstance(content, str):+ items.append(+ MessageItem(+ turn_id=turn_id,+ role=message_role,+ content=(TextContent(content),),+ )+ )+ continue+ if not isinstance(content, list):+ raise AnthropicIngressError(f"{path}.content must be text or a list")+ for block_index, block in enumerate(content):+ block_path = f"{path}.content[{block_index}]"+ if isinstance(block, ContentBlockText):+ items.append(+ MessageItem(+ turn_id=turn_id,+ role=message_role,+ content=(+ TextContent(+ block.text,+ cache_control=_cache_control(block, path=block_path),+ ),+ ),+ )+ )+ elif isinstance(block, ContentBlockImage):+ if role != "user":+ raise AnthropicIngressError(+ f"{block_path} assistant images are not supported"+ )+ items.append(+ MessageItem(+ turn_id=turn_id,+ role=message_role,+ content=(+ ImageContent(+ _image_source(+ block.source, path=f"{block_path}.source"+ ),+ cache_control=_cache_control(block, path=block_path),+ ),+ ),+ )+ )+ elif isinstance(block, ContentBlockDocument):+ if role != "user":+ raise AnthropicIngressError(+ f"{block_path} assistant documents are not supported"+ )+ items.append(+ MessageItem(+ turn_id=turn_id,+ role=message_role,+ content=(+ DocumentContent(+ _document_source(+ block.source,+ path=f"{block_path}.source",+ ),+ cache_control=_cache_control(block, path=block_path),+ ),+ ),+ )+ )+ elif isinstance(block, ContentBlockThinking):+ if role != "assistant":+ raise AnthropicIngressError(+ f"{block_path} thinking requires an assistant message"+ )+ _cache_control(block, path=block_path)+ artifacts = _reasoning_carrier(+ block.signature,+ kind=ReplayArtifactKind.THINKING_SIGNATURE,+ path=f"{block_path}.signature",+ )+ items.append(+ ReasoningItem(+ turn_id=turn_id,+ reasoning=block.thinking,+ artifacts=artifacts,+ )+ )+ elif isinstance(block, ContentBlockRedactedThinking):+ if role != "assistant":+ raise AnthropicIngressError(+ f"{block_path} redacted_thinking requires an assistant message"+ )+ _cache_control(block, path=block_path)+ items.append(+ ReasoningItem(+ turn_id=turn_id,+ reasoning="",+ artifacts=_reasoning_carrier(+ block.data,+ kind=ReplayArtifactKind.REDACTED_THINKING,+ path=f"{block_path}.data",+ ),+ )+ )+ elif isinstance(block, ContentBlockToolUse):+ if role != "assistant":+ raise AnthropicIngressError(+ f"{block_path} tool_use requires an assistant message"+ )+ _cache_control(block, path=block_path)+ items.append(+ ToolCallItem(+ turn_id=turn_id,+ call_id=_non_empty(block.id, path=f"{block_path}.id"),+ kind=ToolCallKind.FUNCTION,+ name=_non_empty(block.name, path=f"{block_path}.name"),+ input=_json_object(block.input, path=f"{block_path}.input"),+ artifacts=_tool_artifacts(block, path=block_path),+ )+ )+ elif isinstance(block, ContentBlockToolResult):+ if role != "user":+ raise AnthropicIngressError(+ f"{block_path} tool_result requires a user message"+ )+ extras = _block_extras(block)+ unknown = set(extras) - {"cache_control", "is_error"}+ if unknown:+ raise AnthropicIngressError(+ f"{block_path}.{sorted(unknown)[0]} is not supported"+ )+ is_error = extras.get("is_error", False)+ if not isinstance(is_error, bool):+ raise AnthropicIngressError(+ f"{block_path}.is_error must be boolean"+ )+ items.append(+ ToolResultItem(+ turn_id=turn_id,+ call_id=_non_empty(+ block.tool_use_id,+ path=f"{block_path}.tool_use_id",+ ),+ content=_json_value(+ block.content, path=f"{block_path}.content"+ ),+ is_error=is_error,+ )+ )+ else:+ block_type = getattr(block, "type", type(block).__name__)+ raise AnthropicIngressError(+ f"{block_path} type {block_type!r} is not supported for provider execution"+ )+ return items+++def _inline_instruction_items(+ content: object,+ *,+ turn_id: str,+ path: str,+) -> list[InstructionItem]:+ if isinstance(content, str):+ return [+ InstructionItem(+ text=content,+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TRANSCRIPT,+ turn_id=turn_id,+ )+ ]+ if not isinstance(content, list):+ raise AnthropicIngressError(f"{path}.content must contain only text")+ items: list[InstructionItem] = []+ for index, block in enumerate(content):+ block_path = f"{path}.content[{index}]"+ if not isinstance(block, ContentBlockText):+ raise AnthropicIngressError(f"{block_path} must be a text block")+ items.append(+ InstructionItem(+ text=block.text,+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TRANSCRIPT,+ cache_control=_cache_control(block, path=block_path),+ turn_id=turn_id,+ )+ )+ return items+++def _function_tool(tool: Tool, *, index: int) -> FunctionTool:+ path = f"tools[{index}]"+ _validate_tool(tool, path=path)+ schema = tool.input_schema or {"type": "object", "properties": {}}+ extras = _block_extras(tool)+ strict = extras.get("strict", False)+ if not isinstance(strict, bool):+ raise AnthropicIngressError(f"{path}.strict must be boolean")+ return FunctionTool(+ name=_non_empty(tool.name, path=f"{path}.name"),+ description=tool.description,+ input_schema=_json_object(schema, path=f"{path}.input_schema"),+ strict=strict,+ cache_control=_cache_control(tool, path=path),+ )+++def _validate_tool(tool: Tool, *, path: str) -> None:+ if tool.type is not None:+ raise AnthropicIngressError(+ f"{path}.type {tool.type!r} is provider-managed and cannot be forwarded"+ )+ unknown = set(_block_extras(tool)) - {"cache_control", "strict"}+ if unknown:+ raise AnthropicIngressError(f"{path}.{sorted(unknown)[0]} is not supported")+ _cache_control(tool, path=path)+++def _validate_wire_tool(tool: Tool, *, path: str) -> None:+ """Validate a tool before local server-tool routing is known."""++ if tool.type is None:+ _validate_tool(tool, path=path)+ return+ if tool.type.startswith(("web_search_", "web_fetch_")):+ return+ raise AnthropicIngressError(+ f"{path}.type {tool.type!r} is provider-managed and cannot be forwarded"+ )+++def _tool_choice(+ value: dict[str, object] | None,+) -> tuple[ToolChoice | None, bool | None]:+ if value is None:+ return None, None+ if not isinstance(value, dict):+ raise AnthropicIngressError("tool_choice must be an object")+ choice_type = value.get("type")+ allowed = {"type", "name", "disable_parallel_tool_use"}+ unknown = set(value) - allowed+ if unknown:+ raise AnthropicIngressError(+ f"tool_choice.{sorted(str(key) for key in unknown)[0]} is not supported"+ )+ disable_parallel = value.get("disable_parallel_tool_use")+ if disable_parallel is not None and not isinstance(disable_parallel, bool):+ raise AnthropicIngressError(+ "tool_choice.disable_parallel_tool_use must be boolean"+ )+ parallel = None if disable_parallel is None else not disable_parallel+ if choice_type == "auto":+ return ToolChoice(ToolChoiceMode.AUTO), parallel+ if choice_type in {"any", "required"}:+ return ToolChoice(ToolChoiceMode.REQUIRED), parallel+ if choice_type == "none":+ return ToolChoice(ToolChoiceMode.NONE), parallel+ if choice_type == "tool":+ name = value.get("name")+ if not isinstance(name, str) or not name:+ raise AnthropicIngressError("tool_choice.name must be a non-empty string")+ return (+ ToolChoice(+ ToolChoiceMode.SPECIFIC,+ kind=ToolCallKind.FUNCTION,+ name=name,+ ),+ parallel,+ )+ raise AnthropicIngressError(f"tool_choice.type {choice_type!r} is not supported")+++def _reasoning_intent(+ request: MessagesRequest | TokenCountRequest,+) -> ClientReasoningIntent:+ thinking = request.thinking+ budget = thinking.budget_tokens if thinking is not None else None+ if budget is not None and (+ not isinstance(budget, int) or isinstance(budget, bool) or budget <= 0+ ):+ raise AnthropicIngressError("thinking.budget_tokens must be a positive integer")+ if thinking is None:+ control = ReasoningControl.DEFAULT+ elif thinking.type == "disabled" or (+ "enabled" in thinking.model_fields_set and thinking.enabled is False+ ):+ control = ReasoningControl.OFF+ elif (+ thinking.type in {"adaptive", "enabled"}+ or ("enabled" in thinking.model_fields_set and thinking.enabled is True)+ or budget is not None+ ):+ control = ReasoningControl.ON+ else:+ control = ReasoningControl.DEFAULT+ output_config = request.output_config or {}+ effort = _reasoning_effort(+ output_config.get("effort"),+ path="output_config.effort",+ )+ if output_config.get("effort") == "none":+ control = ReasoningControl.OFF+ if control is ReasoningControl.OFF:+ budget = None+ if budget is not None:+ control = ReasoningControl.ON+ return ClientReasoningIntent(control=control, effort=effort, budget_tokens=budget)+++def _reasoning_effort(value: object, *, path: str) -> ReasoningEffort | None:+ if value is None or value == "none":+ return None+ if not isinstance(value, str):+ raise AnthropicIngressError(f"{path} must be a string")+ try:+ return ReasoningEffort(value.strip().lower())+ except ValueError as exc:+ raise AnthropicIngressError(f"{path} has unsupported value {value!r}") from exc+++def _image_source(value: object, *, path: str) -> UrlMediaSource | Base64MediaSource:+ source = _mapping(value, path=path)+ source_type = source.get("type")+ if source_type == "url":+ _require_exact_keys(source, allowed={"type", "url"}, path=path)+ return UrlMediaSource(_required_mapping_str(source, "url", path=path))+ if source_type == "base64":+ _require_exact_keys(+ source,+ allowed={"type", "media_type", "data"},+ path=path,+ )+ return Base64MediaSource(+ media_type=_required_mapping_str(source, "media_type", path=path),+ data=_required_mapping_str(source, "data", path=path),+ )+ raise AnthropicIngressError(+ f"{path}.type must be 'url' or 'base64', got {source_type!r}"+ )+++def _document_source(value: object, *, path: str):+ source = _mapping(value, path=path)+ source_type = source.get("type")+ if source_type == "url":+ _require_exact_keys(source, allowed={"type", "url"}, path=path)+ return UrlMediaSource(_required_mapping_str(source, "url", path=path))+ if source_type == "base64":+ _require_exact_keys(+ source,+ allowed={"type", "media_type", "data"},+ path=path,+ )+ return Base64MediaSource(+ media_type=_required_mapping_str(source, "media_type", path=path),+ data=_required_mapping_str(source, "data", path=path),+ )+ if source_type in {"file", "file_id"}:+ _require_exact_keys(source, allowed={"type", "file_id"}, path=path)+ return FileMediaSource(_required_mapping_str(source, "file_id", path=path))+ raise AnthropicIngressError(+ f"{path}.type must be 'url', 'base64', or 'file', got {source_type!r}"+ )+++def _validate_system(value: str | list[SystemContent] | None) -> None:+ if isinstance(value, list):+ for index, block in enumerate(value):+ _cache_control(block, path=f"system[{index}]")+++def _validate_messages(messages: Sequence[object]) -> None:+ for index, raw_message in enumerate(messages):+ role = getattr(raw_message, "role", None)+ content = getattr(raw_message, "content", None)+ path = f"messages[{index}]"+ if isinstance(raw_message, BaseModel):+ _reject_model_extras(raw_message, path=path)+ if role == "system":+ _validate_inline_instruction_content(content, path=path)+ continue+ if role not in {"user", "assistant"}:+ raise AnthropicIngressError(f"{path}.role is unsupported")+ if isinstance(content, str):+ continue+ if not isinstance(content, list):+ raise AnthropicIngressError(f"{path}.content must be text or a list")+ for block_index, block in enumerate(content):+ block_path = f"{path}.content[{block_index}]"+ if isinstance(block, ContentBlockText):+ _cache_control(block, path=block_path)+ elif isinstance(block, ContentBlockImage):+ if role != "user":+ raise AnthropicIngressError(+ f"{block_path} assistant images are not supported"+ )+ _cache_control(block, path=block_path)+ _image_source(block.source, path=f"{block_path}.source")+ elif isinstance(block, ContentBlockDocument):+ if role != "user":+ raise AnthropicIngressError(+ f"{block_path} assistant documents are not supported"+ )+ _cache_control(block, path=block_path)+ _document_source(block.source, path=f"{block_path}.source")+ elif isinstance(block, ContentBlockThinking):+ if role != "assistant":+ raise AnthropicIngressError(+ f"{block_path} thinking requires an assistant message"+ )+ _cache_control(block, path=block_path)+ _reasoning_carrier(+ block.signature,+ kind=ReplayArtifactKind.THINKING_SIGNATURE,+ path=f"{block_path}.signature",+ )+ elif isinstance(block, ContentBlockRedactedThinking):+ if role != "assistant":+ raise AnthropicIngressError(+ f"{block_path} redacted_thinking requires an assistant message"+ )+ _cache_control(block, path=block_path)+ _reasoning_carrier(+ block.data,+ kind=ReplayArtifactKind.REDACTED_THINKING,+ path=f"{block_path}.data",+ )+ elif isinstance(block, ContentBlockToolUse):+ if role != "assistant":+ raise AnthropicIngressError(+ f"{block_path} tool_use requires an assistant message"+ )+ _cache_control(block, path=block_path)+ _non_empty(block.id, path=f"{block_path}.id")+ _non_empty(block.name, path=f"{block_path}.name")+ _json_object(block.input, path=f"{block_path}.input")+ _tool_artifacts(block, path=block_path)+ elif isinstance(block, ContentBlockToolResult):+ if role != "user":+ raise AnthropicIngressError(+ f"{block_path} tool_result requires a user message"+ )+ extras = _block_extras(block)+ unknown = set(extras) - {"cache_control", "is_error"}+ if unknown:+ raise AnthropicIngressError(+ f"{block_path}.{sorted(unknown)[0]} is not supported"+ )+ is_error = extras.get("is_error", False)+ if not isinstance(is_error, bool):+ raise AnthropicIngressError(+ f"{block_path}.is_error must be boolean"+ )+ _non_empty(+ block.tool_use_id,+ path=f"{block_path}.tool_use_id",+ )+ _json_value(block.content, path=f"{block_path}.content")+ elif isinstance(+ block,+ ContentBlockServerToolUse+ | ContentBlockWebSearchToolResult+ | ContentBlockWebFetchToolResult,+ ):+ continue+ else:+ block_type = getattr(block, "type", type(block).__name__)+ raise AnthropicIngressError(+ f"{block_path} type {block_type!r} is not supported"+ )+++def _validate_inline_instruction_content(content: object, *, path: str) -> None:+ if isinstance(content, str):+ return+ if not isinstance(content, list):+ raise AnthropicIngressError(f"{path}.content must contain only text")+ for index, block in enumerate(content):+ block_path = f"{path}.content[{index}]"+ if not isinstance(block, ContentBlockText):+ raise AnthropicIngressError(f"{block_path} must be a text block")+ _cache_control(block, path=block_path)+++def _cache_control(block: BaseModel, *, path: str) -> CacheControl | None:+ extras = _block_extras(block)+ allowed = set(_ALLOWED_BLOCK_EXTRAS)+ if isinstance(block, ContentBlockToolUse):+ allowed.add("extra_content")+ if isinstance(block, Tool):+ allowed.add("strict")+ unknown = set(extras) - allowed+ if unknown:+ raise AnthropicIngressError(f"{path}.{sorted(unknown)[0]} is not supported")+ value = extras.get("cache_control")+ if value is None:+ return None+ mapping = _mapping(value, path=f"{path}.cache_control")+ if set(mapping) - {"type", "ttl"}:+ key = sorted(str(key) for key in set(mapping) - {"type", "ttl"})[0]+ raise AnthropicIngressError(f"{path}.cache_control.{key} is not supported")+ if mapping.get("type") != "ephemeral":+ raise AnthropicIngressError(f"{path}.cache_control.type must be 'ephemeral'")+ raw_ttl = mapping.get("ttl")+ if raw_ttl is None:+ ttl = None+ else:+ try:+ ttl = CacheTTL(raw_ttl)+ except (TypeError, ValueError) as exc:+ raise AnthropicIngressError(+ f"{path}.cache_control.ttl must be '5m' or '1h'"+ ) from exc+ return CacheControl(CacheControlType.EPHEMERAL, ttl)+++def _reasoning_carrier(+ value: str | None,+ *,+ kind: ReplayArtifactKind,+ path: str,+) -> tuple[ReplayArtifact, ...]:+ if not value:+ return ()+ try:+ decoded = decode_replay_envelope(+ value,+ attachment=ReplayAttachment.REASONING,+ )+ except ReplayEnvelopeError as exc:+ raise AnthropicIngressError(f"{path}: {exc}") from exc+ if decoded is not None:+ return decoded+ return (+ ReplayArtifact(+ origin=ReplayArtifactOrigin.ANTHROPIC,+ kind=kind,+ attachment=ReplayAttachment.REASONING,+ payload=value,+ ),+ )+++def _tool_artifacts(+ block: ContentBlockToolUse,+ *,+ path: str,+) -> tuple[ReplayArtifact, ...]:+ extra_content = _block_extras(block).get("extra_content")+ if extra_content is None:+ return ()+ mapping = _mapping(extra_content, path=f"{path}.extra_content")+ envelope = mapping.get("fcc_replay")+ if envelope is not None:+ if set(mapping) != {"fcc_replay"} or not isinstance(envelope, str):+ raise AnthropicIngressError(+ f"{path}.extra_content.fcc_replay must be the only non-empty string carrier"+ )+ try:+ decoded = decode_replay_envelope(+ envelope,+ attachment=ReplayAttachment.TOOL_CALL,+ )+ except ReplayEnvelopeError as exc:+ raise AnthropicIngressError(+ f"{path}.extra_content.fcc_replay: {exc}"+ ) from exc+ if decoded is None:+ raise AnthropicIngressError(+ f"{path}.extra_content.fcc_replay must contain an FCC replay envelope"+ )+ return decoded+ return (+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,+ kind=ReplayArtifactKind.TOOL_EXTRA_CONTENT,+ attachment=ReplayAttachment.TOOL_CALL,+ payload=_json_object(mapping, path=f"{path}.extra_content"),+ ),+ )+++def _block_extras(block: BaseModel) -> Mapping[str, object]:+ return cast(Mapping[str, object], block.model_extra or {})+++def _reject_model_extras(model: BaseModel, *, path: str) -> None:+ extras = model.model_extra or {}+ if extras:+ key = sorted(str(key) for key in extras)[0]+ raise AnthropicIngressError(f"{path}.{key} is not supported")+++def _mapping(value: object, *, path: str) -> Mapping[str, object]:+ if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):+ raise AnthropicIngressError(f"{path} must be an object")+ return cast(Mapping[str, object], value)+++def _require_exact_keys(+ mapping: Mapping[str, object],+ *,+ allowed: set[str],+ path: str,+) -> None:+ unknown = set(mapping) - allowed+ if unknown:+ raise AnthropicIngressError(+ f"{path}.{sorted(str(key) for key in unknown)[0]} is not supported"+ )+++def _required_mapping_str(mapping: Mapping[str, object], key: str, *, path: str) -> str:+ value = mapping.get(key)+ if not isinstance(value, str) or not value.strip():+ raise AnthropicIngressError(f"{path}.{key} must be a non-empty string")+ return value+++def _non_empty(value: str, *, path: str) -> str:+ if not value.strip():+ raise AnthropicIngressError(f"{path} must be a non-empty string")+ return value+++def _json_object(value: object, *, path: str) -> dict[str, JsonValue]:+ mapping = _mapping(value, path=path)+ return {+ str(key): _json_value(item, path=f"{path}.{key}")+ for key, item in mapping.items()+ }+++def _json_value(value: object, *, path: str) -> JsonValue:+ if value is None or isinstance(value, bool | int | float | str):+ return value+ if isinstance(value, BaseModel):+ return _json_value(value.model_dump(mode="python"), path=path)+ if isinstance(value, Mapping):+ if not all(isinstance(key, str) for key in value):+ raise AnthropicIngressError(f"{path} object keys must be strings")+ return {+ str(key): _json_value(item, path=f"{path}.{key}")+ for key, item in value.items()+ }+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):+ return [+ _json_value(item, path=f"{path}[{index}]")+ for index, item in enumerate(value)+ ]+ raise AnthropicIngressError(f"{path} must contain JSON-compatible values")diff --git a/src/free_claude_code/core/anthropic/models.py b/src/free_claude_code/core/anthropic/models.pyindex 684f8cb0..d31d361c 100644--- a/src/free_claude_code/core/anthropic/models.py+++ b/src/free_claude_code/core/anthropic/models.py@@ -79,6 +79,8 @@ class SystemContent(_AnthropicBlockBase):class Message(BaseModel):+ model_config = ConfigDict(extra="allow")+role: Literal["user", "assistant", "system"]content: (str@@ -106,6 +108,8 @@ class Tool(_AnthropicBlockBase):class ThinkingConfig(BaseModel):+ model_config = ConfigDict(extra="allow")+enabled: bool | None = Truetype: str | None = Nonebudget_tokens: int | None = None@@ -115,8 +119,6 @@ class MessagesRequest(BaseModel):model_config = ConfigDict(extra="allow")model: str- original_model: str | None = Field(default=None, exclude=True)- resolved_provider_model: str | None = Field(default=None, exclude=True)max_tokens: int | None = Nonemessages: list[Message]system: str | list[SystemContent] | None = None@@ -140,8 +142,6 @@ class TokenCountRequest(BaseModel):model_config = ConfigDict(extra="allow")model: str- original_model: str | None = Field(default=None, exclude=True)- resolved_provider_model: str | None = Field(default=None, exclude=True)messages: list[Message]system: str | list[SystemContent] | None = Nonetools: list[Tool] | None = Nonediff --git a/src/free_claude_code/core/anthropic/openai_tool_names.py b/src/free_claude_code/core/anthropic/openai_tool_names.pydeleted file mode 100644index 9f1a2e5c..00000000--- a/src/free_claude_code/core/anthropic/openai_tool_names.py+++ /dev/null@@ -1,124 +0,0 @@-"""Reversible tool names for Anthropic-to-OpenAI protocol conversion."""--import hashlib-import re-from collections.abc import Iterable-from dataclasses import dataclass--from .content import get_block_attr, get_block_type-from .models import MessagesRequest--OPENAI_TOOL_NAME_MAX_LENGTH = 64-_ALIAS_DIGEST_LENGTH = 16-_PORTABLE_TOOL_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")-_INVALID_TOOL_NAME_CHARACTERS = re.compile(r"[^A-Za-z0-9_-]+")---@dataclass(frozen=True, slots=True)-class OpenAIToolNameCodec:- """Map non-portable client tool names to deterministic OpenAI aliases."""-- _original_to_alias: dict[str, str]- _alias_to_original: dict[str, str]- _unchanged_names: frozenset[str]-- @classmethod- def from_request(cls, request: MessagesRequest) -> OpenAIToolNameCodec:- """Build the codec from every tool identity carried by one request."""- return cls.from_names(_request_tool_names(request))-- @classmethod- def from_names(cls, names: Iterable[str]) -> OpenAIToolNameCodec:- """Build order-independent aliases for the supplied non-empty names."""- unique_names = {name for name in names if name}- portable_names = {- name for name in unique_names if _PORTABLE_TOOL_NAME.fullmatch(name)- }- reserved = set(portable_names)- original_to_alias: dict[str, str] = {}- alias_to_original: dict[str, str] = {}-- for name in sorted(unique_names - portable_names):- alias = _unique_alias(name, reserved)- reserved.add(alias)- original_to_alias[name] = alias- alias_to_original[alias] = name-- return cls(- original_to_alias,- alias_to_original,- frozenset(portable_names),- )-- @property- def has_aliases(self) -> bool:- """Return whether this request needs any tool-name translation."""- return bool(self._original_to_alias)-- def encode(self, name: str) -> str:- """Return the OpenAI wire name for one client name."""- return self._original_to_alias.get(name, name)-- def decode(self, name: str) -> str:- """Return the original client name for one known wire alias."""- return self._alias_to_original.get(name, name)-- def is_alias(self, value: str) -> bool:- """Return whether value is one complete alias generated for this request."""- return value in self._alias_to_original-- def is_unchanged_name(self, value: str) -> bool:- """Return whether value is one complete name sent upstream unchanged."""- return value in self._unchanged_names-- def is_alias_prefix(self, value: str) -> bool:- """Return whether value is an incomplete prefix of a generated alias."""- return bool(value) and any(- alias != value and alias.startswith(value)- for alias in self._alias_to_original- )---def _request_tool_names(request: MessagesRequest) -> Iterable[str]:- for tool in request.tools or ():- yield tool.name-- tool_choice = request.tool_choice- if isinstance(tool_choice, dict):- choice_type = tool_choice.get("type")- if choice_type == "tool":- name = tool_choice.get("name")- if isinstance(name, str):- yield name- elif choice_type == "function":- function = tool_choice.get("function")- if isinstance(function, dict):- name = function.get("name")- if isinstance(name, str):- yield name-- for message in request.messages:- if message.role != "assistant" or not isinstance(message.content, list):- continue- for block in message.content:- if get_block_type(block) != "tool_use":- continue- name = get_block_attr(block, "name")- if isinstance(name, str):- yield name---def _unique_alias(name: str, reserved: set[str]) -> str:- readable = _INVALID_TOOL_NAME_CHARACTERS.sub("_", name).strip("_-") or "tool"- max_readable_length = OPENAI_TOOL_NAME_MAX_LENGTH - _ALIAS_DIGEST_LENGTH - 1- readable = readable[:max_readable_length].rstrip("_-") or "tool"- attempt = 0- while True:- digest_input = name if attempt == 0 else f"{name}\0{attempt}"- digest = hashlib.sha256(digest_input.encode("utf-8")).hexdigest()[- :_ALIAS_DIGEST_LENGTH- ]- alias = f"{readable}_{digest}"- if alias not in reserved:- return alias- attempt += 1diff --git a/src/free_claude_code/core/anthropic/presenter.py b/src/free_claude_code/core/anthropic/presenter.pyindex f66ea5c3..f130c771 100644--- a/src/free_claude_code/core/anthropic/presenter.py+++ b/src/free_claude_code/core/anthropic/presenter.py@@ -26,9 +26,9 @@ from free_claude_code.core.inference import (ToolCallCompleted,ToolCallStarted,UsageUpdated,- replay_payload_text,)from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.core.replay_envelope import encode_replay_envelopefrom free_claude_code.core.trace import close_stream_inputfrom .streaming.emitter import AnthropicSseEmitter@@ -39,7 +39,6 @@ class _WireBlock:index: int | Noneblock_type: stropen: bool- emitted_artifacts: int = 0class AnthropicEventPresenter:@@ -146,7 +145,6 @@ class AnthropicEventPresenter:for artifact in event.artifacts):chunks.append(self._start_reasoning_wire_block(block))- chunks.extend(self._emit_reasoning_artifacts(block, event.artifacts))return chunksdef _reasoning_delta(self, event: ReasoningDelta) -> list[str]:@@ -173,10 +171,16 @@ class AnthropicEventPresenter:def _reasoning_completed(self, event: ReasoningBlockCompleted) -> list[str]:block = self._require_block(event.block_id, "reasoning")chunks: list[str] = []- if block.open:+ if event.artifacts:+ if block.open or event.reasoning:+ if not block.open:+ chunks.append(self._start_reasoning_wire_block(block))+ chunks.append(self._signature_delta(block, event.artifacts))+ chunks.append(self._stop_wire_block(block))+ else:+ chunks.extend(self._redacted_reasoning_block(event.artifacts))+ elif block.open:chunks.append(self._stop_wire_block(block))- remaining = event.artifacts[block.emitted_artifacts :]- chunks.extend(self._emit_reasoning_artifacts(block, remaining))block.open = Falsereturn chunks@@ -241,58 +245,44 @@ class AnthropicEventPresenter:self._emitter.event("message_stop", {"type": "message_stop"}),]- def _emit_reasoning_artifacts(+ def _signature_delta(self,block: _WireBlock,artifacts: tuple[ReplayArtifact, ...],+ ) -> str:+ return self._emitter.event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": _required_index(block),+ "delta": {+ "type": "signature_delta",+ "signature": encode_replay_envelope(artifacts),+ },+ },+ )++ def _redacted_reasoning_block(+ self, artifacts: tuple[ReplayArtifact, ...]) -> list[str]:- chunks: list[str] = []- for artifact in artifacts:- if artifact.kind is ReplayArtifactKind.THINKING_SIGNATURE:- if not block.open:- chunks.append(self._start_reasoning_wire_block(block))- chunks.append(- self._emitter.event(- "content_block_delta",- {- "type": "content_block_delta",- "index": _required_index(block),- "delta": {- "type": "signature_delta",- "signature": replay_payload_text(artifact),- },- },- )- )- elif artifact.kind in {- ReplayArtifactKind.REDACTED_THINKING,- ReplayArtifactKind.ENCRYPTED_REASONING,- ReplayArtifactKind.REASONING_DETAILS,- }:- if block.open:- chunks.append(self._stop_wire_block(block))- index = self._allocate_index()- chunks.extend(- [- self._emitter.event(- "content_block_start",- {- "type": "content_block_start",- "index": index,- "content_block": {- "type": "redacted_thinking",- "data": replay_payload_text(artifact),- },- },- ),- self._emitter.event(- "content_block_stop",- {"type": "content_block_stop", "index": index},- ),- ]- )- block.emitted_artifacts += 1- return chunks+ index = self._allocate_index()+ return [+ self._emitter.event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": index,+ "content_block": {+ "type": "redacted_thinking",+ "data": encode_replay_envelope(artifacts),+ },+ },+ ),+ self._emitter.event(+ "content_block_stop",+ {"type": "content_block_stop", "index": index},+ ),+ ]def _start_reasoning_wire_block(self, block: _WireBlock) -> str:block.index = self._allocate_index()@@ -390,7 +380,8 @@ async def aggregate_inference_events_to_message("signature": _reasoning_signature(event.artifacts),}content.append(block)- content.extend(_redacted_reasoning_blocks(event.artifacts))+ elif event.artifacts:+ content.extend(_redacted_reasoning_blocks(event.artifacts))elif isinstance(event, ToolCallCompleted):tool_input: JsonValue = {}if event.arguments.strip():@@ -472,43 +463,22 @@ def _usage_value(measurement: TokenMeasurement | None) -> int:def _tool_extra_content(artifacts: tuple[ReplayArtifact, ...],) -> JsonObject | None:- result: JsonObject = {}- for artifact in artifacts:- if artifact.kind is ReplayArtifactKind.THOUGHT_SIGNATURE:- result["google"] = {"thought_signature": replay_payload_text(artifact)}- elif artifact.kind is ReplayArtifactKind.TOOL_EXTRA_CONTENT and isinstance(- artifact.payload, Mapping- ):- result.update(- {- str(key): _json_value(value)- for key, value in artifact.payload.items()- }- )- return result or None+ return {"fcc_replay": encode_replay_envelope(artifacts)} if artifacts else Nonedef _reasoning_signature(artifacts: tuple[ReplayArtifact, ...]) -> str:- for artifact in artifacts:- if artifact.kind is ReplayArtifactKind.THINKING_SIGNATURE:- return replay_payload_text(artifact)- return ""+ return encode_replay_envelope(artifacts) if artifacts else ""def _redacted_reasoning_blocks(artifacts: tuple[ReplayArtifact, ...],) -> list[JsonValue]:+ if not artifacts:+ return []return [{"type": "redacted_thinking",- "data": replay_payload_text(artifact),- }- for artifact in artifacts- if artifact.kind- in {- ReplayArtifactKind.REDACTED_THINKING,- ReplayArtifactKind.ENCRYPTED_REASONING,- ReplayArtifactKind.REASONING_DETAILS,+ "data": encode_replay_envelope(artifacts),}]diff --git a/src/free_claude_code/core/anthropic/request_serialization.py b/src/free_claude_code/core/anthropic/request_serialization.pydeleted file mode 100644index 7b3aba68..00000000--- a/src/free_claude_code/core/anthropic/request_serialization.py+++ /dev/null@@ -1,57 +0,0 @@-"""Shared Anthropic request serialization helpers."""--import json-from typing import Any--from .models import MessagesRequest--_MESSAGES_REQUEST_FIELDS = (- "model",- "messages",- "system",- "max_tokens",- "stop_sequences",- "stream",- "temperature",- "top_p",- "top_k",- "metadata",- "tools",- "tool_choice",- "thinking",- "context_management",- "output_config",- "mcp_servers",- "extra_body",-)---def dump_messages_request(request: MessagesRequest) -> dict[str, Any]:- """Return JSON-ready public Messages fields without FCC routing state."""- raw = request.model_dump(exclude_none=True)- return {- field: raw[field]- for field in _MESSAGES_REQUEST_FIELDS- if field in raw and raw[field] is not None- }---def serialize_tool_result_content(content: Any) -> str:- """Serialize Anthropic ``tool_result.content`` into provider-safe text."""- if content is None:- return ""- if isinstance(content, str):- return content- if isinstance(content, dict):- return json.dumps(content, ensure_ascii=False)- if isinstance(content, list):- parts: list[str] = []- for item in content:- if isinstance(item, dict) and item.get("type") == "text":- parts.append(str(item.get("text", "")))- elif isinstance(item, dict):- parts.append(json.dumps(item, ensure_ascii=False))- else:- parts.append(str(item))- return "\n".join(parts)- return str(content)diff --git a/src/free_claude_code/core/anthropic/request_snapshot.py b/src/free_claude_code/core/anthropic/request_snapshot.pydeleted file mode 100644index 36bb85bb..00000000--- a/src/free_claude_code/core/anthropic/request_snapshot.py+++ /dev/null@@ -1,35 +0,0 @@-"""Trace-safe snapshots of Anthropic protocol requests."""--from typing import Any--from free_claude_code.core.trace import sanitize_trace_value--from .models import MessagesRequest, TokenCountRequest---def anthropic_request_snapshot(- request: MessagesRequest | TokenCountRequest,-) -> dict[str, Any]:- """Return the traceable public fields of an Anthropic request."""- data = request.model_dump(mode="python")- snapshot = {- key: data[key]- for key in (- "model",- "messages",- "system",- "tools",- "tool_choice",- "max_tokens",- "thinking",- "temperature",- "top_p",- "top_k",- "stop_sequences",- "metadata",- "stream",- )- if key in data and data[key] is not None- }- sanitized = sanitize_trace_value(snapshot)- return sanitized if isinstance(sanitized, dict) else {}diff --git a/src/free_claude_code/core/anthropic/streaming/__init__.py b/src/free_claude_code/core/anthropic/streaming/__init__.pyindex 10be1b1b..ccc71770 100644--- a/src/free_claude_code/core/anthropic/streaming/__init__.py+++ b/src/free_claude_code/core/anthropic/streaming/__init__.py@@ -8,30 +8,12 @@ from .emitter import (format_sse_event,map_stop_reason,)-from .recovery import (- ToolSchema,- accept_tool_json_repair,- continuation_suffix,- make_response_recovery_body,- make_text_recovery_body,- make_tool_repair_body,- parse_complete_tool_input,- tool_schemas_by_name,-)__all__ = ["ANTHROPIC_SSE_RESPONSE_HEADERS","AnthropicSseEmitter",- "ToolSchema",- "accept_tool_json_repair","anthropic_terminal_error_frame","anthropic_terminal_failure_frame",- "continuation_suffix","format_sse_event",- "make_response_recovery_body",- "make_text_recovery_body",- "make_tool_repair_body","map_stop_reason",- "parse_complete_tool_input",- "tool_schemas_by_name",]diff --git a/src/free_claude_code/core/anthropic/tokens.py b/src/free_claude_code/core/anthropic/tokens.pydeleted file mode 100644index 72ec3443..00000000--- a/src/free_claude_code/core/anthropic/tokens.py+++ /dev/null@@ -1,111 +0,0 @@-"""Token estimation for Anthropic-compatible requests."""--import json--from loguru import logger--from free_claude_code.core.token_estimation import estimate_text_tokens--from .content import get_block_attr-from .models import Message, SystemContent, Tool---def get_token_count(- messages: list[Message],- system: str | list[SystemContent] | None = None,- tools: list[Tool] | None = None,-) -> int:- """Estimate token count for a request."""- total_tokens = 0-- if system:- if isinstance(system, str):- total_tokens += estimate_text_tokens(system)- elif isinstance(system, list):- for block in system:- text = get_block_attr(block, "text", "")- if text:- total_tokens += estimate_text_tokens(str(text))- total_tokens += 4-- for msg in messages:- if isinstance(msg.content, str):- total_tokens += estimate_text_tokens(msg.content)- elif isinstance(msg.content, list):- for block in msg.content:- b_type = get_block_attr(block, "type") or None-- if b_type == "text":- text = get_block_attr(block, "text", "")- total_tokens += estimate_text_tokens(str(text))- elif b_type == "thinking":- thinking = get_block_attr(block, "thinking", "")- total_tokens += estimate_text_tokens(str(thinking))- elif b_type == "tool_use":- name = get_block_attr(block, "name", "")- inp = get_block_attr(block, "input", {})- block_id = get_block_attr(block, "id", "")- total_tokens += estimate_text_tokens(str(name))- total_tokens += estimate_text_tokens(json.dumps(inp))- total_tokens += estimate_text_tokens(str(block_id))- total_tokens += 15- elif b_type == "image":- source = get_block_attr(block, "source")- if isinstance(source, dict):- data = source.get("data") or source.get("base64") or ""- if data:- total_tokens += max(85, len(data) // 3000)- else:- total_tokens += 765- else:- total_tokens += 765- elif b_type == "tool_result":- content = get_block_attr(block, "content", "")- tool_use_id = get_block_attr(block, "tool_use_id", "")- if isinstance(content, str):- total_tokens += estimate_text_tokens(content)- else:- total_tokens += estimate_text_tokens(json.dumps(content))- total_tokens += estimate_text_tokens(str(tool_use_id))- total_tokens += 8- elif b_type in (- "server_tool_use",- "web_search_tool_result",- "web_fetch_tool_result",- ):- if hasattr(block, "model_dump"):- blob: object = block.model_dump()- else:- blob = block- try:- total_tokens += estimate_text_tokens(- json.dumps(blob, default=str, ensure_ascii=False)- )- except (TypeError, ValueError, OverflowError) as e:- logger.debug(- "Block encode fallback b_type={} err={}", b_type, e- )- total_tokens += estimate_text_tokens(str(blob))- total_tokens += 12- else:- logger.debug(- "Unexpected block type %r, falling back to json/str encoding",- b_type,- )- try:- total_tokens += estimate_text_tokens(json.dumps(block))- except TypeError, ValueError:- total_tokens += estimate_text_tokens(str(block))-- if tools:- for tool in tools:- tool_str = (- tool.name + (tool.description or "") + json.dumps(tool.input_schema)- )- total_tokens += estimate_text_tokens(tool_str)-- total_tokens += len(messages) * 4- if tools:- total_tokens += len(tools) * 5-- return max(1, total_tokens)diff --git a/src/free_claude_code/core/anthropic/tools.py b/src/free_claude_code/core/anthropic/tools.pyindex 7513e07e..c09beb54 100644--- a/src/free_claude_code/core/anthropic/tools.py+++ b/src/free_claude_code/core/anthropic/tools.py@@ -3,264 +3,14 @@import jsonimport reimport uuid-from collections.abc import Mapping-from dataclasses import dataclassfrom enum import Enumfrom typing import Anyfrom loguru import logger-from .models import MessagesRequest-from .openai_tool_names import OpenAIToolNameCodec-from .tool_schema import arguments_match_schema, coerce_text_argument-_CONTROL_TOKEN_RE = re.compile(r"<\|[^|>]{1,80}\|>")_CONTROL_TOKEN_START = "<|"_CONTROL_TOKEN_END = "|>"-_FUNCTION_TAG_BLOCK_START = "<tool_call>"-_FUNCTION_TAG_BLOCK_END = "</tool_call>"-_FUNCTION_TAG_START = "<function="-_FUNCTION_TAG_END = "</function>"-_PARAMETER_TAG_START = "<parameter="-_PARAMETER_TAG_END = "</parameter>"-_MAX_FUNCTION_TAG_CANDIDATE_CHARS = 4 * 1024 * 1024---@dataclass(frozen=True, slots=True)-class _RawFunctionTagCall:- name: str- arguments: dict[str, str]---class _FunctionTagState(Enum):- SEARCHING = 1- CANDIDATE = 2- DISABLED = 3- FINISHED = 4---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]] = {}- for tool in request.tools or ():- if tool.name:- self._schemas[tool.name] = (- tool.input_schema- if tool.input_schema is not None- else {"type": "object"}- )- tool_choice = request.tool_choice- tool_choice_type = (- tool_choice.get("type") if isinstance(tool_choice, dict) else None- )- self._state = (- _FunctionTagState.SEARCHING- if self._schemas and tool_choice_type != "none"- else _FunctionTagState.DISABLED- )- self._parts: list[str] = []- self._length = 0- self._marker_tail = ""-- def feed(self, text: str) -> str:- """Hold a possible reserved response and return text safe to expose."""- if not text:- return ""- if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:- return text-- if self._state is _FunctionTagState.CANDIDATE:- self._parts.append(text)- self._length += len(text)- if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:- return self.disable()- return ""-- candidate = "".join((self._marker_tail, text))- marker_index = candidate.find(_FUNCTION_TAG_BLOCK_START)- if marker_index >= 0:- visible = candidate[:marker_index]- control = candidate[marker_index:]- self._state = _FunctionTagState.CANDIDATE- self._marker_tail = ""- self._parts.append(control)- self._length = len(control)- if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:- return "".join((visible, self.disable()))- return visible-- held_length = _partial_function_tag_marker_suffix_length(candidate)- if held_length:- self._marker_tail = candidate[-held_length:]- return candidate[:-held_length]- self._marker_tail = ""- return candidate-- def disable(self) -> str:- """Disable textual recovery and release any held candidate unchanged."""- if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:- return ""- self._state = _FunctionTagState.DISABLED- text = "".join((self._marker_tail, *self._parts))- self._marker_tail = ""- self._parts.clear()- self._length = 0- return text-- def finish(self) -> tuple[str, tuple[dict[str, Any], ...]]:- """Finalize one response atomically as visible text or validated tools."""- if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:- return "", ()- if self._state is _FunctionTagState.SEARCHING:- self._state = _FunctionTagState.FINISHED- text = self._marker_tail- self._marker_tail = ""- return text, ()- self._state = _FunctionTagState.FINISHED- raw = "".join(self._parts)- self._parts.clear()- self._length = 0- try:- calls = _parse_function_tag_calls(raw)- tool_uses = self._validated_tool_uses(calls)- except ValueError:- return raw, ()- return "", tool_uses-- def _validated_tool_uses(- self, calls: tuple[_RawFunctionTagCall, ...]- ) -> tuple[dict[str, Any], ...]:- tool_uses: list[dict[str, Any]] = []- for call in calls:- name = self._tool_names.decode(call.name)- schema = self._schemas.get(name)- if schema is None:- raise ValueError- properties = schema.get("properties")- property_schemas = properties if isinstance(properties, Mapping) else {}- additional = schema.get("additionalProperties")- arguments: dict[str, Any] = {}- for parameter_name, value in call.arguments.items():- parameter_schema = property_schemas.get(parameter_name)- if not isinstance(parameter_schema, Mapping):- parameter_schema = (- additional if isinstance(additional, Mapping) else {}- )- arguments[parameter_name] = coerce_text_argument(- value,- parameter_schema,- )- if not arguments_match_schema(arguments, schema):- raise ValueError- tool_uses.append(- {- "type": "tool_use",- "id": f"toolu_function_tag_{uuid.uuid4().hex[:8]}",- "name": name,- "input": arguments,- }- )- return tuple(tool_uses)---def _parse_function_tag_calls(text: str) -> tuple[_RawFunctionTagCall, ...]:- cursor = 0- calls: list[_RawFunctionTagCall] = []- while True:- cursor = _skip_function_tag_whitespace(text, cursor)- if cursor == len(text):- break- if not text.startswith(_FUNCTION_TAG_BLOCK_START, cursor):- raise ValueError-- block_start = cursor + len(_FUNCTION_TAG_BLOCK_START)- block_end = text.find(_FUNCTION_TAG_BLOCK_END, block_start)- if block_end < 0:- raise ValueError- name, arguments = _parse_function_tag_block(text[block_start:block_end])- calls.append(_RawFunctionTagCall(name=name, arguments=arguments))- cursor = block_end + len(_FUNCTION_TAG_BLOCK_END)-- if not calls:- raise ValueError- return tuple(calls)---def _parse_function_tag_block(block: str) -> tuple[str, dict[str, str]]:- cursor = _skip_function_tag_whitespace(block, 0)- if not block.startswith(_FUNCTION_TAG_START, cursor):- raise ValueError- name_end = block.find(">", cursor + len(_FUNCTION_TAG_START))- if name_end < 0:- raise ValueError- name = block[cursor + len(_FUNCTION_TAG_START) : name_end]- if not _valid_function_tag_name(name):- raise ValueError-- arguments: dict[str, str] = {}- cursor = name_end + 1- while True:- cursor = _skip_function_tag_whitespace(block, cursor)- if block.startswith(_FUNCTION_TAG_END, cursor):- cursor += len(_FUNCTION_TAG_END)- break- if cursor == len(block) or not block.startswith(_PARAMETER_TAG_START, cursor):- raise ValueError-- parameter_name_end = block.find(">", cursor + len(_PARAMETER_TAG_START))- if parameter_name_end < 0:- raise ValueError- parameter_name = block[cursor + len(_PARAMETER_TAG_START) : parameter_name_end]- if not _valid_function_tag_name(parameter_name) or parameter_name in arguments:- raise ValueError-- value_start = parameter_name_end + 1- value_end = block.find(_PARAMETER_TAG_END, value_start)- if value_end < 0:- raise ValueError- arguments[parameter_name] = _unwrap_function_tag_newlines(- block[value_start:value_end]- )- cursor = value_end + len(_PARAMETER_TAG_END)-- if block[cursor:].strip():- raise ValueError- return name, arguments---def _skip_function_tag_whitespace(text: str, cursor: int) -> int:- while cursor < len(text) and text[cursor].isspace():- cursor += 1- return cursor---def _valid_function_tag_name(value: str) -> bool:- return bool(value) and not any(- character.isspace() or character in "<>" for character in value- )---def _unwrap_function_tag_newlines(value: str) -> str:- if value.startswith("\r\n"):- value = value[2:]- elif value.startswith("\n"):- value = value[1:]- if value.endswith("\r\n"):- return value[:-2]- if value.endswith("\n"):- return value[:-1]- return value---def _partial_function_tag_marker_suffix_length(text: str) -> int:- max_length = min(len(text), len(_FUNCTION_TAG_BLOCK_START) - 1)- for length in range(max_length, 0, -1):- if _FUNCTION_TAG_BLOCK_START.startswith(text[-length:]):- return length- return 0class ParserState(Enum):diff --git a/src/free_claude_code/core/inference/__init__.py b/src/free_claude_code/core/inference/__init__.pyindex eaf3934a..7144390f 100644--- a/src/free_claude_code/core/inference/__init__.py+++ b/src/free_claude_code/core/inference/__init__.py@@ -11,6 +11,7 @@ from .events import (ReplayArtifactKind,ReplayArtifactOrigin,ReplayAttachment,+ ReplayCompatibilityScope,ResponseCompleted,ResponseStarted,TextBlockCompleted,@@ -32,34 +33,113 @@ from .ledger import (InferenceStreamLedger,ToolCallState,)+from .request import (+ Base64MediaSource,+ CacheControl,+ CacheControlType,+ CacheTTL,+ ClientReasoningIntent,+ CustomTool,+ CustomToolFormat,+ CustomToolFormatType,+ DocumentContent,+ FileMediaSource,+ FunctionTool,+ ImageContent,+ InferenceExtension,+ InferenceItem,+ InferenceRequest,+ InferenceTool,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MediaSource,+ MessageContent,+ MessageItem,+ MessageRole,+ OpenAIChatExtension,+ ReasoningItem,+ RefusalContent,+ TextContent,+ ToolCallItem,+ ToolChoice,+ ToolChoiceMode,+ ToolResultItem,+ UrlMediaSource,+ freeze_json,+ freeze_json_object,+ inference_request_snapshot,+ thaw_json,+ thaw_json_object,+)+from .tokens import get_inference_token_count__all__ = [+ "Base64MediaSource",+ "CacheControl",+ "CacheControlType",+ "CacheTTL",+ "ClientReasoningIntent",+ "CustomTool",+ "CustomToolFormat",+ "CustomToolFormatType",+ "DocumentContent",+ "FileMediaSource","FinishReason",+ "FunctionTool",+ "ImageContent","InferenceBlockLedger","InferenceBlockState","InferenceEvent",+ "InferenceExtension",+ "InferenceItem",+ "InferenceRequest","InferenceStreamLedger",+ "InferenceTool","InferenceUsage",+ "InstructionItem",+ "InstructionOrigin",+ "InstructionPlacement",+ "MediaSource",+ "MessageContent",+ "MessageItem",+ "MessageRole",+ "OpenAIChatExtension","ReasoningBlockCompleted","ReasoningBlockStarted","ReasoningDelta",+ "ReasoningItem",+ "RefusalContent","ReplayArtifact","ReplayArtifactKind","ReplayArtifactOrigin","ReplayAttachment",+ "ReplayCompatibilityScope","ResponseCompleted","ResponseStarted","TextBlockCompleted","TextBlockStarted",+ "TextContent","TextDelta","TokenMeasurement","ToolCallArgumentsDelta","ToolCallCompleted",+ "ToolCallItem","ToolCallKind","ToolCallStarted","ToolCallState",+ "ToolChoice",+ "ToolChoiceMode",+ "ToolResultItem",+ "UrlMediaSource","UsageSource","UsageUpdated",+ "freeze_json",+ "freeze_json_object",+ "get_inference_token_count","inference_event_size",+ "inference_request_snapshot","replay_payload_text",+ "thaw_json",+ "thaw_json_object",]diff --git a/src/free_claude_code/core/inference/events.py b/src/free_claude_code/core/inference/events.pyindex f12c6071..a6769d5f 100644--- a/src/free_claude_code/core/inference/events.py+++ b/src/free_claude_code/core/inference/events.py@@ -81,6 +81,17 @@ class ReplayAttachment(StrEnum):TOOL_CALL = "tool_call"+@dataclass(frozen=True, slots=True)+class ReplayCompatibilityScope:+ """Opaque route identity required for safe upstream replay."""++ value: str++ def __post_init__(self) -> None:+ if not self.value.strip():+ raise ValueError("replay compatibility scope must be non-empty")++@dataclass(frozen=True, slots=True)class ReplayArtifact:"""Opaque provider replay material with a typed owner and scope."""@@ -89,6 +100,7 @@ class ReplayArtifact:kind: ReplayArtifactKindattachment: ReplayAttachmentpayload: JsonValue+ scope: ReplayCompatibilityScope | None = Noneclass ToolCallKind(StrEnum):@@ -316,6 +328,7 @@ def _artifacts(artifacts: tuple[ReplayArtifact, ...]) -> JsonValue:artifact.origin.value,artifact.kind.value,artifact.attachment.value,+ artifact.scope.value if artifact.scope is not None else None,_json_projection(artifact.payload),]for artifact in artifactsdiff --git a/src/free_claude_code/core/inference/ledger.py b/src/free_claude_code/core/inference/ledger.pyindex 51df919a..1cbe3556 100644--- a/src/free_claude_code/core/inference/ledger.py+++ b/src/free_claude_code/core/inference/ledger.py@@ -1,14 +1,9 @@"""Semantic state for one provider-neutral inference stream."""-import hashlib-import jsonimport uuidfrom collections.abc import Iteratorfrom dataclasses import dataclass, field-from loguru import logger--from free_claude_code.core.json_types import JsonValuefrom free_claude_code.core.token_estimation import estimate_text_tokensfrom .events import (@@ -19,6 +14,7 @@ from .events import (ReasoningBlockStarted,ReasoningDelta,ReplayArtifact,+ ReplayAttachment,ResponseCompleted,ResponseStarted,TextBlockCompleted,@@ -50,8 +46,6 @@ class ToolCallState:namespace: str | None = Noneartifacts: tuple[ReplayArtifact, ...] = ()started: bool = False- task_arg_buffer: str = ""- task_args_emitted: bool = Falsepre_start_args: str = ""@@ -99,62 +93,22 @@ class InferenceBlockLedger:state = self.ensure_tool_state(index)state.artifacts = _merge_artifacts(state.artifacts, artifacts)- def register_tool_name(self, index: int, name: str) -> None:+ def register_tool_identity(+ self,+ index: int,+ name: str,+ *,+ kind: ToolCallKind,+ namespace: str | None,+ ) -> None:state = self.ensure_tool_state(index)previous = state.nameif not previous or name.startswith(previous):state.name = nameelif not previous.startswith(name):state.name = "".join((previous, name))-- def buffer_task_args(self, index: int, args: str) -> dict[str, JsonValue] | None:- state = self.tool_states.get(index)- if state is None or state.task_args_emitted:- return None-- state.task_arg_buffer += args- try:- parsed: JsonValue = json.loads(state.task_arg_buffer)- except json.JSONDecodeError, TypeError, ValueError:- return None- if not isinstance(parsed, dict):- return None-- normalized = {str(key): value for key, value in parsed.items()}- _normalize_task_run_in_background(normalized)- state.task_args_emitted = True- state.task_arg_buffer = ""- return normalized-- def flush_task_arg_buffers(self) -> list[tuple[int, str]]:- results: list[tuple[int, str]] = []- for tool_index, state in list(self.tool_states.items()):- if not state.task_arg_buffer or state.task_args_emitted:- continue-- output = "{}"- try:- parsed: JsonValue = json.loads(state.task_arg_buffer)- if isinstance(parsed, dict):- normalized = {str(key): value for key, value in parsed.items()}- _normalize_task_run_in_background(normalized)- output = json.dumps(normalized)- 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.call_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+ state.kind = kind+ state.namespace = namespaceclass InferenceStreamLedger:@@ -191,6 +145,7 @@ class InferenceStreamLedger:self, *, artifacts: tuple[ReplayArtifact, ...] = ()) -> ReasoningBlockStarted:self._require_response_open()+ _require_artifact_attachment(artifacts, ReplayAttachment.REASONING)block_id = _new_identity("block")item_id = _new_identity("item")self.blocks.reasoning_block_id = block_id@@ -265,6 +220,7 @@ class InferenceStreamLedger:artifacts: tuple[ReplayArtifact, ...] = (),) -> ToolCallStarted:self._require_response_open()+ _require_artifact_attachment(artifacts, ReplayAttachment.TOOL_CALL)block_id = _new_identity("block")item_id = _new_identity("item")state = self.blocks.ensure_tool_state(tool_index)@@ -300,6 +256,7 @@ class InferenceStreamLedger:def set_tool_artifacts(self, tool_index: int, artifacts: tuple[ReplayArtifact, ...]) -> None:+ _require_artifact_attachment(artifacts, ReplayAttachment.TOOL_CALL)self.blocks.set_tool_artifacts(tool_index, artifacts)state = self.blocks.tool_states[tool_index]if not state.block_id:@@ -498,6 +455,10 @@ def _merge_artifacts(return (*existing, *(artifact for artifact in incoming if artifact not in existing))-def _normalize_task_run_in_background(args: dict[str, JsonValue]) -> None:- if args.get("run_in_background") is not False:- args["run_in_background"] = False+def _require_artifact_attachment(+ artifacts: tuple[ReplayArtifact, ...], expected: ReplayAttachment+) -> None:+ if any(artifact.attachment is not expected for artifact in artifacts):+ raise ValueError(+ f"replay artifacts on {expected.value} output must use that attachment"+ )diff --git a/src/free_claude_code/core/inference/request.py b/src/free_claude_code/core/inference/request.pynew file mode 100644index 00000000..25251e0a--- /dev/null+++ b/src/free_claude_code/core/inference/request.py@@ -0,0 +1,431 @@+"""Provider-neutral inference request values."""++from collections.abc import Mapping, Sequence+from dataclasses import dataclass, replace+from enum import StrEnum+from types import MappingProxyType++from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort++from .events import ReplayArtifact, ToolCallKind+++class CacheControlType(StrEnum):+ """Supported client prompt-cache breakpoint kind."""++ EPHEMERAL = "ephemeral"+++class CacheTTL(StrEnum):+ """Supported Anthropic prompt-cache durations."""++ FIVE_MINUTES = "5m"+ ONE_HOUR = "1h"+++@dataclass(frozen=True, slots=True)+class CacheControl:+ """One typed prompt-cache breakpoint."""++ type: CacheControlType = CacheControlType.EPHEMERAL+ ttl: CacheTTL | None = None+++class InstructionOrigin(StrEnum):+ """Client role that supplied an instruction."""++ SYSTEM = "system"+ DEVELOPER = "developer"+++class InstructionPlacement(StrEnum):+ """Whether an instruction was top-level or part of the transcript."""++ TOP_LEVEL = "top_level"+ TRANSCRIPT = "transcript"+++class MessageRole(StrEnum):+ """Canonical conversational message roles."""++ USER = "user"+ ASSISTANT = "assistant"+++@dataclass(frozen=True, slots=True)+class UrlMediaSource:+ """A media resource referenced by URL."""++ url: str++ def __post_init__(self) -> None:+ if not self.url.strip():+ raise ValueError("media URL must be non-empty")+++@dataclass(frozen=True, slots=True)+class Base64MediaSource:+ """Inline base64 media with an explicit MIME type."""++ media_type: str+ data: str++ def __post_init__(self) -> None:+ if not self.media_type.strip():+ raise ValueError("base64 media_type must be non-empty")+ if not self.data.strip():+ raise ValueError("base64 media data must be non-empty")+++@dataclass(frozen=True, slots=True)+class FileMediaSource:+ """A protocol-owned uploaded file reference."""++ file_id: str++ def __post_init__(self) -> None:+ if not self.file_id.strip():+ raise ValueError("file_id must be non-empty")+++type MediaSource = UrlMediaSource | Base64MediaSource | FileMediaSource+++@dataclass(frozen=True, slots=True)+class TextContent:+ """Visible text content."""++ text: str+ cache_control: CacheControl | None = None+++@dataclass(frozen=True, slots=True)+class ImageContent:+ """User image content."""++ source: UrlMediaSource | Base64MediaSource+ cache_control: CacheControl | None = None+++@dataclass(frozen=True, slots=True)+class DocumentContent:+ """User document content retained for transport preflight."""++ source: MediaSource+ cache_control: CacheControl | None = None+++@dataclass(frozen=True, slots=True)+class RefusalContent:+ """A prior assistant refusal preserved as such."""++ refusal: str+++type MessageContent = TextContent | ImageContent | DocumentContent | RefusalContent+++@dataclass(frozen=True, slots=True)+class InstructionItem:+ """One ordered instruction."""++ text: str+ origin: InstructionOrigin+ placement: InstructionPlacement+ cache_control: CacheControl | None = None+ turn_id: str | None = None++ def __post_init__(self) -> None:+ if (self.placement is InstructionPlacement.TRANSCRIPT) != (+ self.turn_id is not None+ ):+ raise ValueError("only transcript instructions require a turn_id")+++@dataclass(frozen=True, slots=True)+class MessageItem:+ """One conversational turn's visible content."""++ turn_id: str+ role: MessageRole+ content: tuple[MessageContent, ...]+++@dataclass(frozen=True, slots=True)+class ReasoningItem:+ """Visible reasoning and its opaque continuation artifacts."""++ turn_id: str+ reasoning: str+ artifacts: tuple[ReplayArtifact, ...] = ()+++@dataclass(frozen=True, slots=True)+class ToolCallItem:+ """One prior assistant tool invocation."""++ turn_id: str+ call_id: str+ kind: ToolCallKind+ name: str+ input: JsonValue+ namespace: str | None = None+ artifacts: tuple[ReplayArtifact, ...] = ()++ def __post_init__(self) -> None:+ object.__setattr__(self, "input", freeze_json(self.input))+++@dataclass(frozen=True, slots=True)+class ToolResultItem:+ """One user-supplied result for a prior tool invocation."""++ turn_id: str+ call_id: str+ content: JsonValue+ is_error: bool = False++ def __post_init__(self) -> None:+ object.__setattr__(self, "content", freeze_json(self.content))+++type InferenceItem = (+ InstructionItem | MessageItem | ReasoningItem | ToolCallItem | ToolResultItem+)+++@dataclass(frozen=True, slots=True)+class FunctionTool:+ """A JSON-schema function tool."""++ name: str+ description: str | None+ input_schema: Mapping[str, JsonValue]+ strict: bool = False+ namespace: str | None = None+ cache_control: CacheControl | None = None++ def __post_init__(self) -> None:+ object.__setattr__(self, "input_schema", freeze_json_object(self.input_schema))+++class CustomToolFormatType(StrEnum):+ """Supported free-form tool input formats."""++ TEXT = "text"+ GRAMMAR = "grammar"+++@dataclass(frozen=True, slots=True)+class CustomToolFormat:+ """Typed custom-tool input format."""++ type: CustomToolFormatType+ syntax: str | None = None+ definition: str | None = None+++@dataclass(frozen=True, slots=True)+class CustomTool:+ """A free-form/custom tool."""++ name: str+ description: str | None+ format: CustomToolFormat+ namespace: str | None = None+ cache_control: CacheControl | None = None+++type InferenceTool = FunctionTool | CustomTool+++class ToolChoiceMode(StrEnum):+ """Canonical tool selection modes."""++ AUTO = "auto"+ NONE = "none"+ REQUIRED = "required"+ SPECIFIC = "specific"+++@dataclass(frozen=True, slots=True)+class ToolChoice:+ """Tool-selection intent with an optional typed target."""++ mode: ToolChoiceMode+ kind: ToolCallKind | None = None+ name: str | None = None+ namespace: str | None = None++ def __post_init__(self) -> None:+ specific = self.mode is ToolChoiceMode.SPECIFIC+ if specific != (self.kind is not None and self.name is not None):+ raise ValueError("specific tool choice requires kind and name")+ if not specific and self.namespace is not None:+ raise ValueError("only a specific tool choice may name a namespace")+++@dataclass(frozen=True, slots=True)+class ClientReasoningIntent:+ """Unresolved reasoning intent supplied by the client."""++ control: ReasoningControl = ReasoningControl.DEFAULT+ effort: ReasoningEffort | None = None+ budget_tokens: int | None = None++ def __post_init__(self) -> None:+ if self.budget_tokens is not None and (+ not isinstance(self.budget_tokens, int)+ or isinstance(self.budget_tokens, bool)+ or self.budget_tokens <= 0+ ):+ raise ValueError("reasoning budget must be a positive integer")+ if self.budget_tokens is not None and self.control is not ReasoningControl.ON:+ raise ValueError("a reasoning budget requires reasoning control to be on")+++@dataclass(frozen=True, slots=True)+class OpenAIChatExtension:+ """Explicit caller extension for OpenAI-compatible Chat transports."""++ extra_body: Mapping[str, JsonValue]++ def __post_init__(self) -> None:+ object.__setattr__(self, "extra_body", freeze_json_object(self.extra_body))+++type InferenceExtension = OpenAIChatExtension+++@dataclass(frozen=True, slots=True)+class InferenceRequest:+ """Immutable provider-neutral request passed below protocol ingress."""++ model: str+ items: tuple[InferenceItem, ...]+ tools: tuple[InferenceTool, ...] = ()+ tool_choice: ToolChoice | None = None+ parallel_tool_calls: bool | None = None+ max_output_tokens: int | None = None+ temperature: float | None = None+ top_p: float | None = None+ top_k: int | None = None+ stop_sequences: tuple[str, ...] = ()+ reasoning: ClientReasoningIntent = ClientReasoningIntent()+ metadata: Mapping[str, JsonValue] | None = None+ extensions: tuple[InferenceExtension, ...] = ()++ def __post_init__(self) -> None:+ if not self.model.strip():+ raise ValueError("model must be non-empty")+ if self.max_output_tokens is not None and (+ not isinstance(self.max_output_tokens, int)+ or isinstance(self.max_output_tokens, bool)+ or self.max_output_tokens <= 0+ ):+ raise ValueError("max_output_tokens must be a positive integer")+ if self.metadata is not None:+ object.__setattr__(self, "metadata", freeze_json_object(self.metadata))+ if sum(isinstance(value, OpenAIChatExtension) for value in self.extensions) > 1:+ raise ValueError("only one OpenAI Chat extension is allowed")++ @property+ def message_count(self) -> int:+ """Return the number of distinct transcript turns."""++ turn_ids: set[str] = set()+ for item in self.items:+ if isinstance(item, InstructionItem):+ if item.turn_id is not None:+ turn_ids.add(item.turn_id)+ elif isinstance(+ item,+ MessageItem | ReasoningItem | ToolCallItem | ToolResultItem,+ ):+ turn_ids.add(item.turn_id)+ return len(turn_ids)++ @property+ def openai_chat_extension(self) -> OpenAIChatExtension | None:+ """Return the one explicit Chat extension, if supplied."""++ return next(+ (+ extension+ for extension in self.extensions+ if isinstance(extension, OpenAIChatExtension)+ ),+ None,+ )++ def with_stop_sequences(self, stop_sequences: tuple[str, ...]) -> InferenceRequest:+ """Return a request with an application-owned stop-policy adjustment."""++ return replace(self, stop_sequences=stop_sequences)+++def freeze_json(value: JsonValue) -> JsonValue:+ """Return a recursively immutable, owned JSON value."""++ if isinstance(value, Mapping):+ return MappingProxyType(+ {str(key): freeze_json(item) for key, item in value.items()}+ )+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):+ return tuple(freeze_json(item) for item in value)+ return value+++def freeze_json_object(value: Mapping[str, JsonValue]) -> Mapping[str, JsonValue]:+ """Return a recursively immutable, owned JSON object."""++ frozen = freeze_json(value)+ if not isinstance(frozen, Mapping):+ raise TypeError("expected a JSON object")+ return frozen+++def thaw_json(value: JsonValue) -> JsonValue:+ """Return a mutable JSON-ready copy of a canonical value."""++ if isinstance(value, Mapping):+ return {str(key): thaw_json(item) for key, item in value.items()}+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):+ return [thaw_json(item) for item in value]+ return value+++def thaw_json_object(value: Mapping[str, JsonValue]) -> dict[str, JsonValue]:+ """Return a mutable JSON-ready copy of a canonical object."""++ return {str(key): thaw_json(item) for key, item in value.items()}+++def inference_request_snapshot(request: InferenceRequest) -> dict[str, object]:+ """Return trace-safe request structure without prompts or replay payloads."""++ return {+ "model": request.model,+ "item_count": len(request.items),+ "message_count": request.message_count,+ "tool_count": len(request.tools),+ "tool_choice": (+ request.tool_choice.mode.value if request.tool_choice is not None else None+ ),+ "parallel_tool_calls": request.parallel_tool_calls,+ "max_output_tokens": request.max_output_tokens,+ "temperature": request.temperature,+ "top_p": request.top_p,+ "top_k": request.top_k,+ "stop_sequence_count": len(request.stop_sequences),+ "reasoning_control": request.reasoning.control.value,+ "reasoning_effort": (+ request.reasoning.effort.value+ if request.reasoning.effort is not None+ else None+ ),+ "reasoning_budget_tokens": request.reasoning.budget_tokens,+ "has_metadata": request.metadata is not None,+ "extension_count": len(request.extensions),+ }diff --git a/src/free_claude_code/core/inference/tokens.py b/src/free_claude_code/core/inference/tokens.pynew file mode 100644index 00000000..b21c6430--- /dev/null+++ b/src/free_claude_code/core/inference/tokens.py@@ -0,0 +1,125 @@+"""Token estimation over the canonical inference request."""++import json+from collections.abc import Mapping, Sequence++from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.token_estimation import estimate_text_tokens++from .request import (+ Base64MediaSource,+ DocumentContent,+ FunctionTool,+ ImageContent,+ InferenceRequest,+ InstructionItem,+ InstructionPlacement,+ MessageItem,+ ReasoningItem,+ RefusalContent,+ TextContent,+ ToolCallItem,+ ToolResultItem,+ UrlMediaSource,+ thaw_json,+)+++def get_inference_token_count(request: InferenceRequest) -> int:+ """Estimate input tokens from the one canonical transcript interpretation."""++ total = 0+ has_top_level_instruction = False+ for item in request.items:+ if isinstance(item, InstructionItem):+ total += estimate_text_tokens(item.text)+ has_top_level_instruction |= (+ item.placement is InstructionPlacement.TOP_LEVEL+ )+ elif isinstance(item, MessageItem):+ total += sum(_content_tokens(part) for part in item.content)+ elif isinstance(item, ReasoningItem):+ total += estimate_text_tokens(item.reasoning)+ elif isinstance(item, ToolCallItem):+ total += estimate_text_tokens(item.name)+ total += estimate_text_tokens(_json_text(item.input))+ total += estimate_text_tokens(item.call_id)+ total += 15+ elif isinstance(item, ToolResultItem):+ total += estimate_text_tokens(_tool_result_text(item.content))+ total += estimate_text_tokens(item.call_id)+ total += 8++ if has_top_level_instruction:+ total += 4+ total += request.message_count * 4++ for tool in request.tools:+ if isinstance(tool, FunctionTool):+ schema = _json_text(tool.input_schema)+ else:+ schema = " ".join(+ value+ for value in (+ tool.format.type.value,+ tool.format.syntax,+ tool.format.definition,+ )+ if value+ )+ total += estimate_text_tokens(tool.name + (tool.description or "") + schema)+ if request.tools:+ total += len(request.tools) * 5+ return max(1, total)+++def _content_tokens(content: object) -> int:+ if isinstance(content, TextContent):+ return estimate_text_tokens(content.text)+ if isinstance(content, RefusalContent):+ return estimate_text_tokens(content.refusal)+ if isinstance(content, ImageContent):+ return _media_tokens(content.source)+ if isinstance(content, DocumentContent):+ source = content.source+ if isinstance(source, Base64MediaSource):+ return max(85, len(source.data) // 3000)+ if isinstance(source, UrlMediaSource):+ return 765+ return estimate_text_tokens(source.file_id)+ raise TypeError(f"unsupported canonical content: {type(content).__name__}")+++def _media_tokens(source: UrlMediaSource | Base64MediaSource) -> int:+ if isinstance(source, Base64MediaSource):+ return max(85, len(source.data) // 3000)+ return 765+++def _tool_result_text(value: JsonValue) -> str:+ if value is None:+ return ""+ if isinstance(value, str):+ return value+ if isinstance(value, Mapping):+ return _json_text(value)+ if isinstance(value, Sequence):+ parts: list[str] = []+ for item in value:+ if isinstance(item, Mapping) and item.get("type") == "text":+ text = item.get("text")+ parts.append(text if isinstance(text, str) else str(text or ""))+ elif isinstance(item, Mapping | Sequence) and not isinstance(item, str):+ parts.append(_json_text(item))+ else:+ parts.append(str(item))+ return "\n".join(parts)+ return str(value)+++def _json_text(value: JsonValue | Mapping[str, JsonValue]) -> str:+ return json.dumps(+ thaw_json(value),+ ensure_ascii=False,+ separators=(",", ":"),+ )diff --git a/src/free_claude_code/core/openai_responses/__init__.py b/src/free_claude_code/core/openai_responses/__init__.pyindex adf6b99a..4e25b4fb 100644--- a/src/free_claude_code/core/openai_responses/__init__.py+++ b/src/free_claude_code/core/openai_responses/__init__.py@@ -1,30 +1,34 @@"""OpenAI Responses protocol adapter."""-from .adapter import OpenAIResponsesAdapterfrom .errors import (ResponsesConversionError,openai_error_payload,openai_error_type_for_failure,openai_failure_payload,)-from .models import OpenAIResponsesRequest+from .events import OPENAI_RESPONSES_SSE_HEADERS+from .ingress import (+ ResponsesIngressResult,+ responses_to_inference_request,+ validate_responses_field_policy,+)+from .models import OpenAIResponsesRequest, ResponsesPresentationSnapshotfrom .presenter import (ResponsesEventPresenter,iter_responses_sse_from_events,)-from .provider_events import ResponsesEventDecoder, ResponsesStreamFailure-from .provider_input import build_responses_provider_request__all__ = [- "OpenAIResponsesAdapter",+ "OPENAI_RESPONSES_SSE_HEADERS","OpenAIResponsesRequest","ResponsesConversionError",- "ResponsesEventDecoder","ResponsesEventPresenter",- "ResponsesStreamFailure",- "build_responses_provider_request",+ "ResponsesIngressResult",+ "ResponsesPresentationSnapshot","iter_responses_sse_from_events","openai_error_payload","openai_error_type_for_failure","openai_failure_payload",+ "responses_to_inference_request",+ "validate_responses_field_policy",]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 60b0f2cb..00000000--- a/src/free_claude_code/core/openai_responses/adapter.py+++ /dev/null@@ -1,21 +0,0 @@-"""Facade for OpenAI Responses protocol adaptation."""--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---class OpenAIResponsesAdapter:- """Convert the current Responses request bridge and public error envelopes."""-- 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 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/ingress.py b/src/free_claude_code/core/openai_responses/ingress.pynew file mode 100644index 00000000..08c06f7f--- /dev/null+++ b/src/free_claude_code/core/openai_responses/ingress.py@@ -0,0 +1,778 @@+"""OpenAI Responses ingress conversion to canonical inference semantics."""++import json+from collections.abc import Mapping, Sequence+from dataclasses import dataclass, field+from typing import cast++from free_claude_code.core.inference import (+ ClientReasoningIntent,+ CustomTool,+ CustomToolFormat,+ CustomToolFormatType,+ FunctionTool,+ InferenceItem,+ InferenceRequest,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MessageContent,+ MessageItem,+ MessageRole,+ ReasoningItem,+ RefusalContent,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolChoice,+ ToolChoiceMode,+ ToolResultItem,+)+from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort+from free_claude_code.core.replay_envelope import (+ ReplayEnvelopeError,+ decode_replay_envelope,+)+from free_claude_code.core.trace import trace_event++from .errors import ResponsesConversionError+from .ids import new_call_id+from .models import OpenAIResponsesRequest, ResponsesPresentationSnapshot++_AMBIENT_HOSTED_TOOL_TYPES = frozenset(+ {"web_search", "image_generation", "tool_search"}+)+++@dataclass(frozen=True, slots=True)+class ResponsesIngressResult:+ """Canonical request plus the minimal validated public echo state."""++ request: InferenceRequest+ presentation: ResponsesPresentationSnapshot+++@dataclass(slots=True)+class _PendingReasoning:+ text_parts: list[str] = field(default_factory=list)+ artifacts: list[ReplayArtifact] = field(default_factory=list)++ def add(self, item: Mapping[str, object], *, path: str) -> None:+ self.text_parts.extend(_reasoning_text_parts(item, path=path))+ encrypted = item.get("encrypted_content")+ if encrypted is None:+ return+ if not isinstance(encrypted, str):+ raise ResponsesConversionError(f"{path}.encrypted_content must be a string")+ try:+ decoded = decode_replay_envelope(+ encrypted,+ attachment=ReplayAttachment.REASONING,+ )+ except ReplayEnvelopeError as exc:+ raise ResponsesConversionError(f"{path}.encrypted_content: {exc}") from exc+ if decoded is not None:+ self.artifacts.extend(decoded)+ elif encrypted:+ self.artifacts.append(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload=encrypted,+ )+ )++ @property+ def pending(self) -> bool:+ return bool(self.text_parts or self.artifacts)++ def take(self, *, turn_id: str) -> ReasoningItem | None:+ if not self.pending:+ return None+ item = ReasoningItem(+ turn_id=turn_id,+ reasoning="\n".join(self.text_parts),+ artifacts=tuple(self.artifacts),+ )+ self.text_parts.clear()+ self.artifacts.clear()+ return item+++@dataclass(slots=True)+class _TranscriptBuilder:+ items: list[InferenceItem] = field(default_factory=list)+ system: list[InstructionItem] = field(default_factory=list)+ pending_reasoning: _PendingReasoning = field(default_factory=_PendingReasoning)+ quarantined_call_ids: set[str] = field(default_factory=set)+ _next_turn: int = 0+ _last_assistant_tool_turn: str | None = None+ _last_user_tool_turn: str | None = None++ def new_turn(self) -> str:+ turn_id = f"turn_{self._next_turn}"+ self._next_turn += 1+ return turn_id++ def break_tool_groups(self) -> None:+ self._last_assistant_tool_turn = None+ self._last_user_tool_turn = None++ def flush_reasoning(self) -> None:+ if self.pending_reasoning.pending:+ item = self.pending_reasoning.take(turn_id=self.new_turn())+ if item is not None:+ self.items.append(item)+ self.break_tool_groups()++ def assistant_tool_turn(self) -> str:+ if self._last_assistant_tool_turn is None:+ self._last_assistant_tool_turn = self.new_turn()+ self._last_user_tool_turn = None+ return self._last_assistant_tool_turn++ def user_tool_turn(self) -> str:+ if self._last_user_tool_turn is None:+ self._last_user_tool_turn = self.new_turn()+ self._last_assistant_tool_turn = None+ return self._last_user_tool_turn+++def responses_to_inference_request(+ wire: OpenAIResponsesRequest,+) -> ResponsesIngressResult:+ """Validate and convert one public Responses request exactly once."""++ _validate_top_level(wire)+ builder = _TranscriptBuilder()+ if wire.instructions is not None:+ builder.system.append(+ InstructionItem(+ text=wire.instructions,+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ )+ )+ for index, item in enumerate(_input_items(wire.input)):+ _append_item(item, builder=builder, path=f"input[{index}]")+ builder.flush_reasoning()+ if not builder.items:+ raise ResponsesConversionError("Responses request input must contain a message")++ tool_choice = _tool_choice(wire.tool_choice)+ tools = _tools(wire.tools, raw_choice=wire.tool_choice)+ if (+ tool_choice is not None+ and tool_choice.mode is ToolChoiceMode.REQUIRED+ and not tools+ ):+ raise ResponsesConversionError(+ "tool_choice 'required' needs at least one executable function or custom tool"+ )+ metadata = (+ _json_object(wire.metadata, path="metadata")+ if wire.metadata is not None+ else None+ )+ request = InferenceRequest(+ model=_required_str(wire.model, path="model"),+ items=(*builder.system, *builder.items),+ tools=tools,+ tool_choice=tool_choice,+ parallel_tool_calls=wire.parallel_tool_calls,+ max_output_tokens=wire.max_output_tokens,+ temperature=wire.temperature,+ top_p=wire.top_p,+ reasoning=_reasoning_intent(wire.reasoning),+ metadata=metadata,+ )+ return ResponsesIngressResult(+ request=request,+ presentation=ResponsesPresentationSnapshot(+ model=request.model,+ parallel_tool_calls=(+ True if wire.parallel_tool_calls is None else wire.parallel_tool_calls+ ),+ tool_choice=_presentation_tool_choice(wire.tool_choice),+ temperature=wire.temperature,+ top_p=wire.top_p,+ max_output_tokens=wire.max_output_tokens,+ ),+ )+++def validate_responses_field_policy(wire: OpenAIResponsesRequest) -> None:+ """Apply protocol-wide rejection before routing or provider I/O."""++ _validate_top_level(wire)+ _tool_choice(wire.tool_choice)+ _tools(wire.tools, raw_choice=wire.tool_choice)+++def _validate_top_level(wire: OpenAIResponsesRequest) -> None:+ if wire.model_extra:+ key = sorted(str(key) for key in wire.model_extra)[0]+ raise ResponsesConversionError(f"request.{key} is not supported")+ if wire.stream is False:+ raise ResponsesConversionError(+ "stream=false is not supported; omit stream or set stream=true"+ )+ if wire.store is True:+ raise ResponsesConversionError("store=true is not supported")+ if wire.previous_response_id is not None:+ raise ResponsesConversionError("previous_response_id must be null or omitted")+ _validate_include(wire.include)+ _validate_prompt_cache_key(wire.prompt_cache_key)+ _reasoning_intent(wire.reasoning)+++def _validate_include(value: object) -> None:+ if value is None:+ return+ if value != ["reasoning.encrypted_content"]:+ raise ResponsesConversionError(+ "include must be exactly ['reasoning.encrypted_content'] when provided"+ )+++def _validate_prompt_cache_key(value: object) -> None:+ if value is None:+ return+ if not isinstance(value, str) or not value.strip():+ raise ResponsesConversionError(+ "prompt_cache_key must be a non-empty string when provided"+ )+++def _reasoning_intent(value: Mapping[str, object] | None) -> ClientReasoningIntent:+ if value is None:+ return ClientReasoningIntent()+ unknown = set(value) - {"effort", "summary"}+ if unknown:+ raise ResponsesConversionError(+ f"reasoning.{sorted(str(key) for key in unknown)[0]} is not supported"+ )+ summary = value.get("summary")+ if summary is not None and summary != "auto":+ raise ResponsesConversionError("reasoning.summary must be null or 'auto'")+ raw_effort = value.get("effort")+ if raw_effort is None:+ return ClientReasoningIntent()+ if not isinstance(raw_effort, str) or not raw_effort.strip():+ raise ResponsesConversionError("reasoning.effort must be a non-empty string")+ normalized = raw_effort.strip().lower()+ if normalized == "none":+ return ClientReasoningIntent(control=ReasoningControl.OFF)+ try:+ effort = ReasoningEffort(normalized)+ except ValueError as exc:+ raise ResponsesConversionError(+ f"reasoning.effort has unsupported value {raw_effort!r}"+ ) from exc+ return ClientReasoningIntent(control=ReasoningControl.ON, effort=effort)+++def _input_items(value: object) -> list[object]:+ if value is None:+ return []+ if isinstance(value, list):+ return value+ return [value]+++def _append_item(+ value: object,+ *,+ builder: _TranscriptBuilder,+ path: str,+) -> None:+ if isinstance(value, str):+ builder.flush_reasoning()+ turn_id = builder.new_turn()+ builder.items.append(+ MessageItem(turn_id, MessageRole.USER, (TextContent(value),))+ )+ return+ item = _mapping(value, path=path)+ item_type = item.get("type")+ if item_type in {None, "message"} or "role" in item:+ role = _required_str(item.get("role", "user"), path=f"{path}.role")+ _append_message(+ role,+ item.get("content", ""),+ builder=builder,+ path=path,+ )+ return+ if item_type == "reasoning":+ builder.pending_reasoning.add(item, path=path)+ return+ if item_type in {"function_call", "custom_tool_call"}:+ _append_tool_call(item, item_type=item_type, builder=builder, path=path)+ return+ if item_type in {"function_call_output", "custom_tool_call_output"}:+ _append_tool_result(item, item_type=item_type, builder=builder, path=path)+ return+ if item_type in {"input_text", "output_text", "text"}:+ builder.flush_reasoning()+ turn_id = builder.new_turn()+ builder.items.append(+ MessageItem(+ turn_id,+ MessageRole.USER,+ (TextContent(_text_from_part(item, path=path)),),+ )+ )+ return+ raise ResponsesConversionError(f"{path}.type {item_type!r} is not supported")+++def _append_message(+ role: str,+ content: object,+ *,+ builder: _TranscriptBuilder,+ path: str,+) -> None:+ if role in {"system", "developer"}:+ builder.flush_reasoning()+ text = _instruction_text(content, path=f"{path}.content")+ if text:+ turn_id = builder.new_turn()+ builder.items.append(+ InstructionItem(+ text=text,+ origin=(+ InstructionOrigin.DEVELOPER+ if role == "developer"+ else InstructionOrigin.SYSTEM+ ),+ placement=InstructionPlacement.TRANSCRIPT,+ turn_id=turn_id,+ )+ )+ builder.break_tool_groups()+ return+ if role not in {"user", "assistant"}:+ raise ResponsesConversionError(f"{path}.role {role!r} is not supported")+ if role == "user":+ builder.flush_reasoning()+ turn_id = builder.new_turn()+ if role == "assistant" and (+ reasoning := builder.pending_reasoning.take(turn_id=turn_id)+ ):+ builder.items.append(reasoning)+ parts = _message_content(content, path=f"{path}.content")+ builder.items.append(MessageItem(turn_id, MessageRole(role), parts))+ builder.break_tool_groups()+++def _append_tool_call(+ item: Mapping[str, object],+ *,+ item_type: object,+ builder: _TranscriptBuilder,+ path: str,+) -> None:+ call_id = _call_id(item)+ namespace = _optional_str(item.get("namespace"), path=f"{path}.namespace")+ name = _required_str(item.get("name"), path=f"{path}.name")+ if item_type == "function_call":+ try:+ tool_input = _function_arguments(+ item.get("arguments"), path=f"{path}.arguments"+ )+ except ResponsesConversionError as exc:+ builder.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+ kind = ToolCallKind.FUNCTION+ else:+ tool_input = _custom_input(item.get("input"), path=f"{path}.input")+ kind = ToolCallKind.CUSTOM+ turn_id = builder.assistant_tool_turn()+ if reasoning := builder.pending_reasoning.take(turn_id=turn_id):+ builder.items.append(reasoning)+ builder.items.append(+ ToolCallItem(+ turn_id=turn_id,+ call_id=call_id,+ kind=kind,+ name=name,+ namespace=namespace,+ input=tool_input,+ )+ )+++def _append_tool_result(+ item: Mapping[str, object],+ *,+ item_type: object,+ builder: _TranscriptBuilder,+ path: str,+) -> None:+ call_id = _call_id(item)+ if item_type == "function_call_output" and call_id in builder.quarantined_call_ids:+ return+ if builder.pending_reasoning.pending:+ turn_id = builder._last_assistant_tool_turn or builder.new_turn()+ if reasoning := builder.pending_reasoning.take(turn_id=turn_id):+ builder.items.append(reasoning)+ turn_id = builder.user_tool_turn()+ builder.items.append(+ ToolResultItem(+ turn_id=turn_id,+ call_id=call_id,+ content=_json_value(item.get("output", ""), path=f"{path}.output"),+ )+ )+++def _message_content(value: object, *, path: str) -> tuple[MessageContent, ...]:+ if isinstance(value, str):+ return (TextContent(value),)+ if isinstance(value, Mapping):+ return (_content_part(_mapping(value, path=path), path=path),)+ if not isinstance(value, list):+ raise ResponsesConversionError(f"{path} must be text or a list")+ parts: list[MessageContent] = []+ for index, raw_part in enumerate(value):+ part_path = f"{path}[{index}]"+ if isinstance(raw_part, str):+ parts.append(TextContent(raw_part))+ else:+ parts.append(+ _content_part(_mapping(raw_part, path=part_path), path=part_path)+ )+ return tuple(parts)+++def _content_part(part: Mapping[str, object], *, path: str) -> MessageContent:+ part_type = part.get("type")+ if part_type in {"input_text", "output_text", "text"}:+ return TextContent(_text_from_part(part, path=path))+ if part_type == "refusal":+ return RefusalContent(+ _required_str(part.get("refusal"), path=f"{path}.refusal")+ )+ raise ResponsesConversionError(f"{path}.type {part_type!r} is not supported")+++def _instruction_text(value: object, *, path: str) -> str:+ parts = _message_content(value, path=path)+ text: list[str] = []+ for index, part in enumerate(parts):+ if not isinstance(part, TextContent):+ raise ResponsesConversionError(+ f"{path}[{index}] instruction content must be text"+ )+ text.append(part.text)+ return "\n\n".join(text)+++def _reasoning_text_parts(item: Mapping[str, object], *, path: str) -> list[str]:+ content = _typed_text_list(+ item.get("content"),+ item_type="reasoning_text",+ path=f"{path}.content",+ )+ if content:+ return content+ return _typed_text_list(+ item.get("summary"),+ item_type="summary_text",+ path=f"{path}.summary",+ )+++def _typed_text_list(value: object, *, item_type: str, path: str) -> list[str]:+ if value is None:+ return []+ if not isinstance(value, list):+ raise ResponsesConversionError(f"{path} must be a list")+ parts: list[str] = []+ for index, raw_part in enumerate(value):+ part = _mapping(raw_part, path=f"{path}[{index}]")+ if part.get("type") != item_type:+ raise ResponsesConversionError(+ f"{path}[{index}].type must be {item_type!r}"+ )+ parts.append(_required_str(part.get("text"), path=f"{path}[{index}].text"))+ return parts+++def _tools(+ value: list[dict[str, object]] | None,+ *,+ raw_choice: object,+) -> tuple[FunctionTool | CustomTool, ...]:+ if value is None:+ return ()+ tools: list[FunctionTool | CustomTool] = []+ ambient_allowed = raw_choice is None or raw_choice == "auto"+ for index, raw_tool in enumerate(value):+ path = f"tools[{index}]"+ tool = _mapping(raw_tool, path=path)+ tool_type = tool.get("type")+ if tool_type in _AMBIENT_HOSTED_TOOL_TYPES:+ if ambient_allowed:+ continue+ if raw_choice == "none":+ continue+ continue+ if tool_type == "function":+ tools.append(_function_tool(tool, namespace=None, path=path))+ elif tool_type == "custom":+ tools.append(_custom_tool(tool, namespace=None, path=path))+ elif tool_type == "namespace":+ tools.extend(_namespace_tools(tool, path=path))+ else:+ raise ResponsesConversionError(+ f"{path}.type {tool_type!r} is not supported"+ )+ return tuple(tools)+++def _function_tool(+ tool: Mapping[str, object],+ *,+ namespace: str | None,+ path: str,+) -> FunctionTool:+ nested = tool.get("function")+ source = _mapping(nested, path=f"{path}.function") if nested is not None else tool+ name = _required_str(source.get("name"), path=f"{path}.name")+ raw_schema = source.get("parameters", {"type": "object", "properties": {}})+ schema = _json_object(raw_schema, path=f"{path}.parameters")+ strict = source.get("strict", False)+ if not isinstance(strict, bool):+ raise ResponsesConversionError(f"{path}.strict must be boolean")+ return FunctionTool(+ name=name,+ description=_optional_str(+ source.get("description"), path=f"{path}.description"+ ),+ input_schema=schema,+ strict=strict,+ namespace=namespace,+ )+++def _custom_tool(+ tool: Mapping[str, object],+ *,+ namespace: str | None,+ path: str,+) -> CustomTool:+ nested = tool.get("custom")+ source = _mapping(nested, path=f"{path}.custom") if nested is not None else tool+ name = _required_str(source.get("name"), path=f"{path}.name")+ raw_format = source.get("format")+ if raw_format is None:+ custom_format = CustomToolFormat(CustomToolFormatType.TEXT)+ else:+ format_value = _mapping(raw_format, path=f"{path}.format")+ format_type = format_value.get("type")+ if format_type == "text":+ custom_format = CustomToolFormat(CustomToolFormatType.TEXT)+ elif format_type == "grammar":+ custom_format = CustomToolFormat(+ CustomToolFormatType.GRAMMAR,+ syntax=_optional_str(+ format_value.get("syntax"),+ path=f"{path}.format.syntax",+ ),+ definition=_optional_str(+ format_value.get("definition"),+ path=f"{path}.format.definition",+ ),+ )+ else:+ raise ResponsesConversionError(+ f"{path}.format.type {format_type!r} is not supported"+ )+ return CustomTool(+ name=name,+ description=_optional_str(+ source.get("description"), path=f"{path}.description"+ ),+ format=custom_format,+ namespace=namespace,+ )+++def _namespace_tools(+ tool: Mapping[str, object], *, path: str+) -> list[FunctionTool | CustomTool]:+ namespace = _required_str(tool.get("name"), path=f"{path}.name")+ nested = tool.get("tools")+ if not isinstance(nested, list):+ raise ResponsesConversionError(f"{path}.tools must be a list")+ result: list[FunctionTool | CustomTool] = []+ for index, raw_tool in enumerate(nested):+ nested_path = f"{path}.tools[{index}]"+ nested_tool = _mapping(raw_tool, path=nested_path)+ if nested_tool.get("type") == "function":+ result.append(+ _function_tool(nested_tool, namespace=namespace, path=nested_path)+ )+ elif nested_tool.get("type") == "custom":+ result.append(+ _custom_tool(nested_tool, namespace=namespace, path=nested_path)+ )+ else:+ raise ResponsesConversionError(+ f"{nested_path}.type {nested_tool.get('type')!r} is not supported"+ )+ return result+++def _tool_choice(value: object) -> ToolChoice | None:+ if value is None or value == "auto":+ return None if value is None else ToolChoice(ToolChoiceMode.AUTO)+ if value == "none":+ return ToolChoice(ToolChoiceMode.NONE)+ if value == "required":+ return ToolChoice(ToolChoiceMode.REQUIRED)+ choice = _mapping(value, path="tool_choice")+ choice_type = choice.get("type")+ if choice_type in _AMBIENT_HOSTED_TOOL_TYPES:+ raise ResponsesConversionError(+ f"tool_choice.type {choice_type!r} cannot be selected explicitly"+ )+ if choice_type in {"auto"}:+ return ToolChoice(ToolChoiceMode.AUTO)+ if choice_type in {"any", "required"}:+ return ToolChoice(ToolChoiceMode.REQUIRED)+ if choice_type in {"function", "custom", "tool"}:+ nested = choice.get(str(choice_type))+ source = (+ _mapping(nested, path=f"tool_choice.{choice_type}")+ if nested is not None+ else choice+ )+ name = _required_str(source.get("name"), path="tool_choice.name")+ namespace = _optional_str(+ source.get("namespace", choice.get("namespace")),+ path="tool_choice.namespace",+ )+ return ToolChoice(+ ToolChoiceMode.SPECIFIC,+ kind=(+ ToolCallKind.CUSTOM+ if choice_type == "custom"+ else ToolCallKind.FUNCTION+ ),+ name=name,+ namespace=namespace,+ )+ raise ResponsesConversionError(f"tool_choice.type {choice_type!r} is not supported")+++def _presentation_tool_choice(value: object) -> object:+ if value is None:+ return "auto"+ return _json_value(value, path="tool_choice")+++def _function_arguments(value: object, *, path: str) -> dict[str, JsonValue]:+ if value is None or value == "":+ return {}+ if isinstance(value, Mapping):+ return _json_object(value, path=path)+ if not isinstance(value, str):+ raise ResponsesConversionError(f"{path} must be JSON")+ try:+ parsed = json.loads(value)+ except json.JSONDecodeError as exc:+ raise ResponsesConversionError(f"{path} is invalid JSON: {exc.msg}") from exc+ if not isinstance(parsed, dict):+ raise ResponsesConversionError(f"{path} must decode to an object")+ return _json_object(parsed, path=path)+++def _custom_input(value: object, *, path: str) -> str:+ if value is None:+ return ""+ if isinstance(value, str):+ return value+ return json.dumps(+ _json_value(value, path=path),+ ensure_ascii=False,+ separators=(",", ":"),+ )+++def _call_id(item: Mapping[str, object]) -> str:+ for key in ("call_id", "id"):+ value = item.get(key)+ if isinstance(value, str) and value:+ return value+ return new_call_id()+++def _text_from_part(part: Mapping[str, object], *, path: str) -> str:+ for key in ("text", "input_text", "output_text"):+ value = part.get(key)+ if isinstance(value, str):+ return value+ raise ResponsesConversionError(f"{path} requires a text value")+++def _mapping(value: object, *, path: str) -> Mapping[str, object]:+ if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):+ raise ResponsesConversionError(f"{path} must be an object")+ return cast(Mapping[str, object], value)+++def _required_str(value: object, *, path: str) -> str:+ if isinstance(value, str) and value:+ return value+ raise ResponsesConversionError(f"{path} must be a non-empty string")+++def _optional_str(value: object, *, path: str) -> str | None:+ if value is None:+ return None+ if not isinstance(value, str):+ raise ResponsesConversionError(f"{path} must be a string")+ return value+++def _json_object(value: object, *, path: str) -> dict[str, JsonValue]:+ mapping = _mapping(value, path=path)+ return {+ str(key): _json_value(item, path=f"{path}.{key}")+ for key, item in mapping.items()+ }+++def _json_value(value: object, *, path: str) -> JsonValue:+ if value is None or isinstance(value, bool | int | float | str):+ return value+ if isinstance(value, Mapping):+ if not all(isinstance(key, str) for key in value):+ raise ResponsesConversionError(f"{path} object keys must be strings")+ return {+ str(key): _json_value(item, path=f"{path}.{key}")+ for key, item in value.items()+ }+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):+ return [+ _json_value(item, path=f"{path}[{index}]")+ for index, item in enumerate(value)+ ]+ raise ResponsesConversionError(f"{path} must contain JSON-compatible values")diff --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..3dec9975 100644--- a/src/free_claude_code/core/openai_responses/models.py+++ b/src/free_claude_code/core/openai_responses/models.py@@ -1,6 +1,6 @@-"""Pydantic models for OpenAI Responses-compatible ingress."""+"""Wire and presentation models for OpenAI Responses-compatible ingress."""-from typing import Any+from dataclasses import dataclassfrom pydantic import BaseModel, ConfigDict@@ -11,16 +11,30 @@ class OpenAIResponsesRequest(BaseModel):model_config = ConfigDict(extra="allow")model: str- input: Any = None+ input: object = Noneinstructions: str | None = None- tools: list[dict[str, Any]] | None = None- tool_choice: Any = None+ tools: list[dict[str, object]] | None = None+ tool_choice: object = 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: dict[str, object] | None = None+ reasoning: dict[str, object] | None = Noneprevious_response_id: str | None = Nonestore: bool | None = None+ include: object = None+ prompt_cache_key: object = None+++@dataclass(frozen=True, slots=True)+class ResponsesPresentationSnapshot:+ """Validated fields echoed in public Responses envelopes."""++ model: str+ parallel_tool_calls: bool+ tool_choice: object+ temperature: float | None+ top_p: float | None+ max_output_tokens: int | Nonediff --git a/src/free_claude_code/core/openai_responses/presenter.py b/src/free_claude_code/core/openai_responses/presenter.pyindex 4cd6ac98..a59f9bae 100644--- a/src/free_claude_code/core/openai_responses/presenter.py+++ b/src/free_claude_code/core/openai_responses/presenter.py@@ -1,6 +1,7 @@"""Present canonical inference events through the OpenAI Responses protocol."""import asyncio+import jsonimport sysimport timeimport uuid@@ -17,7 +18,6 @@ from free_claude_code.core.inference import (ReasoningBlockStarted,ReasoningDelta,ReplayArtifact,- ReplayArtifactKind,ResponseCompleted,ResponseStarted,TextBlockCompleted,@@ -28,9 +28,9 @@ from free_claude_code.core.inference import (ToolCallKind,ToolCallStarted,UsageUpdated,- replay_payload_text,)from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.core.replay_envelope import encode_replay_envelopefrom free_claude_code.core.token_estimation import estimate_text_tokensfrom free_claude_code.core.trace import close_stream_input, trace_event@@ -45,14 +45,9 @@ from .ids import (new_reasoning_item_id,new_response_id,)-from .models import OpenAIResponsesRequest+from .models import ResponsesPresentationSnapshotfrom .streaming.error_mapping import replay_unsafe_function_call_errorfrom .streaming.event_builders import ResponseEventBuilder-from .tools import (- custom_tool_input_text_from_arguments,- normalized_function_call_arguments,- responses_tool_identity_from_anthropic_name,-)PostStartTerminalFailureObserver = Callable[[BaseException], None]@@ -89,8 +84,8 @@ type _OutputState = _TextState | _ReasoningState | _ToolStateclass ResponsesEventPresenter:"""Serialize one canonical stream while owning Responses envelope state."""- def __init__(self, request: OpenAIResponsesRequest) -> None:- self._request = request+ def __init__(self, snapshot: ResponsesPresentationSnapshot) -> None:+ self._snapshot = snapshotself._response_id = new_response_id()self._created_at = int(time.time())self._events = ResponseEventBuilder()@@ -145,21 +140,21 @@ class ResponsesEventPresenter:"object": "response","created_at": self._created_at,"status": status,- "model": self._request.model,+ "model": self._snapshot.model,"output": [item for item in self._output if item is not None],"parallel_tool_calls": (True- if self._request.parallel_tool_calls is None- else self._request.parallel_tool_calls+ if self._snapshot.parallel_tool_calls is None+ else self._snapshot.parallel_tool_calls),"tool_choice": _json_value("auto"- if self._request.tool_choice is None- else self._request.tool_choice+ if self._snapshot.tool_choice is None+ else self._snapshot.tool_choice),- "temperature": self._request.temperature,- "top_p": self._request.top_p,- "max_output_tokens": self._request.max_output_tokens,+ "temperature": self._snapshot.temperature,+ "top_p": self._snapshot.top_p,+ "max_output_tokens": self._snapshot.max_output_tokens,"usage": _responses_usage(self._usage,reasoning_estimate=self._reasoning_tokens_estimate,@@ -271,23 +266,15 @@ class ResponsesEventPresenter:return chunksdef _tool_started(self, event: ToolCallStarted) -> list[str]:- identity = responses_tool_identity_from_anthropic_name(- self._request.tools,- event.name,- )- kind = (- ToolCallKind.CUSTOM- if event.kind is ToolCallKind.CUSTOM or identity.kind == "custom"- else ToolCallKind.FUNCTION- )+ kind = event.kindstate = _ToolState(output_index=self._reserve_output(),item_id=f"{'ctc' if kind is ToolCallKind.CUSTOM else 'fc'}_"f"{uuid.uuid4().hex[:24]}",call_id=event.call_id or new_call_id(),kind=kind,- name=identity.name if identity.name else event.name,- namespace=identity.namespace or event.namespace,+ name=event.name,+ namespace=event.namespace,)self._set_block(event.block_id, state)return [@@ -308,7 +295,7 @@ class ResponsesEventPresenter:if state.kind is ToolCallKind.CUSTOM:return self._complete_custom_tool(state, arguments)try:- normalized = normalized_function_call_arguments(arguments or "{}")+ normalized = _normalized_function_call_arguments(arguments or "{}")except ResponsesConversionError as exc:trace_event(stage="responses",@@ -344,7 +331,7 @@ class ResponsesEventPresenter:return chunksdef _complete_custom_tool(self, state: _ToolState, arguments: str) -> list[str]:- input_text = custom_tool_input_text_from_arguments(arguments)+ input_text = _custom_tool_input_text_from_arguments(arguments)item = _tool_item(state, status="completed", input_text=input_text)self._commit_output(state.output_index, item)chunks: list[str] = []@@ -425,13 +412,13 @@ class ResponsesEventPresenter:async def iter_responses_sse_from_events(events: AsyncIterator[InferenceEvent],- request: OpenAIResponsesRequest,+ snapshot: ResponsesPresentationSnapshot,*,on_post_start_terminal_failure: PostStartTerminalFailureObserver | None = None,) -> AsyncIterator[str]:"""Serialize canonical events and map only post-start failures to wire events."""- presenter = ResponsesEventPresenter(request)+ presenter = ResponsesEventPresenter(snapshot)emitted_any = Falsetry:async for event in events:@@ -526,14 +513,41 @@ def _reasoning_item(def _encrypted_reasoning(artifacts: tuple[ReplayArtifact, ...],) -> str | None:- for artifact in artifacts:- if artifact.kind in {- ReplayArtifactKind.REDACTED_THINKING,- ReplayArtifactKind.ENCRYPTED_REASONING,- ReplayArtifactKind.REASONING_DETAILS,- }:- return replay_payload_text(artifact)- return None+ return encode_replay_envelope(artifacts) if artifacts else None+++def _normalized_function_call_arguments(value: str) -> str:+ try:+ parsed = json.loads(value)+ except json.JSONDecodeError as exc:+ raise ResponsesConversionError(+ f"Responses function_call arguments are invalid JSON: {exc.msg}"+ ) from exc+ if not isinstance(parsed, dict):+ raise ResponsesConversionError(+ "Responses function_call arguments must decode to an object"+ )+ return json.dumps(parsed, separators=(",", ":"))+++def _custom_tool_input_text_from_arguments(arguments: str) -> str:+ if not arguments:+ return ""+ try:+ parsed = json.loads(arguments)+ except json.JSONDecodeError:+ return arguments+ if isinstance(parsed, Mapping):+ value = parsed.get("input")+ if value is None and not parsed:+ return ""+ if value is None:+ value = parsed+ else:+ value = parsed+ if isinstance(value, str):+ return value+ return json.dumps(value, ensure_ascii=False, separators=(",", ":"))def _tool_item(diff --git a/src/free_claude_code/core/openai_responses/provider_input.py b/src/free_claude_code/core/openai_responses/provider_input.pydeleted file mode 100644index f18030e5..00000000--- a/src/free_claude_code/core/openai_responses/provider_input.py+++ /dev/null@@ -1,352 +0,0 @@-"""Convert Anthropic Messages into an upstream OpenAI Responses request."""--import json-from typing import Any--from free_claude_code.core.anthropic.content import get_block_attr, get_block_type-from free_claude_code.core.anthropic.conversion import resolve_anthropic_tool_choice-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec-from free_claude_code.core.anthropic.request_serialization import (- serialize_tool_result_content,-)-from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy--from .errors import ResponsesConversionError---def build_responses_provider_request(- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,-) -> dict[str, Any]:- """Build a stateless Responses request without silently dropping fields."""-- _validate_supported_request(request)- tool_names = OpenAIToolNameCodec.from_request(request)- instructions = _system_text(request)- input_items: list[dict[str, Any]] = []- for message in request.messages:- if message.role == "system":- text = _message_text(message.content, context="system message")- if text:- instructions.append(text)- elif message.role == "assistant":- input_items.extend(- _assistant_items(- message.content,- reasoning_content=message.reasoning_content,- tool_names=tool_names,- )- )- else:- input_items.extend(_user_items(message.content))-- if not input_items:- raise ResponsesConversionError(- "OpenAI Responses conversion requires at least one user or assistant item."- )-- body: dict[str, Any] = {- "model": request.model,- "input": input_items,- "stream": True,- "store": False,- "include": ["reasoning.encrypted_content"],- }- if instructions:- body["instructions"] = "\n\n".join(instructions)- if request.max_tokens is not None:- body["max_output_tokens"] = request.max_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- if request.tools:- body["tools"] = [- {- "type": "function",- "name": tool_names.encode(tool.name),- "description": tool.description,- "parameters": tool.input_schema or {"type": "object", "properties": {}},- "strict": False,- }- for tool in request.tools- ]- 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):- body["reasoning"] = reasoning_config- return body---def _validate_supported_request(request: MessagesRequest) -> None:- if request.model_extra:- raise ResponsesConversionError(- "OpenAI Responses does not support these request fields: "- f"{sorted(str(key) for key in request.model_extra)}."- )- provider_tool_types = sorted(- {tool.type for tool in request.tools or () if tool.type is not None}- )- if provider_tool_types:- raise ResponsesConversionError(- "OpenAI Responses cannot represent provider-managed tool types: "- f"{provider_tool_types}."- )- unsupported: list[str] = []- if request.stop_sequences:- unsupported.append("stop_sequences")- if request.top_k is not None:- unsupported.append("top_k")- if not _is_noop_context_management(request.context_management):- unsupported.append("context_management")- unsupported.extend(_unsupported_output_config_paths(request.output_config))- if request.mcp_servers:- unsupported.append("mcp_servers")- if request.extra_body:- unsupported.append("extra_body")- if unsupported:- raise ResponsesConversionError(- "OpenAI Responses cannot represent these fields without data loss: "- f"{unsupported}."- )---def _unsupported_output_config_paths(- output_config: dict[str, Any] | None,-) -> list[str]:- if not output_config:- return []- return [f"output_config.{key}" for key in sorted(output_config) if key != "effort"]---def _is_noop_context_management(- context_management: dict[str, Any] | None,-) -> bool:- if not context_management:- return True- if set(context_management) != {"edits"}:- return False- edits = context_management["edits"]- return isinstance(edits, list) and all(- isinstance(edit, dict)- and edit- == {- "type": "clear_thinking_20251015",- "keep": "all",- }- for edit in edits- )---def _system_text(request: MessagesRequest) -> list[str]:- if request.system is None:- return []- if isinstance(request.system, str):- return [request.system] if request.system else []- return [part.text for part in request.system if part.text]---def _assistant_items(- content: Any,- *,- reasoning_content: str | None,- tool_names: OpenAIToolNameCodec,-) -> list[dict[str, Any]]:- if isinstance(content, str):- items = [_assistant_message([{"type": "output_text", "text": content}])]- if reasoning_content is not None:- items.insert(- 0,- {- "type": "reasoning",- "summary": [{"type": "summary_text", "text": reasoning_content}],- },- )- return items- if not isinstance(content, list):- raise ResponsesConversionError(- "Assistant content must be text or content blocks."- )-- items: list[dict[str, Any]] = []- text_parts: list[dict[str, Any]] = []- thinking_parts: list[str] = (- [reasoning_content] if reasoning_content is not None else []- )- encrypted_parts: list[str] = []-- def flush_text() -> None:- if text_parts:- items.append(_assistant_message(list(text_parts)))- text_parts.clear()-- for block in content:- block_type = get_block_type(block)- if block_type == "text":- text_parts.append(- {- "type": "output_text",- "text": str(get_block_attr(block, "text", "")),- }- )- elif block_type == "thinking":- thinking_parts.append(str(get_block_attr(block, "thinking", "")))- elif block_type == "redacted_thinking":- encrypted_parts.append(str(get_block_attr(block, "data", "")))- elif block_type == "tool_use":- flush_text()- items.append(- {- "type": "function_call",- "call_id": str(get_block_attr(block, "id", "")),- "name": tool_names.encode(str(get_block_attr(block, "name", ""))),- "arguments": json.dumps(- get_block_attr(block, "input", {}),- ensure_ascii=False,- separators=(",", ":"),- ),- }- )- else:- raise ResponsesConversionError(- "OpenAI Responses cannot represent assistant content block "- f"{block_type!r}."- )- if thinking_parts or encrypted_parts:- summary = [- {"type": "summary_text", "text": text} for text in thinking_parts if text- ]- if encrypted_parts:- for index, encrypted in enumerate(encrypted_parts):- item: dict[str, Any] = {- "type": "reasoning",- "summary": summary if index == 0 else [],- "encrypted_content": encrypted,- }- items.insert(index, item)- else:- items.insert(0, {"type": "reasoning", "summary": summary})- flush_text()- return items---def _user_items(content: Any) -> list[dict[str, Any]]:- if isinstance(content, str):- return [_user_message([{"type": "input_text", "text": content}])]- if not isinstance(content, list):- raise ResponsesConversionError("User content must be text or content blocks.")-- items: list[dict[str, Any]] = []- message_parts: list[dict[str, Any]] = []-- def flush_message() -> None:- if message_parts:- items.append(_user_message(list(message_parts)))- message_parts.clear()-- for block in content:- block_type = get_block_type(block)- if block_type == "text":- message_parts.append(- {- "type": "input_text",- "text": str(get_block_attr(block, "text", "")),- }- )- elif block_type == "image":- message_parts.append(_image_part(block))- elif block_type == "tool_result":- flush_message()- items.append(- {- "type": "function_call_output",- "call_id": str(get_block_attr(block, "tool_use_id", "")),- "output": serialize_tool_result_content(- get_block_attr(block, "content")- ),- }- )- elif block_type == "document":- raise ResponsesConversionError(- "OpenAI Responses provider does not support Anthropic document blocks."- )- else:- raise ResponsesConversionError(- f"OpenAI Responses cannot represent user content block {block_type!r}."- )- flush_message()- return items---def _image_part(block: Any) -> dict[str, Any]:- source = get_block_attr(block, "source", {})- source_type = get_block_attr(source, "type")- if source_type == "url":- url = get_block_attr(source, "url")- elif source_type == "base64":- media_type = get_block_attr(source, "media_type")- data = get_block_attr(source, "data")- if not isinstance(media_type, str) or not isinstance(data, str):- raise ResponsesConversionError("Base64 images require media_type and data.")- url = f"data:{media_type};base64,{data}"- else:- raise ResponsesConversionError(- f"Unsupported image source type {source_type!r}."- )- if not isinstance(url, str) or not url:- raise ResponsesConversionError("Image source requires a non-empty URL.")- return {"type": "input_image", "image_url": url}---def _message_text(content: Any, *, context: str) -> str:- if isinstance(content, str):- return content- if not isinstance(content, list):- raise ResponsesConversionError(f"{context} must contain only text.")- parts: list[str] = []- for block in content:- if get_block_type(block) != "text":- raise ResponsesConversionError(f"{context} must contain only text.")- parts.append(str(get_block_attr(block, "text", "")))- return "\n\n".join(parts)---def _assistant_message(content: list[dict[str, Any]]) -> dict[str, Any]:- return {"type": "message", "role": "assistant", "content": content}---def _user_message(content: list[dict[str, Any]]) -> dict[str, Any]:- return {"type": "message", "role": "user", "content": content}---def _tool_choice(- choice: dict[str, Any],- *,- tool_names: OpenAIToolNameCodec,-) -> str | dict[str, str]:- choice_type = choice.get("type")- if choice_type in {"auto", "none"}:- return str(choice_type)- if choice_type == "any":- return "required"- if choice_type == "tool":- name = choice.get("name")- if not isinstance(name, str) or not name:- 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/reasoning.py b/src/free_claude_code/core/openai_responses/reasoning.pyindex 5617a0e4..6d42280e 100644--- a/src/free_claude_code/core/openai_responses/reasoning.py+++ b/src/free_claude_code/core/openai_responses/reasoning.py@@ -3,8 +3,6 @@from collections.abc import Mappingfrom typing import Any-from .tools import optional_str-def reasoning_text_from_item(item: Mapping[str, Any]) -> str | None:content_parts = _text_parts_from_items(@@ -23,7 +21,7 @@ def reasoning_text_from_item(item: Mapping[str, Any]) -> str | None:def encrypted_reasoning_from_item(item: Mapping[str, Any]) -> str | None:"""Return opaque reasoning content without interpreting it."""- return optional_str(item.get("encrypted_content"))+ return _optional_str(item.get("encrypted_content"))def combine_reasoning(existing: str | None, addition: str | None) -> str | None:@@ -54,7 +52,11 @@ def _text_parts_from_items(value: Any, *, item_type: str) -> list[str]:parts: list[str] = []for item in value:if isinstance(item, dict) and item.get("type") == item_type:- text = optional_str(item.get("text"))+ text = _optional_str(item.get("text"))if text is not None:parts.append(text)return parts+++def _optional_str(value: object) -> str | None:+ return value if isinstance(value, str) else Nonediff --git a/src/free_claude_code/core/openai_responses/tools.py b/src/free_claude_code/core/openai_responses/tools.pydeleted file mode 100644index 259e75e7..00000000--- a/src/free_claude_code/core/openai_responses/tools.py+++ /dev/null@@ -1,375 +0,0 @@-"""Tool conversion helpers for the OpenAI Responses adapter."""--import hashlib-import json-import re-from collections.abc import Mapping-from dataclasses import dataclass-from typing import Any, Literal--from .errors import ResponsesConversionError-from .ids import new_call_id--_MAX_ANTHROPIC_TOOL_NAME_LEN = 64-_NAMESPACE_TOOL_SEPARATOR = "__"-_UNSUPPORTED_PASSIVE_TOOL_TYPES = frozenset(- {"web_search", "image_generation", "tool_search"}-)-_INVALID_TOOL_NAME_CHARS = re.compile(r"[^A-Za-z0-9_-]+")---@dataclass(frozen=True, slots=True)-class ResponsesToolIdentity:- kind: Literal["function", "custom"]- name: str- namespace: str | None = None---def convert_tools(value: Any) -> list[dict[str, Any]] | None:- if value is None:- return None- if not isinstance(value, list):- raise ResponsesConversionError("Responses tools must be a list")-- tools: list[dict[str, Any]] = []- for tool in value:- if not isinstance(tool, dict):- raise ResponsesConversionError(- f"Unsupported Responses tool: {type(tool).__name__}"- )- tool_type = tool.get("type")- if tool_type == "function":- tools.append(_convert_function_tool(tool, namespace=None))- continue- if tool_type == "custom":- tools.append(_convert_custom_tool(tool, namespace=None))- continue- if tool_type == "namespace":- tools.extend(_convert_namespace_tool(tool))- continue- if tool_type in _UNSUPPORTED_PASSIVE_TOOL_TYPES:- continue- if tool_type != "function":- raise ResponsesConversionError(- f"Unsupported Responses tool type: {tool_type!r}"- )- return tools---def convert_tool_choice(value: Any) -> dict[str, Any] | None:- if value is None or value == "auto":- return None- if value == "none":- return None- if value == "required":- return {"type": "any"}- if isinstance(value, dict):- choice_type = value.get("type")- if choice_type == "function":- namespace = optional_str(value.get("namespace"))- name = required_str(value.get("name"), "tool_choice.name")- return {- "type": "tool",- "name": responses_tool_name_to_anthropic_name(- name, namespace=namespace- ),- }- if choice_type == "custom":- source = _custom_source(value)- namespace = optional_str(source.get("namespace")) or optional_str(- value.get("namespace")- )- name = required_str(source.get("name"), "tool_choice.name")- return {- "type": "tool",- "name": responses_tool_name_to_anthropic_name(- name, namespace=namespace- ),- }- if choice_type == "tool":- namespace = optional_str(value.get("namespace"))- name = optional_str(value.get("name"))- if name:- return {- "type": "tool",- "name": responses_tool_name_to_anthropic_name(- name, namespace=namespace- ),- }- return dict(value)- if choice_type in {"auto", "any"}:- return dict(value)- raise ResponsesConversionError(f"Unsupported Responses tool_choice: {value!r}")---def responses_tool_name_to_anthropic_name(- name: str, *, namespace: str | None = None-) -> str:- """Return a deterministic Anthropic tool name for a Responses tool identity."""-- if not namespace:- return name- combined = (- f"{_tool_name_part(namespace)}"- f"{_NAMESPACE_TOOL_SEPARATOR}"- f"{_tool_name_part(name)}"- )- if len(combined) <= _MAX_ANTHROPIC_TOOL_NAME_LEN:- return combined- digest = hashlib.sha1(combined.encode("utf-8")).hexdigest()[:8]- prefix_len = _MAX_ANTHROPIC_TOOL_NAME_LEN - len(digest) - 1- return f"{combined[:prefix_len]}_{digest}"---def responses_tool_identity_from_anthropic_name(- tools: list[dict[str, Any]] | None, anthropic_name: str-) -> ResponsesToolIdentity:- """Return the Responses namespace/name represented by an Anthropic tool name."""-- if tools is None:- return ResponsesToolIdentity(kind="function", name=anthropic_name)- for tool in tools:- if not isinstance(tool, dict):- continue- tool_type = tool.get("type")- if tool_type == "function":- source = tool.get("function")- function = source if isinstance(source, dict) else tool- if (name := optional_str(function.get("name"))) and (- responses_tool_name_to_anthropic_name(name) == anthropic_name- ):- return ResponsesToolIdentity(kind="function", name=name)- continue- if tool_type == "custom":- source = _custom_source(tool)- if (name := optional_str(source.get("name"))) and (- responses_tool_name_to_anthropic_name(name) == anthropic_name- ):- return ResponsesToolIdentity(kind="custom", name=name)- continue- if tool_type != "namespace":- continue- namespace = optional_str(tool.get("name"))- nested_tools = tool.get("tools")- if not namespace or not isinstance(nested_tools, list):- continue- for nested_tool in nested_tools:- if not isinstance(nested_tool, dict):- continue- nested_tool_type = nested_tool.get("type")- if nested_tool_type == "function":- source = nested_tool.get("function")- function = source if isinstance(source, dict) else nested_tool- if (name := optional_str(function.get("name"))) and (- responses_tool_name_to_anthropic_name(name, namespace=namespace)- == anthropic_name- ):- return ResponsesToolIdentity(- kind="function", name=name, namespace=namespace- )- continue- if nested_tool_type == "custom":- source = _custom_source(nested_tool)- if (name := optional_str(source.get("name"))) and (- responses_tool_name_to_anthropic_name(name, namespace=namespace)- == anthropic_name- ):- return ResponsesToolIdentity(- kind="custom", name=name, namespace=namespace- )- return ResponsesToolIdentity(kind="function", name=anthropic_name)---def parse_arguments(value: Any) -> dict[str, Any]:- if value is None or value == "":- return {}- if isinstance(value, dict):- return value- if not isinstance(value, str):- raise ResponsesConversionError("Responses function_call arguments must be JSON")- try:- parsed = json.loads(value)- except json.JSONDecodeError as exc:- raise ResponsesConversionError(- f"Responses function_call arguments are invalid JSON: {exc.msg}"- ) from exc- if not isinstance(parsed, dict):- raise ResponsesConversionError(- "Responses function_call arguments must decode to an object"- )- return parsed---def normalized_function_call_arguments(value: Any) -> str:- return json.dumps(parse_arguments(value), separators=(",", ":"))---def custom_tool_input_to_anthropic(value: Any) -> dict[str, str]:- return {"input": custom_tool_input_text(value)}---def custom_tool_input_text(value: Any) -> str:- if value is None:- return ""- if isinstance(value, str):- return value- return _json_dumps(value)---def custom_tool_input_text_from_anthropic(value: Any) -> str:- if isinstance(value, Mapping):- raw_input = value.get("input")- if isinstance(raw_input, str):- return raw_input- if raw_input is not None:- return custom_tool_input_text(raw_input)- if not value:- return ""- return _json_dumps(value)- return custom_tool_input_text(value)---def custom_tool_input_text_from_arguments(arguments: str) -> str:- if not arguments:- return ""- try:- parsed = json.loads(arguments)- except json.JSONDecodeError:- return arguments- return custom_tool_input_text_from_anthropic(parsed)---def call_id_from_item(item: Mapping[str, Any]) -> str:- for key in ("call_id", "id"):- if value := optional_str(item.get(key)):- return value- return new_call_id()---def required_str(value: Any, field_name: str) -> str:- if isinstance(value, str) and value:- return value- raise ResponsesConversionError(- f"Responses field {field_name} must be a non-empty string"- )---def optional_str(value: Any) -> str | None:- return value if isinstance(value, str) else None---def _convert_namespace_tool(tool: Mapping[str, Any]) -> list[dict[str, Any]]:- namespace = required_str(tool.get("name"), "tool.namespace.name")- nested_tools = tool.get("tools")- if not isinstance(nested_tools, list):- raise ResponsesConversionError(- f"Responses namespace tool {namespace!r} tools must be a list"- )-- converted_tools: list[dict[str, Any]] = []- for nested_tool in nested_tools:- if not isinstance(nested_tool, dict):- raise ResponsesConversionError(- f"Unsupported Responses namespace tool: {type(nested_tool).__name__}"- )- nested_tool_type = nested_tool.get("type")- if nested_tool_type == "function":- converted_tools.append(- _convert_function_tool(nested_tool, namespace=namespace)- )- continue- if nested_tool_type == "custom":- converted_tools.append(- _convert_custom_tool(nested_tool, namespace=namespace)- )- continue- raise ResponsesConversionError(- f"Unsupported Responses namespace tool type: {nested_tool_type!r}"- )- return converted_tools---def _convert_function_tool(- tool: Mapping[str, Any], *, namespace: str | None-) -> dict[str, Any]:- function = tool.get("function")- source = function if isinstance(function, dict) else tool- name = required_str(source.get("name"), "tool.name")- schema = source.get("parameters")- if schema is None:- schema = {"type": "object", "properties": {}}- if not isinstance(schema, dict):- raise ResponsesConversionError(- f"Responses tool {name!r} parameters must be an object"- )- converted: dict[str, Any] = {- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),- "input_schema": schema,- }- if description := optional_str(source.get("description")):- converted["description"] = description- return converted---def _convert_custom_tool(- tool: Mapping[str, Any], *, namespace: str | None-) -> dict[str, Any]:- source = _custom_source(tool)- name = required_str(source.get("name"), "tool.name")- converted: dict[str, Any] = {- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),- "input_schema": {- "type": "object",- "properties": {- "input": {- "type": "string",- "description": "Free-form input for the custom tool.",- }- },- "required": ["input"],- },- }- if description := _custom_tool_description(source):- converted["description"] = description- return converted---def _custom_source(tool: Mapping[str, Any]) -> Mapping[str, Any]:- custom = tool.get("custom")- return custom if isinstance(custom, Mapping) else tool---def _custom_tool_description(source: Mapping[str, Any]) -> 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)- elif format_type:- parts.append(f"Custom tool input format: {format_type}.")- else:- parts.append(f"Custom tool input format: {_json_dumps(format_value)}")- return "\n\n".join(parts) if parts else None---def _tool_name_part(value: str) -> str:- normalized = _INVALID_TOOL_NAME_CHARS.sub("_", value).strip("_")- return normalized or "tool"---def _json_dumps(value: Any) -> str:- try:- return json.dumps(value)- except TypeError:- return str(value)diff --git a/src/free_claude_code/core/replay_envelope.py b/src/free_claude_code/core/replay_envelope.pynew file mode 100644index 00000000..f1d92608--- /dev/null+++ b/src/free_claude_code/core/replay_envelope.py@@ -0,0 +1,169 @@+"""Versioned public envelope for opaque inference replay artifacts."""++import base64+import binascii+import json+import math+from collections.abc import Mapping, Sequence++from free_claude_code.core.inference import (+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ReplayCompatibilityScope,+)+from free_claude_code.core.json_types import JsonValue++REPLAY_ENVELOPE_PREFIX = "fcc-replay-v1:"+_REPLAY_ENVELOPE_VERSION = 1+_MAX_REPLAY_ENVELOPE_BYTES = 1_048_576+_ARTIFACT_KEYS = frozenset({"origin", "kind", "attachment", "scope", "payload"})+++class ReplayEnvelopeError(ValueError):+ """A recognized FCC replay envelope is malformed or unsupported."""+++def encode_replay_envelope(artifacts: tuple[ReplayArtifact, ...]) -> str:+ """Encode ordered replay artifacts into the deterministic v1 carrier."""++ if not artifacts:+ raise ValueError("a replay envelope requires at least one artifact")+ payload = {+ "version": _REPLAY_ENVELOPE_VERSION,+ "artifacts": [+ {+ "origin": artifact.origin.value,+ "kind": artifact.kind.value,+ "attachment": artifact.attachment.value,+ "scope": (artifact.scope.value if artifact.scope is not None else None),+ "payload": _json_copy(artifact.payload),+ }+ for artifact in artifacts+ ],+ }+ encoded = json.dumps(+ payload,+ allow_nan=False,+ ensure_ascii=False,+ separators=(",", ":"),+ sort_keys=True,+ ).encode("utf-8")+ if len(encoded) > _MAX_REPLAY_ENVELOPE_BYTES:+ raise ValueError("replay envelope exceeds the supported size limit")+ carrier = base64.urlsafe_b64encode(encoded).decode("ascii").rstrip("=")+ return f"{REPLAY_ENVELOPE_PREFIX}{carrier}"+++def decode_replay_envelope(+ value: str,+ *,+ attachment: ReplayAttachment,+) -> tuple[ReplayArtifact, ...] | None:+ """Decode a recognized carrier, or return ``None`` for a legacy raw value."""++ if not value.startswith(REPLAY_ENVELOPE_PREFIX):+ return None+ token = value.removeprefix(REPLAY_ENVELOPE_PREFIX)+ if not token:+ raise ReplayEnvelopeError("FCC replay envelope payload is empty")+ padding = "=" * (-len(token) % 4)+ try:+ raw = base64.b64decode(+ token + padding,+ altchars=b"-_",+ validate=True,+ )+ except (binascii.Error, ValueError) as exc:+ raise ReplayEnvelopeError("FCC replay envelope is not valid base64url") from exc+ if len(raw) > _MAX_REPLAY_ENVELOPE_BYTES:+ raise ReplayEnvelopeError(+ "FCC replay envelope exceeds the supported size limit"+ )+ try:+ payload = json.loads(raw.decode("utf-8"))+ except (UnicodeDecodeError, json.JSONDecodeError) as exc:+ raise ReplayEnvelopeError(+ "FCC replay envelope is not valid UTF-8 JSON"+ ) from exc+ if not isinstance(payload, dict) or set(payload) != {"version", "artifacts"}:+ raise ReplayEnvelopeError("FCC replay envelope has an invalid top-level schema")+ if payload.get("version") != _REPLAY_ENVELOPE_VERSION:+ raise ReplayEnvelopeError("FCC replay envelope version is unsupported")+ raw_artifacts = payload.get("artifacts")+ if not isinstance(raw_artifacts, list) or not raw_artifacts:+ raise ReplayEnvelopeError(+ "FCC replay envelope artifacts must be a non-empty list"+ )+ artifacts = tuple(+ _decode_artifact(raw_artifact, index=index, attachment=attachment)+ for index, raw_artifact in enumerate(raw_artifacts)+ )+ return artifacts+++def _decode_artifact(+ value: object,+ *,+ index: int,+ attachment: ReplayAttachment,+) -> ReplayArtifact:+ path = f"artifacts[{index}]"+ if not isinstance(value, dict) or set(value) != _ARTIFACT_KEYS:+ raise ReplayEnvelopeError(f"FCC replay envelope {path} has an invalid schema")+ try:+ origin = ReplayArtifactOrigin(value["origin"])+ kind = ReplayArtifactKind(value["kind"])+ decoded_attachment = ReplayAttachment(value["attachment"])+ except (KeyError, TypeError, ValueError) as exc:+ raise ReplayEnvelopeError(+ f"FCC replay envelope {path} has an unknown artifact value"+ ) from exc+ if decoded_attachment is not attachment:+ raise ReplayEnvelopeError(+ f"FCC replay envelope {path}.attachment does not match its carrier"+ )+ raw_scope = value.get("scope")+ if raw_scope is not None and (+ not isinstance(raw_scope, str) or not raw_scope.strip()+ ):+ raise ReplayEnvelopeError(+ f"FCC replay envelope {path}.scope must be null or a non-empty string"+ )+ raw_payload = value.get("payload")+ if not _is_json_value(raw_payload):+ raise ReplayEnvelopeError(+ f"FCC replay envelope {path}.payload is not valid JSON"+ )+ return ReplayArtifact(+ origin=origin,+ kind=kind,+ attachment=decoded_attachment,+ payload=raw_payload,+ scope=(+ ReplayCompatibilityScope(raw_scope) if isinstance(raw_scope, str) else None+ ),+ )+++def _is_json_value(value: object) -> bool:+ if value is None or isinstance(value, bool | int | str):+ return True+ if isinstance(value, float):+ return math.isfinite(value)+ if isinstance(value, list):+ return all(_is_json_value(item) for item in value)+ if isinstance(value, dict):+ return all(+ isinstance(key, str) and _is_json_value(item) for key, item in value.items()+ )+ return False+++def _json_copy(value: JsonValue) -> JsonValue:+ if isinstance(value, Mapping):+ return {str(key): _json_copy(item) for key, item in value.items()}+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):+ return [_json_copy(item) for item in value]+ return valuediff --git a/src/free_claude_code/providers/base.py b/src/free_claude_code/providers/base.pyindex ab426729..5435b8fb 100644--- a/src/free_claude_code/providers/base.py+++ b/src/free_claude_code/providers/base.py@@ -7,12 +7,11 @@ from dataclasses import dataclassfrom loguru import loggerfrom free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.diagnostics import (exception_cause_types,redacted_exception_traceback,)-from free_claude_code.core.inference import InferenceEvent+from free_claude_code.core.inference import InferenceEvent, InferenceRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.core.trace import trace_event@@ -47,8 +46,9 @@ class BaseProvider(ABC):@abstractmethoddef preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:"""Validate the upstream request before opening an SSE stream."""@@ -107,9 +107,10 @@ class BaseProvider(ABC):@abstractmethoddef stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,diff --git a/src/free_claude_code/providers/cloudflare/client.py b/src/free_claude_code/providers/cloudflare/client.pyindex 616d8348..c7b6218c 100644--- a/src/free_claude_code/providers/cloudflare/client.py+++ b/src/free_claude_code/providers/cloudflare/client.py@@ -10,7 +10,6 @@ import httpxfrom free_claude_code.application.errors import ApplicationUnavailableErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import CLOUDFLARE_AI_REST_ROOT-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.inference import (InferenceEvent,InferenceStreamLedger,@@ -30,6 +29,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,+ ReasoningReplayMode,validate_extra_body_does_not_override_canonical_fields,)diff --git a/src/free_claude_code/providers/deepseek/client.py b/src/free_claude_code/providers/deepseek/client.pyindex 29a5a345..09e1f23e 100644--- a/src/free_claude_code/providers/deepseek/client.py+++ b/src/free_claude_code/providers/deepseek/client.py@@ -2,7 +2,7 @@from typing import Any-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -35,12 +35,14 @@ class DeepSeekProvider(OpenAIChatProvider):def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict:return build_deepseek_request_body(request,+ provider_model=provider_model,reasoning=reasoning,)diff --git a/src/free_claude_code/providers/deepseek/compat.py b/src/free_claude_code/providers/deepseek/compat.pyindex f62503ff..1f8ab1ff 100644--- a/src/free_claude_code/providers/deepseek/compat.py+++ b/src/free_claude_code/providers/deepseek/compat.py@@ -1,18 +1,19 @@-"""DeepSeek Anthropic-to-OpenAI chat request policy."""--from collections.abc import Mapping-from typing import Any+"""DeepSeek-owned OpenAI Chat compatibility policy."""from loguru import loggerfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS-from free_claude_code.core.anthropic import (- ReasoningReplayMode,- dump_messages_request,- serialize_tool_result_content,+from free_claude_code.core.inference import (+ DocumentContent,+ ImageContent,+ InferenceRequest,+ MessageItem,+ ReasoningItem,+ ToolCallItem,+ ToolChoiceMode,)-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,@@ -20,8 +21,13 @@ from free_claude_code.core.reasoning import ()from free_claude_code.providers.openai_chat import (OpenAIChatRequestPolicy,+ ReasoningReplayMode,build_openai_chat_request_body,)+from free_claude_code.providers.openai_compat import (+ OpenAIToolNameCodec,+ openai_replay_scope,+)DEEPSEEK_REQUEST_POLICY = OpenAIChatRequestPolicy(provider_name="DEEPSEEK",@@ -29,466 +35,109 @@ DEEPSEEK_REQUEST_POLICY = OpenAIChatRequestPolicy(include_extra_body=True,)-_UNSUPPORTED_MESSAGE_BLOCK_TYPES = frozenset(- {- "image",- "document",- "server_tool_use",- "web_search_tool_result",- "web_fetch_tool_result",- }-)-_STRIPPABLE_MESSAGE_BLOCK_TYPES = frozenset({"image", "document"})-_FORWARDABLE_ATTACHMENT_BLOCK_TYPES = frozenset({"image"})-_OMITTED_ATTACHMENT_TEXT = (- "[attachment omitted: DeepSeek does not support image or document inputs]"-)-_OMITTED_ATTACHMENT_BLOCK = {"type": "text", "text": _OMITTED_ATTACHMENT_TEXT}---def _is_vision_capable_model(model: str | None) -> bool:- """True when the DeepSeek model accepts OpenAI image parts.-- DeepSeek's vision models (e.g. ``deepseek-v4-flash-vision-exp``) support- image inputs natively. Document blocks are still stripped because the- shared OpenAI conversion path has no document parts.- """- if not model:- return False- return "vision" in str(model).rsplit("/", 1)[-1].lower()-def build_deepseek_request_body(- request_data: MessagesRequest, *, reasoning: ReasoningPolicy-) -> dict:- """Build a DeepSeek Chat Completions body from an Anthropic request."""- logger.debug(- "DEEPSEEK_REQUEST: chat build model={} msgs={}",- request_data.model,- len(request_data.messages),- )-- vision_capable = _is_vision_capable_model(request_data.model)- data = dump_messages_request(request_data)- if "messages" in data:- data["messages"] = _strip_unsupported_attachment_blocks(- 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+ request: InferenceRequest,+ *,+ provider_model: str,+ reasoning: ReasoningPolicy,+) -> JsonObject:+ """Build one DeepSeek request without rewriting canonical history."""++ _validate_media(request, provider_model=provider_model)effective_reasoning = reasoning- if reasoning.control is not ReasoningControl.OFF:- if unsafe_tool_followup:- logger.debug(- "DEEPSEEK_REQUEST: disabling thinking for tool follow-up without "- "replayable thinking model={} msgs={} tools={}",- data.get("model"),- len(data.get("messages", [])),- len(data.get("tools", [])),- )- _remove_deepseek_thinking_hints(data)- effective_reasoning = ReasoningPolicy.off()- elif has_tool_history:- logger.debug(- "DEEPSEEK_REQUEST: keeping thinking for tool follow-up with "- "replayable thinking model={} msgs={} tools={}",- data.get("model"),- len(data.get("messages", [])),- len(data.get("tools", [])),- )- elif data.get("tools") or data.get("tool_choice"):- logger.debug(- "DEEPSEEK_REQUEST: keeping thinking for initial tool request "- "model={} msgs={} tools={}",- data.get("model"),- len(data.get("messages", [])),- len(data.get("tools", [])),- )-- if "messages" in data:- data["messages"] = _normalize_tool_result_content(- sanitize_deepseek_messages_for_openai(data["messages"])+ if (+ reasoning.control is not ReasoningControl.OFF+ and _has_tool_history(request)+ and not _all_tool_calls_have_replayable_reasoning(request)+ ):+ logger.debug(+ "DEEPSEEK_REQUEST: disabling thinking for a tool follow-up without "+ "replayable reasoning model={} items={}",+ provider_model,+ len(request.items),)+ effective_reasoning = ReasoningPolicy.off()- sanitized_request = MessagesRequest.model_validate(data)body = build_openai_chat_request_body(- sanitized_request,+ request,+ provider_model=provider_model,reasoning=effective_reasoning,policy=DEEPSEEK_REQUEST_POLICY,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=openai_replay_scope(+ "DEEPSEEK",+ provider_model,+ replay_format="chat-completions",+ ),postprocessors=(_apply_deepseek_chat_extras,),)- if "max_tokens" not in body or body.get("max_tokens") is None:- body["max_tokens"] = ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS-- logger.debug(- "DEEPSEEK_REQUEST: build done model={} msgs={} tools={}",- body.get("model"),- len(body.get("messages", [])),- len(body.get("tools", [])),- )+ if (+ request.tool_choice is not None+ and request.tool_choice.mode is ToolChoiceMode.SPECIFIC+ ):+ logger.debug(+ "DEEPSEEK_REQUEST: downgrading unsupported specific tool choice to auto"+ )+ body["tool_choice"] = "auto"+ body.setdefault("max_tokens", ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS)return body-def sanitize_deepseek_messages_for_openai(messages: Any) -> Any:- """Keep only DeepSeek-required reasoning history on assistant tool calls."""- if not isinstance(messages, list):- return messages-- sanitized: list[Any] = []- for message in messages:- if not isinstance(message, dict):- sanitized.append(message)- continue- if message.get("role") != "assistant":- sanitized.append(message)+def _validate_media(request: InferenceRequest, *, provider_model: str) -> None:+ vision_capable = "vision" in provider_model.rsplit("/", 1)[-1].lower()+ for item in request.items:+ if not isinstance(item, MessageItem):continue- replay_tool_reasoning = _assistant_has_tool_use(message)- new_msg = dict(message)- if not replay_tool_reasoning:- new_msg.pop("reasoning_content", None)- content = message.get("content")- if not isinstance(content, list):- sanitized.append(new_msg)- continue-- filtered = [- block- for block in content- if not (- isinstance(block, dict)- and (- block.get("type") == "redacted_thinking"- or (block.get("type") == "thinking" and not replay_tool_reasoning)+ for content in item.content:+ if isinstance(content, DocumentContent):+ raise InvalidRequestError(+ "DeepSeek Chat does not support document content.")- )- ]- new_msg["content"] = filtered or ""- sanitized.append(new_msg)- return sanitized---def _strip_unsupported_attachment_blocks(- messages: Any, *, allow_attachments: bool = False-) -> Any:- if not isinstance(messages, list):- return messages-- stripped: list[Any] = []- top_level_dropped: dict[str, int] = {}- nested_dropped: dict[str, int] = {}- placeholder_replacements = 0-- for message in messages:- if not isinstance(message, dict):- stripped.append(message)- continue- content = message.get("content")- if not isinstance(content, list):- stripped.append(message)- continue-- new_content: list[Any] = []- message_dropped_attachment = False- for block in content:- if isinstance(block, dict):- btype = block.get("type")- if btype in _STRIPPABLE_MESSAGE_BLOCK_TYPES:- if (- allow_attachments- and btype in _FORWARDABLE_ATTACHMENT_BLOCK_TYPES- ):- new_content.append(block)- continue- top_level_dropped[btype] = top_level_dropped.get(btype, 0) + 1- message_dropped_attachment = True- continue- if btype == "tool_result":- inner = block.get("content")- if isinstance(inner, list):- filtered_inner: list[Any] = []- for sub in inner:- if (- isinstance(sub, dict)- and sub.get("type") in _STRIPPABLE_MESSAGE_BLOCK_TYPES- ):- sub_type = sub["type"]- if (- allow_attachments- and sub_type in _FORWARDABLE_ATTACHMENT_BLOCK_TYPES- ):- filtered_inner.append(sub)- continue- nested_dropped[sub_type] = (- nested_dropped.get(sub_type, 0) + 1- )- continue- filtered_inner.append(sub)- if not filtered_inner:- filtered_inner = [_OMITTED_ATTACHMENT_BLOCK]- placeholder_replacements += 1- new_block = dict(block)- new_block["content"] = filtered_inner- new_content.append(new_block)- continue- new_content.append(block)- if not new_content and message_dropped_attachment:- new_content = [_OMITTED_ATTACHMENT_BLOCK]- placeholder_replacements += 1- new_msg = dict(message)- new_msg["content"] = new_content- stripped.append(new_msg)-- if top_level_dropped or nested_dropped:- logger.warning(- "DEEPSEEK_REQUEST: stripped unsupported attachment blocks "- "(top_level={} nested_in_tool_result={} placeholder_tool_results={}). "- "DeepSeek has no vision/document support; the model will not see this content.",- dict(top_level_dropped),- dict(nested_dropped),- placeholder_replacements,- )- return stripped---def _is_server_listed_tool(tool: Mapping[str, Any]) -> bool:- name = (tool.get("name") or "").strip()- if name in ("web_search", "web_fetch"):- return True- typ = tool.get("type")- if isinstance(typ, str):- return typ.startswith("web_search") or typ.startswith("web_fetch")- return False---def _walk_block_list_for_unsupported(- blocks: Any, *, where: str, allow_attachments: bool = False-) -> None:- if not isinstance(blocks, list):- return- for block in blocks:- if not isinstance(block, dict):- continue- btype = block.get("type")- if btype in _UNSUPPORTED_MESSAGE_BLOCK_TYPES:- if allow_attachments and btype in _FORWARDABLE_ATTACHMENT_BLOCK_TYPES:- continue- raise InvalidRequestError(- f"DeepSeek native does not support {btype!r} blocks ({where})."- )- if btype == "tool_result" and "content" in block:- _walk_block_list_for_unsupported(- block["content"],- where=f"{where} (tool_result content)",- allow_attachments=allow_attachments,- )---def _validate_deepseek_request_dict(- data: dict[str, Any], *, allow_attachments: bool = False-) -> None:- mcp = data.get("mcp_servers")- if mcp:- raise InvalidRequestError("DeepSeek does not support mcp_servers on requests.")-- for tool in data.get("tools") or ():- if not isinstance(tool, dict):- continue- if _is_server_listed_tool(tool):- raise InvalidRequestError(- "DeepSeek does not support listed Anthropic server tools "- "(web_search / web_fetch). Remove them or use a different provider."- )-- for i, message in enumerate(data.get("messages") or ()):- if not isinstance(message, dict):- continue- content = message.get("content")- if isinstance(content, list):- _walk_block_list_for_unsupported(- content,- where=f"messages[{i}].content",- allow_attachments=allow_attachments,- )-- system = data.get("system")- if isinstance(system, list):- _walk_block_list_for_unsupported(- system, where="system", allow_attachments=allow_attachments- )---def _has_tool_history_blocks(message: Mapping[str, Any]) -> bool:- role = message.get("role")- content = message.get("content")- if not isinstance(content, list):- return False-- for block in content:- if not isinstance(block, dict):- continue- btype = block.get("type")- if role == "assistant" and btype == "tool_use":- return True- if role == "user" and btype == "tool_result":- return True- return False---def _has_replayable_thinking_before_tool_use(message: Mapping[str, Any]) -> bool:- if message.get("role") != "assistant":- return False- content = message.get("content")- if not isinstance(content, list):- return False-- has_thinking = isinstance(message.get("reasoning_content"), str)- for block in content:- if not isinstance(block, dict):- continue- btype = block.get("type")- if btype == "thinking" and isinstance(block.get("thinking"), str):- has_thinking = True- continue- if btype == "tool_use":- return has_thinking- return False---def _assistant_has_tool_use(message: Mapping[str, Any]) -> bool:- if message.get("role") != "assistant":- return False- content = message.get("content")- return isinstance(content, list) and any(- isinstance(block, dict) and block.get("type") == "tool_use" for block in content- )---def _has_tool_history(data: dict[str, Any]) -> bool:- for message in data.get("messages") or ():- if isinstance(message, Mapping) and _has_tool_history_blocks(message):- return True- return False---def _all_tool_calls_have_replayable_thinking(data: dict[str, Any]) -> bool:- found_tool_call = False- for message in data.get("messages") or ():- if not isinstance(message, Mapping) or not _assistant_has_tool_use(message):- continue- found_tool_call = True- if not _has_replayable_thinking_before_tool_use(message):- return False- return found_tool_call---def _remove_deepseek_thinking_hints(data: dict[str, Any]) -> None:- output_config = data.get("output_config")- if isinstance(output_config, dict) and "effort" in output_config:- cleaned_output_config = dict(output_config)- cleaned_output_config.pop("effort", None)- if cleaned_output_config:- data["output_config"] = cleaned_output_config- else:- data.pop("output_config", None)-- context_management = data.get("context_management")- if not isinstance(context_management, dict):- return- edits = context_management.get("edits")- if not isinstance(edits, list):- return- filtered_edits = [- edit- for edit in edits- if not (- isinstance(edit, dict)- and isinstance(edit.get("type"), str)- and edit["type"].startswith("clear_thinking_")- )- ]- if len(filtered_edits) == len(edits):- return- cleaned_context_management = dict(context_management)- if filtered_edits:- cleaned_context_management["edits"] = filtered_edits- data["context_management"] = cleaned_context_management- else:- cleaned_context_management.pop("edits", None)- if cleaned_context_management:- data["context_management"] = cleaned_context_management- else:- data.pop("context_management", None)---def _normalize_tool_result_content(messages: Any) -> Any:- if not isinstance(messages, list):- return messages-- normalized: list[Any] = []- for message in messages:- if not isinstance(message, dict):- normalized.append(message)- continue-- content = message.get("content")- if not isinstance(content, list):- normalized.append(message)- continue-- new_content: list[Any] = []- for block in content:- if not isinstance(block, dict):- new_content.append(block)- continue-- if block.get("type") == "tool_result":- normalized_block = dict(block)- normalized_block["content"] = serialize_tool_result_content(- block.get("content")+ if isinstance(content, ImageContent) and not vision_capable:+ raise InvalidRequestError(+ "The selected DeepSeek model does not support image content.")- new_content.append(normalized_block)- else:- new_content.append(block)- new_msg = dict(message)- new_msg["content"] = new_content- normalized.append(new_msg)- return normalized+def _has_tool_history(request: InferenceRequest) -> bool:+ return any(isinstance(item, ToolCallItem) for item in request.items)-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 _all_tool_calls_have_replayable_reasoning(request: InferenceRequest) -> bool:+ reasoning_turns = {+ item.turn_id for item in request.items if isinstance(item, ReasoningItem)+ }+ tool_turns = {+ item.turn_id for item in request.items if isinstance(item, ToolCallItem)+ }+ return bool(tool_turns) and tool_turns <= reasoning_turnsdef _apply_deepseek_chat_extras(- body: dict[str, Any], _request_data: MessagesRequest, policy: ReasoningPolicy+ body: JsonObject,+ _request: InferenceRequest,+ policy: ReasoningPolicy,) -> None:- extra_body = body.setdefault("extra_body", {})- if not isinstance(extra_body, dict):- return+ messages = body.get("messages")+ if isinstance(messages, list):+ for message in messages:+ if (+ isinstance(message, dict)+ and message.get("role") == "assistant"+ and not message.get("tool_calls")+ ):+ message.pop("reasoning_content", None)++ raw_extra = body.setdefault("extra_body", {})+ if not isinstance(raw_extra, dict):+ raise InvalidRequestError("DeepSeek extra_body must be an object.")if policy.control is ReasoningControl.OFF:- extra_body["thinking"] = {"type": "disabled"}+ raw_extra["thinking"] = {"type": "disabled"}returnif policy.effort in {ReasoningEffort.XHIGH, ReasoningEffort.MAX}:body["reasoning_effort"] = "max"elif policy.effort is not None:body["reasoning_effort"] = "high"elif policy.requests_reasoning:- extra_body["thinking"] = {"type": "enabled"}+ raw_extra["thinking"] = {"type": "enabled"}diff --git a/src/free_claude_code/providers/gemini/client.py b/src/free_claude_code/providers/gemini/client.pyindex 1dee808d..0e426292 100644--- a/src/free_claude_code/providers/gemini/client.py+++ b/src/free_claude_code/providers/gemini/client.py@@ -1,6 +1,5 @@"""Google AI Studio Gemini provider (OpenAI-compatible chat completions)."""-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfigfrom free_claude_code.providers.google_openai import (@@ -11,6 +10,7 @@ from free_claude_code.providers.google_openai import (from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatRequestPolicy,+ ReasoningReplayMode,)_REQUEST_POLICY = OpenAIChatRequestPolicy(diff --git a/src/free_claude_code/providers/github_models/client.py b/src/free_claude_code/providers/github_models/client.pyindex 639d3fd9..c10724a1 100644--- a/src/free_claude_code/providers/github_models/client.py+++ b/src/free_claude_code/providers/github_models/client.py@@ -6,7 +6,6 @@ from typing import Anyimport httpxfrom free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.providers.admission import (ProviderAdmissionController,ProviderOperationKind,@@ -22,6 +21,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,+ ReasoningReplayMode,)GITHUB_MODELS_CATALOG_URL = "https://models.github.ai/catalog/models"diff --git a/src/free_claude_code/providers/google_openai/provider.py b/src/free_claude_code/providers/google_openai/provider.pyindex 09a71fe8..661370d7 100644--- a/src/free_claude_code/providers/google_openai/provider.py+++ b/src/free_claude_code/providers/google_openai/provider.py@@ -4,7 +4,7 @@ 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.inference import InferenceRequestfrom free_claude_code.core.reasoning import (DEFAULT_REASONING_POLICY,ReasoningPolicy,@@ -17,6 +17,10 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProvider,build_openai_chat_request_body,)+from free_claude_code.providers.openai_compat import (+ OpenAIToolNameCodec,+ openai_replay_scope,+)from .thought_signatures import apply_google_thought_signatures@@ -59,14 +63,22 @@ class GoogleOpenAIProvider(OpenAIChatProvider):def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict[str, Any]:return build_openai_chat_request_body(request,+ provider_model=provider_model,reasoning=reasoning,policy=self._profile.request_policy,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=openai_replay_scope(+ self._provider_name,+ provider_model,+ replay_format="chat-completions",+ ),postprocessors=(lambda body, _request_data, _policy: apply_google_thought_signatures(body,diff --git a/src/free_claude_code/providers/groq/client.py b/src/free_claude_code/providers/groq/client.pyindex 83aa9973..319f0e46 100644--- a/src/free_claude_code/providers/groq/client.py+++ b/src/free_claude_code/providers/groq/client.py@@ -9,8 +9,7 @@ from typing import Anyimport openaifrom loguru import logger-from free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import (DEFAULT_REASONING_POLICY,ReasoningEffort,@@ -23,6 +22,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,+ ReasoningReplayMode,validate_extra_body_does_not_override_reasoning_fields,)@@ -99,11 +99,16 @@ class GroqProvider(OpenAIChatProvider):def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict[str, Any]:- body = super()._build_request_body(request, reasoning=reasoning)+ body = super()._build_request_body(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ )model = body.get("model")if not isinstance(model, str):return bodydiff --git a/src/free_claude_code/providers/kilo/client.py b/src/free_claude_code/providers/kilo/client.pyindex 86a9ccbc..3eacb5f2 100644--- a/src/free_claude_code/providers/kilo/client.py+++ b/src/free_claude_code/providers/kilo/client.py@@ -1,7 +1,6 @@"""Kilo.ai provider implementation."""from free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.reasoning import ReasoningEffortfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -10,7 +9,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProvider,OpenAIChatRequestPolicy,ReasoningObject,- apply_reasoning_details_replay,+ ReasoningReplayMode,validate_extra_body_does_not_override_canonical_fields,)@@ -24,7 +23,6 @@ _PROFILE = OpenAIChatProfile(extra_body_validator=validate_extra_body_does_not_override_canonical_fields,),ReasoningObject(tuple((effort, effort.value) for effort in ReasoningEffort)),- postprocessors=(apply_reasoning_details_replay,),reasoning_delta_field="reasoning",structured_reasoning_details=True,)diff --git a/src/free_claude_code/providers/lmstudio/client.py b/src/free_claude_code/providers/lmstudio/client.pyindex c2e83fda..4a2c5f2f 100644--- a/src/free_claude_code/providers/lmstudio/client.py+++ b/src/free_claude_code/providers/lmstudio/client.py@@ -16,8 +16,7 @@ import timeimport httpxfrom loguru import logger-from free_claude_code.core.anthropic import ReasoningReplayMode, get_token_count-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequest, get_inference_token_countfrom free_claude_code.core.reasoning import (DEFAULT_REASONING_POLICY,ReasoningEffort,@@ -33,6 +32,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,+ ReasoningReplayMode,)_PROFILE = OpenAIChatProfile(@@ -78,22 +78,23 @@ class LMStudioProvider(OpenAIChatProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:- super().preflight_stream(request, reasoning=reasoning)+ super().preflight_stream(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ )self._preflight_context_budget(request)- def _preflight_context_budget(self, request: MessagesRequest) -> None:+ def _preflight_context_budget(self, request: InferenceRequest) -> None:loaded_context = self._loaded_context_length()if loaded_context is None:return- estimate = get_token_count(- request.messages,- request.system,- request.tools,- )+ estimate = get_inference_token_count(request)# 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..7790ca93 100644--- a/src/free_claude_code/providers/mistral/client.py+++ b/src/free_claude_code/providers/mistral/client.py@@ -5,8 +5,7 @@ from typing import Anyfrom loguru import logger-from free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -15,7 +14,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,- build_openai_chat_request_body,+ ReasoningReplayMode,)from .reasoning import (@@ -46,14 +45,15 @@ class MistralProvider(OpenAIChatProvider):def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict:- body = build_openai_chat_request_body(+ body = super()._build_request_body(request,+ provider_model=provider_model,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..51f3c596 100644--- a/src/free_claude_code/providers/nvidia_nim/client.py+++ b/src/free_claude_code/providers/nvidia_nim/client.py@@ -9,8 +9,8 @@ import openaifrom loguru import loggerfrom free_claude_code.config.nim import NimSettings-from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -66,14 +66,16 @@ class NvidiaNimProvider(OpenAIChatProvider):def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict:"""Internal helper for tests and shared building."""return build_nim_request_body(request,self._nim_settings,+ provider_model=provider_model,reasoning=reasoning,)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..c3d2ac65 100644--- a/src/free_claude_code/providers/nvidia_nim/request_options.py+++ b/src/free_claude_code/providers/nvidia_nim/request_options.py@@ -1,33 +1,48 @@"""NVIDIA NIM request option injection."""-from copy import deepcopyfrom typing import Anyfrom free_claude_code.config.nim import NimSettings-from free_claude_code.core.anthropic import ReasoningReplayMode, set_if_not_none-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequest, thaw_json_objectfrom free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicyfrom free_claude_code.providers.openai_chat import (OpenAIChatRequestPolicy,+ ReasoningReplayMode,build_openai_chat_request_body,)+from free_claude_code.providers.openai_compat import (+ OpenAIToolNameCodec,+ openai_replay_scope,+)from .tool_schema import sanitize_nim_tool_schemasNIM_REQUEST_POLICY = OpenAIChatRequestPolicy(provider_name="NIM",reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,+ postprocessor_consumes_extra_body=True,)def build_nim_request_body(- request_data: MessagesRequest, nim: NimSettings, *, reasoning: ReasoningPolicy+ request_data: InferenceRequest,+ nim: NimSettings,+ *,+ provider_model: str,+ reasoning: ReasoningPolicy,) -> dict[str, Any]:- """Build OpenAI-format request body from Anthropic request plus NIM settings."""+ """Build an OpenAI-format body from canonical input plus NIM settings."""return build_openai_chat_request_body(request_data,+ provider_model=provider_model,reasoning=reasoning,policy=NIM_REQUEST_POLICY,+ tool_names=OpenAIToolNameCodec.from_request(request_data),+ replay_scope=openai_replay_scope(+ "NIM",+ provider_model,+ replay_format="chat-completions",+ ),postprocessors=(lambda body, request, policy: apply_nim_request_options(body,@@ -41,7 +56,7 @@ def build_nim_request_body(def apply_nim_request_options(body: dict[str, Any],- request_data: MessagesRequest,+ request_data: InferenceRequest,reasoning: ReasoningPolicy,*,nim: NimSettings,@@ -49,12 +64,13 @@ def apply_nim_request_options("""Apply NIM schema repairs and configured request defaults."""sanitize_nim_tool_schemas(body)- max_tokens = body.get("max_tokens") or request_data.max_tokens+ max_tokens = body.get("max_tokens") or request_data.max_output_tokensif max_tokens is None:max_tokens = nim.max_tokenselif nim.max_tokens:max_tokens = min(max_tokens, nim.max_tokens)- set_if_not_none(body, "max_tokens", max_tokens)+ if max_tokens is not None:+ body["max_tokens"] = max_tokensif body.get("temperature") is None and nim.temperature is not None:body["temperature"] = nim.temperature@@ -73,9 +89,9 @@ def apply_nim_request_options(body["parallel_tool_calls"] = nim.parallel_tool_callsextra_body: dict[str, Any] = {}- request_extra = request_data.extra_body- if request_extra:- extra_body.update(deepcopy(request_extra))+ extension = request_data.openai_chat_extension+ if extension is not None:+ extra_body.update(thaw_json_object(extension.extra_body))for key in ("reasoning","reasoning_budget",diff --git a/src/free_claude_code/providers/open_router/client.py b/src/free_claude_code/providers/open_router/client.pyindex 7410f4cb..60d98042 100644--- a/src/free_claude_code/providers/open_router/client.py+++ b/src/free_claude_code/providers/open_router/client.py@@ -2,7 +2,6 @@from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.reasoning import ReasoningEffortfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -12,7 +11,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProvider,OpenAIChatRequestPolicy,ReasoningObject,- apply_reasoning_details_replay,+ ReasoningReplayMode,validate_extra_body_does_not_override_canonical_fields,)@@ -48,6 +47,5 @@ class OpenRouterProvider(OpenAIChatProvider):_PROFILE = OpenAIChatProfile(_REQUEST_POLICY,ReasoningObject(tuple((effort, effort.value) for effort in ReasoningEffort)),- postprocessors=(apply_reasoning_details_replay,),structured_reasoning_details=True,)diff --git a/src/free_claude_code/providers/openai_chat/__init__.py b/src/free_claude_code/providers/openai_chat/__init__.pyindex fcf8b146..6cd2f6ef 100644--- a/src/free_claude_code/providers/openai_chat/__init__.py+++ b/src/free_claude_code/providers/openai_chat/__init__.py@@ -16,7 +16,7 @@ from .reasoning import (NamedEffortReasoning,ReasoningObject,)-from .reasoning_details import apply_reasoning_details_replay+from .request_codec import ReasoningReplayModefrom .request_policy import OpenAIChatRequestPolicy, build_openai_chat_request_bodyfrom .usage import usage_int@@ -50,7 +50,7 @@ __all__ = ["OpenAIChatProvider","OpenAIChatRequestPolicy","ReasoningObject",- "apply_reasoning_details_replay",+ "ReasoningReplayMode","build_openai_chat_request_body","create_openai_chat_provider","openai_v1_base_url",diff --git a/src/free_claude_code/providers/openai_chat/function_tags.py b/src/free_claude_code/providers/openai_chat/function_tags.pynew file mode 100644index 00000000..dfa32ff1--- /dev/null+++ b/src/free_claude_code/providers/openai_chat/function_tags.py@@ -0,0 +1,261 @@+"""Parse exact OpenAI-compatible function-tag tool envelopes."""++import uuid+from collections.abc import Mapping+from dataclasses import dataclass+from enum import Enum+from typing import cast++from free_claude_code.core.anthropic.tool_schema import (+ arguments_match_schema,+ coerce_text_argument,+)+from free_claude_code.core.inference import (+ FunctionTool,+ InferenceRequest,+ ToolChoiceMode,+ thaw_json_object,+)+from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec++_FUNCTION_TAG_BLOCK_START = "<tool_call>"+_FUNCTION_TAG_BLOCK_END = "</tool_call>"+_FUNCTION_TAG_START = "<function="+_FUNCTION_TAG_END = "</function>"+_PARAMETER_TAG_START = "<parameter="+_PARAMETER_TAG_END = "</parameter>"+_MAX_FUNCTION_TAG_CANDIDATE_CHARS = 4 * 1024 * 1024+++@dataclass(frozen=True, slots=True)+class _RawFunctionTagCall:+ name: str+ arguments: dict[str, str]+++class _FunctionTagState(Enum):+ SEARCHING = 1+ CANDIDATE = 2+ DISABLED = 3+ FINISHED = 4+++class FunctionTagToolParser:+ """Parse an exact terminal function-tag envelope into tool use."""++ def __init__(self, request: InferenceRequest):+ self._tool_names = OpenAIToolNameCodec.from_request(request)+ self._schemas = {+ tool.name: thaw_json_object(tool.input_schema)+ for tool in request.tools+ if isinstance(tool, FunctionTool)+ }+ tool_choice_disabled = (+ request.tool_choice is not None+ and request.tool_choice.mode is ToolChoiceMode.NONE+ )+ self._state = (+ _FunctionTagState.SEARCHING+ if self._schemas and not tool_choice_disabled+ else _FunctionTagState.DISABLED+ )+ self._parts: list[str] = []+ self._length = 0+ self._marker_tail = ""++ def feed(self, text: str) -> str:+ """Hold a possible reserved response and return text safe to expose."""+ if not text:+ return ""+ if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:+ return text++ if self._state is _FunctionTagState.CANDIDATE:+ self._parts.append(text)+ self._length += len(text)+ if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:+ return self.disable()+ return ""++ candidate = "".join((self._marker_tail, text))+ marker_index = candidate.find(_FUNCTION_TAG_BLOCK_START)+ if marker_index >= 0:+ visible = candidate[:marker_index]+ control = candidate[marker_index:]+ self._state = _FunctionTagState.CANDIDATE+ self._marker_tail = ""+ self._parts.append(control)+ self._length = len(control)+ if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:+ return "".join((visible, self.disable()))+ return visible++ held_length = _partial_function_tag_marker_suffix_length(candidate)+ if held_length:+ self._marker_tail = candidate[-held_length:]+ return candidate[:-held_length]+ self._marker_tail = ""+ return candidate++ def disable(self) -> str:+ """Disable textual recovery and release any held candidate unchanged."""+ if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:+ return ""+ self._state = _FunctionTagState.DISABLED+ text = "".join((self._marker_tail, *self._parts))+ self._marker_tail = ""+ self._parts.clear()+ self._length = 0+ return text++ def finish(self) -> tuple[str, tuple[JsonObject, ...]]:+ """Finalize one response atomically as visible text or validated tools."""+ if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:+ return "", ()+ if self._state is _FunctionTagState.SEARCHING:+ self._state = _FunctionTagState.FINISHED+ text = self._marker_tail+ self._marker_tail = ""+ return text, ()+ self._state = _FunctionTagState.FINISHED+ raw = "".join(self._parts)+ self._parts.clear()+ self._length = 0+ try:+ calls = _parse_function_tag_calls(raw)+ tool_uses = self._validated_tool_uses(calls)+ except ValueError:+ return raw, ()+ return "", tool_uses++ def _validated_tool_uses(+ self, calls: tuple[_RawFunctionTagCall, ...]+ ) -> tuple[JsonObject, ...]:+ tool_uses: list[JsonObject] = []+ for call in calls:+ name = self._tool_names.decode(call.name)+ schema = self._schemas.get(name)+ if schema is None:+ raise ValueError+ properties = schema.get("properties")+ property_schemas = properties if isinstance(properties, Mapping) else {}+ additional = schema.get("additionalProperties")+ arguments: JsonObject = {}+ for parameter_name, value in call.arguments.items():+ parameter_schema = property_schemas.get(parameter_name)+ if not isinstance(parameter_schema, Mapping):+ parameter_schema = (+ additional if isinstance(additional, Mapping) else {}+ )+ arguments[parameter_name] = cast(+ JsonValue,+ coerce_text_argument(value, parameter_schema),+ )+ if not arguments_match_schema(arguments, schema):+ raise ValueError+ tool_use: JsonObject = {+ "type": "tool_use",+ "id": f"toolu_function_tag_{uuid.uuid4().hex[:8]}",+ "name": name,+ "input": arguments,+ }+ tool_uses.append(tool_use)+ return tuple(tool_uses)+++def _parse_function_tag_calls(text: str) -> tuple[_RawFunctionTagCall, ...]:+ cursor = 0+ calls: list[_RawFunctionTagCall] = []+ while True:+ cursor = _skip_function_tag_whitespace(text, cursor)+ if cursor == len(text):+ break+ if not text.startswith(_FUNCTION_TAG_BLOCK_START, cursor):+ raise ValueError++ block_start = cursor + len(_FUNCTION_TAG_BLOCK_START)+ block_end = text.find(_FUNCTION_TAG_BLOCK_END, block_start)+ if block_end < 0:+ raise ValueError+ name, arguments = _parse_function_tag_block(text[block_start:block_end])+ calls.append(_RawFunctionTagCall(name=name, arguments=arguments))+ cursor = block_end + len(_FUNCTION_TAG_BLOCK_END)++ if not calls:+ raise ValueError+ return tuple(calls)+++def _parse_function_tag_block(block: str) -> tuple[str, dict[str, str]]:+ cursor = _skip_function_tag_whitespace(block, 0)+ if not block.startswith(_FUNCTION_TAG_START, cursor):+ raise ValueError+ name_end = block.find(">", cursor + len(_FUNCTION_TAG_START))+ if name_end < 0:+ raise ValueError+ name = block[cursor + len(_FUNCTION_TAG_START) : name_end]+ if not _valid_function_tag_name(name):+ raise ValueError++ arguments: dict[str, str] = {}+ cursor = name_end + 1+ while True:+ cursor = _skip_function_tag_whitespace(block, cursor)+ if block.startswith(_FUNCTION_TAG_END, cursor):+ cursor += len(_FUNCTION_TAG_END)+ break+ if cursor == len(block) or not block.startswith(_PARAMETER_TAG_START, cursor):+ raise ValueError++ parameter_name_end = block.find(">", cursor + len(_PARAMETER_TAG_START))+ if parameter_name_end < 0:+ raise ValueError+ parameter_name = block[cursor + len(_PARAMETER_TAG_START) : parameter_name_end]+ if not _valid_function_tag_name(parameter_name) or parameter_name in arguments:+ raise ValueError++ value_start = parameter_name_end + 1+ value_end = block.find(_PARAMETER_TAG_END, value_start)+ if value_end < 0:+ raise ValueError+ arguments[parameter_name] = _unwrap_function_tag_newlines(+ block[value_start:value_end]+ )+ cursor = value_end + len(_PARAMETER_TAG_END)++ if block[cursor:].strip():+ raise ValueError+ return name, arguments+++def _skip_function_tag_whitespace(text: str, cursor: int) -> int:+ while cursor < len(text) and text[cursor].isspace():+ cursor += 1+ return cursor+++def _valid_function_tag_name(value: str) -> bool:+ return bool(value) and not any(+ character.isspace() or character in "<>" for character in value+ )+++def _unwrap_function_tag_newlines(value: str) -> str:+ if value.startswith("\r\n"):+ value = value[2:]+ elif value.startswith("\n"):+ value = value[1:]+ if value.endswith("\r\n"):+ return value[:-2]+ if value.endswith("\n"):+ return value[:-1]+ return value+++def _partial_function_tag_marker_suffix_length(text: str) -> int:+ max_length = min(len(text), len(_FUNCTION_TAG_BLOCK_START) - 1)+ for length in range(max_length, 0, -1):+ if _FUNCTION_TAG_BLOCK_START.startswith(text[-length:]):+ return length+ return 0diff --git a/src/free_claude_code/providers/openai_chat/profiles.py b/src/free_claude_code/providers/openai_chat/profiles.pyindex d40aa51a..ff0e7187 100644--- a/src/free_claude_code/providers/openai_chat/profiles.py+++ b/src/free_claude_code/providers/openai_chat/profiles.py@@ -1,14 +1,13 @@"""Declarative profiles for ordinary OpenAI-compatible providers."""-from collections.abc import Mappingfrom copy import deepcopyfrom dataclasses import dataclassfrom typing import Any, Literalfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS-from free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequest, thaw_json_object+from free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.model_listing import RequiredPathValues@@ -27,7 +26,7 @@ from .reasoning import (ReasoningObject,ThinkingObjectReasoning,)-from .reasoning_details import apply_reasoning_details_replay+from .request_codec import ReasoningReplayModefrom .request_policy import OpenAIChatPostprocessor, OpenAIChatRequestPolicy_ALL_EFFORTS = tuple((effort, effort.value) for effort in ReasoningEffort)@@ -137,8 +136,8 @@ class OpenAIChatProfile:def apply_reasoning(self,- body: dict[str, Any],- _request: MessagesRequest,+ body: JsonObject,+ _request: InferenceRequest,policy: ReasoningPolicy,) -> None:self.reasoning.encode(body, policy)@@ -149,9 +148,13 @@ class OpenAIChatProfile:def _apply_cohere_request_quirks(- body: dict[str, Any], request: MessagesRequest, _policy: ReasoningPolicy+ body: JsonObject, request: InferenceRequest, _policy: ReasoningPolicy) -> None:- _merge_allowed_cohere_extra_body(body, request.extra_body)+ extension = request.openai_chat_extension+ _merge_allowed_cohere_extra_body(+ body,+ thaw_json_object(extension.extra_body) if extension is not None else None,+ )_COHERE_EXTRA_BODY_KEYS = frozenset(@@ -164,11 +167,11 @@ _COHERE_EXTRA_BODY_KEYS = frozenset()-def _merge_allowed_cohere_extra_body(body: dict[str, Any], extra_body: Any) -> None:+def _merge_allowed_cohere_extra_body(+ body: JsonObject, extra_body: JsonObject | None+) -> None:if extra_body in (None, {}):return- if not isinstance(extra_body, Mapping):- raise InvalidRequestError("Cohere extra_body must be an object when provided.")unsupported = sorted(str(key) for key in extra_body if key not in _COHERE_EXTRA_BODY_KEYS@@ -215,7 +218,6 @@ OPENAI_CHAT_PROFILES: dict[str, OpenAIChatProfile] = {"cline_pass": OpenAIChatProfile(_policy("CLINE_PASS", ReasoningReplayMode.DISABLED),NO_REASONING,- postprocessors=(apply_reasoning_details_replay,),model_listing=OpenAIModelListing(path="/ai/cline/recommended-models",collection_field="clinePass",@@ -383,7 +385,6 @@ OPENAI_CHAT_PROFILES: dict[str, OpenAIChatProfile] = {max_tokens_field="max_completion_tokens",),ReasoningObject(_MINIMAL_TO_XHIGH),- postprocessors=(apply_reasoning_details_replay,),model_listing=OpenAIModelListing(required_sequence_items=(("input_modalities", "text"),@@ -451,6 +452,7 @@ OPENAI_CHAT_PROFILES: dict[str, OpenAIChatProfile] = {_policy("COHERE",ReasoningReplayMode.REASONING_CONTENT,+ postprocessor_consumes_extra_body=True,strip_message_names=True,unsupported_body_keys=frozenset({diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.pyindex c4837be3..a03737b4 100644--- a/src/free_claude_code/providers/openai_chat/provider.py+++ b/src/free_claude_code/providers/openai_chat/provider.py@@ -15,27 +15,17 @@ from openai import AsyncOpenAI, DefaultAsyncHttpx2Clientfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import (ContentType,- FunctionTagToolParser,HeuristicToolParser,- OpenAIToolNameCodec,ThinkTagParser,)-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.streaming import (- accept_tool_json_repair,- continuation_suffix,- make_response_recovery_body,- make_text_recovery_body,- make_tool_repair_body,- parse_complete_tool_input,- tool_schemas_by_name,-)from free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.core.inference import (FinishReason,InferenceEvent,+ InferenceRequest,InferenceStreamLedger,InferenceUsage,+ ReplayCompatibilityScope,TokenMeasurement,UsageSource,)@@ -66,6 +56,20 @@ from free_claude_code.providers.model_listing import (model_infos_from_ids,validate_model_list_page,)+from free_claude_code.providers.openai_chat.function_tags import FunctionTagToolParser+from free_claude_code.providers.openai_chat.recovery import (+ accept_tool_json_repair,+ continuation_suffix,+ make_response_recovery_body,+ make_text_recovery_body,+ make_tool_repair_body,+ parse_complete_tool_input,+ tool_schemas_by_name,+)+from free_claude_code.providers.openai_compat import (+ OpenAIToolNameCodec,+ openai_replay_scope,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -241,7 +245,7 @@ class _OpenAIChatStreamAssembler:def __init__(self,*,- request: MessagesRequest,+ request: InferenceRequest,ledger: InferenceStreamLedger,profile: OpenAIChatProfile,provider_name: str,@@ -249,6 +253,7 @@ class _OpenAIChatStreamAssembler:tool_names: OpenAIToolNameCodec,tool_calls: OpenAIToolCallAssembler,extra_reasoning_events: _ExtraReasoningEvents,+ replay_scope: ReplayCompatibilityScope,) -> None:self._request = requestself._ledger = ledger@@ -262,7 +267,7 @@ class _OpenAIChatStreamAssembler:self._function_tag_parser = FunctionTagToolParser(request)self._heuristic_parser = HeuristicToolParser()self._structured_reasoning = (- StructuredReasoningStream()+ StructuredReasoningStream(replay_scope)if profile.structured_reasoning_detailselse None)@@ -474,6 +479,7 @@ class _OpenAIChatStreamAssembler:yield from self._tool_calls.flush_tool_argument_alias_buffers(self._ledger,+ self._tool_names,self._tool_argument_aliases,self._tool_argument_alias_buffers,)@@ -664,26 +670,39 @@ class OpenAIChatProvider(BaseProvider):def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict[str, Any]:"""Build a provider request from the immutable profile."""return build_openai_chat_request_body(request,+ provider_model=provider_model,reasoning=reasoning,policy=self._profile.request_policy,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=openai_replay_scope(+ self._provider_name,+ provider_model,+ replay_format="chat-completions",+ ),postprocessors=self._profile.request_postprocessors,)def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:"""Validate OpenAI-chat request conversion before streaming."""- self._build_request_body(request, reasoning=reasoning)+ self._build_request_body(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ )def _handle_extra_reasoning(self, delta: Any, ledger: InferenceStreamLedger, *, output_reasoning: bool@@ -836,9 +855,10 @@ class OpenAIChatProvider(BaseProvider):def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,@@ -847,9 +867,10 @@ class OpenAIChatProvider(BaseProvider):runner = _OpenAIChatStreamRunner(self,request=request,+ provider_model=provider_model,input_tokens=input_tokens,request_id=request_id,- response_model=response_model,+ response_model=response_model or request.model,reasoning=reasoning,)return runner.run()@@ -862,24 +883,30 @@ class _OpenAIChatStreamRunner:self,provider: OpenAIChatProvider,*,- request: MessagesRequest,+ request: InferenceRequest,+ provider_model: str,input_tokens: int,request_id: str | None,- response_model: str | None,+ response_model: str,reasoning: ReasoningPolicy,) -> None:self._provider = providerself._request = request+ self._provider_model = provider_modelself._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 = reasoningself._tool_names = OpenAIToolNameCodec.from_request(request)+ self._replay_scope = openai_replay_scope(+ provider._provider_name,+ provider_model,+ replay_format="chat-completions",+ )self._response_id = f"response_{uuid.uuid4().hex}"self._tool_calls = OpenAIToolCallAssembler(- record_extra_content=provider._record_tool_call_extra_content+ record_extra_content=provider._record_tool_call_extra_content,+ replay_scope=self._replay_scope,)async def run(self) -> AsyncIterator[InferenceEvent]:@@ -916,6 +943,7 @@ class _OpenAIChatStreamRunner:body = self._provider._build_request_body(self._request,+ provider_model=self._provider_model,reasoning=self._reasoning,)request_stream_usage(body)@@ -1334,7 +1362,13 @@ class _OpenAIChatStreamRunner:if recovered.tool_calls:events.extend(ledger.close_content_blocks())for tool_call in recovered.tool_calls:- events.extend(self._tool_calls.process_tool_call(tool_call, ledger))+ events.extend(+ self._tool_calls.process_tool_call(+ tool_call,+ ledger,+ tool_names=self._tool_names,+ )+ )if not events:return Noneevents.extend(ledger.close_all_blocks())@@ -1370,8 +1404,8 @@ class _OpenAIChatStreamRunner:block = ledger.tool_block_for_tool_index(tool_index)emitted_prefix = block.content if block is not None else ""repair_prefix = emitted_prefix- if not repair_prefix and state.name == "Task" and state.task_arg_buffer:- repair_prefix = state.task_arg_buffer+ if not repair_prefix and state.name == "Task":+ repair_prefix = self._tool_calls.buffered_task_args(tool_index)if not repair_prefix and tool_index in tool_argument_alias_buffers:repair_prefix = tool_argument_alias_buffers[tool_index]if (@@ -1452,4 +1486,5 @@ class _OpenAIChatStreamRunner:tool_names=self._tool_names,tool_calls=self._tool_calls,extra_reasoning_events=extra_reasoning_events,+ replay_scope=self._replay_scope,)diff --git a/src/free_claude_code/providers/openai_chat/reasoning_details.py b/src/free_claude_code/providers/openai_chat/reasoning_details.pyindex 2e2e5635..fffeffe6 100644--- a/src/free_claude_code/providers/openai_chat/reasoning_details.py+++ b/src/free_claude_code/providers/openai_chat/reasoning_details.py@@ -4,10 +4,6 @@ import jsonfrom collections.abc import Iterator, Mapping, Sequencefrom typing import Any, Literal-from free_claude_code.core.anthropic import (- is_synthetic_openai_tool_turn_boundary,-)-from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.inference import (InferenceEvent,InferenceStreamLedger,@@ -15,45 +11,16 @@ from free_claude_code.core.inference import (ReplayArtifactKind,ReplayArtifactOrigin,ReplayAttachment,+ ReplayCompatibilityScope,)-from free_claude_code.core.reasoning import ReasoningPolicy---def apply_reasoning_details_replay(- body: dict[str, Any], request: MessagesRequest, _policy: ReasoningPolicy-) -> None:- """Replay opaque reasoning details on their converted assistant messages."""- assistant_details = _assistant_reasoning_details(request.messages)- if not assistant_details:- return- messages = body.get("messages")- if not isinstance(messages, list):- return-- cursor = 0- for details in assistant_details:- for index in range(cursor, len(messages)):- message = messages[index]- if (- not isinstance(message, dict)- or message.get("role") != "assistant"- or is_synthetic_openai_tool_turn_boundary(message)- ):- continue- existing = message.get("reasoning_details")- if isinstance(existing, list):- existing.extend(details)- else:- message["reasoning_details"] = list(details)- cursor = index + 1- breakclass StructuredReasoningStream:"""Reconcile alternate plaintext reasoning representations for one stream."""- def __init__(self) -> None:+ def __init__(self, replay_scope: ReplayCompatibilityScope) -> None:self._text_source: Literal["native", "details"] | None = None+ self._replay_scope = replay_scopedef events(self,@@ -89,6 +56,7 @@ class StructuredReasoningStream:kind=ReplayArtifactKind.REASONING_DETAILS,attachment=ReplayAttachment.REASONING,payload=preserved,+ scope=self._replay_scope,))@@ -102,39 +70,6 @@ def _reasoning_details(delta: Any) -> Sequence[Any]:return details if _is_sequence(details) else ()-def _assistant_reasoning_details(messages: Any) -> list[list[dict[str, Any]]]:- if not _is_sequence(messages):- return []- result: list[list[dict[str, Any]]] = []- for message in messages:- if _field(message, "role") != "assistant":- continue- details = _redacted_reasoning_details(_field(message, "content"))- if details:- result.append(details)- return result---def _redacted_reasoning_details(content: Any) -> list[dict[str, Any]]:- if not _is_sequence(content):- return []- details: list[dict[str, Any]] = []- for block in content:- if _field(block, "type") != "redacted_thinking":- continue- data = _field(block, "data")- if not isinstance(data, str) or not data:- continue- parsed = _json_payload(data)- if isinstance(parsed, list):- details.extend(item for item in parsed if isinstance(item, dict))- elif isinstance(parsed, dict):- details.append(parsed)- else:- details.append({"type": "reasoning.encrypted", "data": data})- return details--def _reasoning_detail_text(detail: Any) -> str | None:kind = str(_field(detail, "type") or "").lower()if "encrypted" in kind or "redacted" in kind:@@ -162,13 +97,6 @@ def _preserved_reasoning_detail(detail: Any) -> str | None:return None-def _json_payload(value: str) -> Any:- try:- return json.loads(value)- except json.JSONDecodeError:- return None--def _field(item: Any, name: str) -> Any:if isinstance(item, Mapping):return item.get(name)diff --git a/src/free_claude_code/core/anthropic/streaming/recovery.py b/src/free_claude_code/providers/openai_chat/recovery.pysimilarity index 91%rename from src/free_claude_code/core/anthropic/streaming/recovery.pyrename to src/free_claude_code/providers/openai_chat/recovery.pyindex 68143304..79383479 100644--- a/src/free_claude_code/core/anthropic/streaming/recovery.py+++ b/src/free_claude_code/providers/openai_chat/recovery.py@@ -1,4 +1,4 @@-"""Pure Anthropic continuation and tool-repair transformations."""+"""OpenAI Chat continuation and tool-repair transformations."""import jsonfrom copy import deepcopy@@ -8,7 +8,11 @@ from typing import Anyimport jsonschemafrom loguru import logger-from ..models import MessagesRequest+from free_claude_code.core.inference import (+ FunctionTool,+ InferenceRequest,+ thaw_json_object,+)_RECOVERY_USER_PREFIX = ("The previous provider stream was interrupted. Continue the assistant response "@@ -21,7 +25,7 @@ _RECOVERY_THINKING_PREFIX = (@dataclass(frozen=True, slots=True)class ToolSchema:- """Tool schema resolved from the original Anthropic request."""+ """Tool schema resolved from the original canonical request."""name: strinput_schema: dict[str, Any]@@ -35,20 +39,16 @@ class ToolRepair:parsed_input: dict[str, Any]-def tool_schemas_by_name(request: MessagesRequest) -> dict[str, ToolSchema]:- """Return Anthropic tool input schemas keyed by tool name."""+def tool_schemas_by_name(request: InferenceRequest) -> dict[str, ToolSchema]:+ """Return canonical function-tool schemas keyed by tool name."""schemas: dict[str, ToolSchema] = {}- tools = request.tools- if not tools:- return schemas-- for tool in tools:+ for tool in request.tools:+ if not isinstance(tool, FunctionTool):+ continuename = tool.nameif not name:continue- schema = tool.input_schema- if schema is None:- schema = {"type": "object"}+ schema = thaw_json_object(tool.input_schema)schemas[name] = ToolSchema(name=name, input_schema=deepcopy(schema))return schemasdiff --git a/src/free_claude_code/providers/openai_chat/request_codec.py b/src/free_claude_code/providers/openai_chat/request_codec.pynew file mode 100644index 00000000..62129698--- /dev/null+++ b/src/free_claude_code/providers/openai_chat/request_codec.py@@ -0,0 +1,747 @@+"""Encode canonical inference requests as OpenAI Chat Completions bodies."""++import json+from collections.abc import Mapping, Sequence+from dataclasses import dataclass, field+from enum import StrEnum+from typing import cast++from free_claude_code.core.inference import (+ Base64MediaSource,+ CacheControl,+ CustomTool,+ DocumentContent,+ FunctionTool,+ ImageContent,+ InferenceItem,+ InferenceRequest,+ InstructionItem,+ InstructionPlacement,+ MessageItem,+ MessageRole,+ ReasoningItem,+ RefusalContent,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayCompatibilityScope,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolChoiceMode,+ ToolResultItem,+ UrlMediaSource,+ thaw_json,+ thaw_json_object,+)+from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec+++class OpenAIConversionError(ValueError):+ """Canonical content cannot be represented by OpenAI Chat without loss."""+++class ReasoningReplayMode(StrEnum):+ """How visible assistant reasoning is replayed to a Chat provider."""++ DISABLED = "disabled"+ THINK_TAGS = "think_tags"+ REASONING_CONTENT = "reasoning_content"+ REASONING = "reasoning"+++@dataclass(slots=True)+class _PlainSegment:+ messages: list[JsonObject]+++@dataclass(slots=True)+class _ToolTurnSegment:+ assistant_message: JsonObject+ required_tool_ids: list[str]+ deferred_items: list[InferenceItem] = field(default_factory=list)+ reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS+ replay_scope: ReplayCompatibilityScope | None = None+ assistant_emitted: bool = False+++type _TranscriptSegment = _PlainSegment | _ToolTurnSegment+++class _SyntheticOpenAIToolTurnBoundary(dict[str, JsonValue]):+ __slots__ = ()+++def is_synthetic_openai_tool_turn_boundary(message: object) -> bool:+ """Return whether FCC inserted a harmless assistant tool-turn boundary."""++ return isinstance(message, _SyntheticOpenAIToolTurnBoundary)+++class _OpenAIChatHistoryLedger:+ """Emit tool calls before their results without reordering later content."""++ def __init__(+ self,+ *,+ tool_names: OpenAIToolNameCodec,+ ) -> None:+ self._tool_names = tool_names+ self._output: list[JsonObject] = []+ self._segments: list[_TranscriptSegment] = []+ self._tool_results: dict[str, JsonObject] = {}++ def add_plain(self, messages: list[JsonObject]) -> None:+ if messages:+ self._segments.append(_PlainSegment(messages))+ self._drain_ready_segments()++ def add_tool_turn(self, segment: _ToolTurnSegment) -> None:+ self._segments.append(segment)+ self._drain_ready_segments()++ def add_user_turn(self, items: list[InferenceItem]) -> None:+ visible: list[MessageItem] = []++ def flush_visible() -> None:+ if visible:+ self.add_plain(_user_messages(visible))+ visible.clear()++ for item in items:+ if isinstance(item, MessageItem):+ visible.append(item)+ elif isinstance(item, ToolResultItem):+ flush_visible()+ self._record_tool_result(item)+ else:+ raise OpenAIConversionError(+ f"user turn contains unsupported {type(item).__name__}"+ )+ flush_visible()+ self._drain_ready_segments()++ def finish(self) -> list[JsonObject]:+ self._drain_ready_segments()+ missing = self._missing_required_tool_ids()+ if missing:+ raise OpenAIConversionError(+ "OpenAI Chat cannot replay incomplete tool history; missing "+ f"tool results for call IDs: {missing}"+ )+ while self._segments:+ segment = self._segments.pop(0)+ if isinstance(segment, _PlainSegment):+ self._output.extend(segment.messages)+ else:+ self._emit_tool_turn(segment)+ return _coalesce_user_messages(_close_tool_result_turns(self._output))++ def _record_tool_result(self, item: ToolResultItem) -> None:+ message: JsonObject = {+ "role": "tool",+ "tool_call_id": item.call_id,+ "content": serialize_tool_result_content(item.content),+ }+ if self._has_pending_tool_id(item.call_id):+ self._tool_results[item.call_id] = message+ else:+ self.add_plain([message])++ def _drain_ready_segments(self) -> None:+ while self._segments:+ segment = self._segments[0]+ if isinstance(segment, _PlainSegment):+ self._output.extend(segment.messages)+ self._segments.pop(0)+ continue+ if not segment.assistant_emitted:+ self._output.append(segment.assistant_message)+ segment.assistant_emitted = True+ if any(+ call_id not in self._tool_results+ for call_id in segment.required_tool_ids+ ):+ break+ self._segments.pop(0)+ for call_id in segment.required_tool_ids:+ self._output.append(self._tool_results.pop(call_id))+ self._output.extend(+ _assistant_messages(+ segment.deferred_items,+ reasoning_replay=segment.reasoning_replay,+ replay_scope=segment.replay_scope,+ )+ )++ def _emit_tool_turn(self, segment: _ToolTurnSegment) -> None:+ if not segment.assistant_emitted:+ self._output.append(segment.assistant_message)+ for call_id in segment.required_tool_ids:+ result = self._tool_results.pop(call_id, None)+ if result is not None:+ self._output.append(result)+ self._output.extend(+ _assistant_messages(+ segment.deferred_items,+ reasoning_replay=segment.reasoning_replay,+ replay_scope=segment.replay_scope,+ )+ )++ def _missing_required_tool_ids(self) -> list[str]:+ return [+ call_id+ for segment in self._segments+ if isinstance(segment, _ToolTurnSegment)+ for call_id in segment.required_tool_ids+ if call_id not in self._tool_results+ ]++ def _has_pending_tool_id(self, call_id: str) -> bool:+ return any(+ isinstance(segment, _ToolTurnSegment)+ and call_id in segment.required_tool_ids+ for segment in self._segments+ )+++def build_base_request_body(+ request: InferenceRequest,+ *,+ provider_model: str,+ tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope | None,+ default_max_tokens: int | None = None,+ reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,+) -> JsonObject:+ """Build common OpenAI Chat fields from canonical semantics."""++ turns = _turns(request.items)+ ledger = _OpenAIChatHistoryLedger(tool_names=tool_names)+ for turn_items in turns:+ if all(isinstance(item, InstructionItem) for item in turn_items):+ text = "\n\n".join(+ item.text for item in turn_items if isinstance(item, InstructionItem)+ )+ ledger.add_plain([{"role": "user", "content": text}])+ elif any(isinstance(item, ToolResultItem) for item in turn_items) or all(+ isinstance(item, MessageItem) and item.role is MessageRole.USER+ for item in turn_items+ ):+ ledger.add_user_turn(turn_items)+ else:+ segment = _assistant_segment(+ turn_items,+ reasoning_replay=reasoning_replay,+ replay_scope=replay_scope,+ tool_names=tool_names,+ )+ if isinstance(segment, _ToolTurnSegment):+ ledger.add_tool_turn(segment)+ else:+ ledger.add_plain(segment.messages)++ messages = ledger.finish()+ top_level = [+ item+ for item in request.items+ if isinstance(item, InstructionItem)+ and item.placement is InstructionPlacement.TOP_LEVEL+ ]+ if top_level:+ messages.insert(0, _system_message(top_level))++ body: JsonObject = {"model": provider_model, "messages": messages}+ max_tokens = request.max_output_tokens or default_max_tokens+ if max_tokens is not None:+ body["max_tokens"] = max_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.stop_sequences:+ body["stop"] = list(request.stop_sequences)+ if request.metadata is not None:+ body["metadata"] = thaw_json_object(request.metadata)+ if request.tools:+ body["tools"] = [+ _tool_definition(tool, tool_names=tool_names) for tool in request.tools+ ]+ if request.tool_choice is not None:+ body["tool_choice"] = _tool_choice(request, tool_names=tool_names)+ elif request.tools:+ body["tool_choice"] = "auto"+ if request.parallel_tool_calls is not None:+ body["parallel_tool_calls"] = request.parallel_tool_calls+ return body+++def serialize_tool_result_content(content: JsonValue) -> str:+ """Serialize canonical tool output into provider-safe text."""++ if content is None:+ return ""+ if isinstance(content, str):+ return content+ if isinstance(content, Mapping):+ return json.dumps(thaw_json(content), ensure_ascii=False)+ if isinstance(content, Sequence):+ parts: list[str] = []+ for item in content:+ if isinstance(item, Mapping) and item.get("type") == "text":+ text = item.get("text")+ parts.append(text if isinstance(text, str) else str(text or ""))+ elif isinstance(item, Mapping | Sequence) and not isinstance(item, str):+ parts.append(json.dumps(thaw_json(item), ensure_ascii=False))+ else:+ parts.append(str(item))+ return "\n".join(parts)+ return str(content)+++def _turns(items: tuple[InferenceItem, ...]) -> list[list[InferenceItem]]:+ turns: list[list[InferenceItem]] = []+ indexes: dict[str, int] = {}+ for item in items:+ if isinstance(item, InstructionItem):+ if item.placement is InstructionPlacement.TOP_LEVEL:+ continue+ turn_id = item.turn_id+ else:+ turn_id = item.turn_id+ if turn_id is None:+ raise OpenAIConversionError("transcript item has no turn identity")+ index = indexes.get(turn_id)+ if index is None:+ index = len(turns)+ indexes[turn_id] = index+ turns.append([])+ turns[index].append(item)+ return turns+++def _assistant_segment(+ items: list[InferenceItem],+ *,+ reasoning_replay: ReasoningReplayMode,+ replay_scope: ReplayCompatibilityScope | None,+ tool_names: OpenAIToolNameCodec,+) -> _TranscriptSegment:+ first_tool = next(+ (index for index, item in enumerate(items) if isinstance(item, ToolCallItem)),+ None,+ )+ if first_tool is None:+ return _PlainSegment(+ _assistant_messages(+ items,+ reasoning_replay=reasoning_replay,+ replay_scope=replay_scope,+ )+ )+ calls = [item for item in items if isinstance(item, ToolCallItem)]+ pre_items = items[:first_tool]+ message = _assistant_message(+ pre_items,+ reasoning_replay=reasoning_replay,+ replay_scope=replay_scope,+ )+ message["tool_calls"] = [+ _tool_call(item, tool_names=tool_names, replay_scope=replay_scope)+ for item in calls+ ]+ if message.get("content") == " ":+ message["content"] = ""+ if reasoning_replay is ReasoningReplayMode.REASONING_CONTENT:+ message.setdefault("reasoning_content", "")+ return _ToolTurnSegment(+ assistant_message=message,+ required_tool_ids=[item.call_id for item in calls],+ deferred_items=[+ item+ for index, item in enumerate(items)+ if index > first_tool and not isinstance(item, ToolCallItem)+ ],+ reasoning_replay=reasoning_replay,+ replay_scope=replay_scope,+ )+++def _assistant_messages(+ items: list[InferenceItem],+ *,+ reasoning_replay: ReasoningReplayMode,+ replay_scope: ReplayCompatibilityScope | None,+) -> list[JsonObject]:+ if not items:+ return []+ return [+ _assistant_message(+ items,+ reasoning_replay=reasoning_replay,+ replay_scope=replay_scope,+ )+ ]+++def _assistant_message(+ items: list[InferenceItem],+ *,+ reasoning_replay: ReasoningReplayMode,+ replay_scope: ReplayCompatibilityScope | None,+) -> JsonObject:+ text_parts: list[str] = []+ reasoning_parts: list[str] = []+ reasoning_details: list[JsonValue] = []+ for item in items:+ if isinstance(item, MessageItem):+ if item.role is not MessageRole.ASSISTANT:+ raise OpenAIConversionError("assistant turn contains user content")+ for part in item.content:+ if isinstance(part, TextContent):+ text_parts.append(part.text)+ elif isinstance(part, RefusalContent):+ text_parts.append(part.refusal)+ else:+ raise OpenAIConversionError(+ "OpenAI Chat cannot represent assistant media content"+ )+ elif isinstance(item, ReasoningItem):+ if reasoning_replay is ReasoningReplayMode.THINK_TAGS and item.reasoning:+ text_parts.append(f"<think>\n{item.reasoning}\n</think>")+ elif (+ reasoning_replay is not ReasoningReplayMode.DISABLED and item.reasoning+ ):+ reasoning_parts.append(item.reasoning)+ reasoning_details.extend(+ _reasoning_details(item.artifacts, replay_scope=replay_scope)+ )+ else:+ raise OpenAIConversionError(+ f"assistant turn contains unsupported {type(item).__name__}"+ )+ message: JsonObject = {+ "role": "assistant",+ "content": "\n\n".join(text_parts) or " ",+ }+ if reasoning_parts and reasoning_replay in {+ ReasoningReplayMode.REASONING_CONTENT,+ ReasoningReplayMode.REASONING,+ }:+ message[reasoning_replay.value] = "\n".join(reasoning_parts)+ if reasoning_details:+ message["reasoning_details"] = [+ thaw_json(detail) for detail in reasoning_details+ ]+ return message+++def _user_messages(items: list[MessageItem]) -> list[JsonObject]:+ content_parts: list[JsonObject] = []+ for item in items:+ if item.role is not MessageRole.USER:+ raise OpenAIConversionError("user turn contains assistant content")+ for part in item.content:+ if isinstance(part, TextContent):+ content: JsonObject = {"type": "text", "text": part.text}+ _add_cache_control(content, part.cache_control)+ content_parts.append(content)+ elif isinstance(part, ImageContent):+ content_parts.append(_image_part(part))+ elif isinstance(part, DocumentContent):+ raise OpenAIConversionError(+ "OpenAI Chat cannot represent document content without data loss"+ )+ elif isinstance(part, RefusalContent):+ content_parts.append({"type": "text", "text": part.refusal})+ if all(+ part.get("type") == "text" and "cache_control" not in part+ for part in content_parts+ ):+ message_content: JsonValue = "\n".join(+ str(part.get("text", "")) for part in content_parts+ )+ else:+ message_content = content_parts+ return [{"role": "user", "content": message_content}]+++def _system_message(items: list[InstructionItem]) -> JsonObject:+ if all(item.cache_control is None for item in items):+ return {+ "role": "system",+ "content": "\n\n".join(item.text for item in items).strip(),+ }+ parts: list[JsonObject] = []+ for item in items:+ part: JsonObject = {"type": "text", "text": item.text}+ _add_cache_control(part, item.cache_control)+ parts.append(part)+ return {"role": "system", "content": parts}+++def _image_part(content: ImageContent) -> JsonObject:+ if isinstance(content.source, UrlMediaSource):+ url = content.source.url+ elif isinstance(content.source, Base64MediaSource):+ url = f"data:{content.source.media_type};base64,{content.source.data}"+ else:+ raise OpenAIConversionError("unsupported canonical image source")+ part: JsonObject = {"type": "image_url", "image_url": {"url": url}}+ _add_cache_control(part, content.cache_control)+ return part+++def _tool_definition(+ tool: FunctionTool | CustomTool,+ *,+ tool_names: OpenAIToolNameCodec,+) -> JsonObject:+ kind = (+ ToolCallKind.CUSTOM if isinstance(tool, CustomTool) else ToolCallKind.FUNCTION+ )+ if isinstance(tool, FunctionTool):+ parameters = thaw_json_object(tool.input_schema)+ description = tool.description or ""+ strict = tool.strict+ else:+ parameters = {+ "type": "object",+ "properties": {+ "input": {+ "type": "string",+ "description": "Free-form input for the custom tool.",+ }+ },+ "required": ["input"],+ }+ format_parts = [f"Custom tool input format: {tool.format.type.value}."]+ if tool.format.syntax:+ format_parts.append(f"Syntax: {tool.format.syntax}.")+ if tool.format.definition:+ format_parts.append(tool.format.definition)+ description = "\n\n".join(+ part for part in (tool.description, *format_parts) if part+ )+ strict = False+ function: JsonObject = {+ "name": tool_names.encode(+ tool.name,+ kind=kind,+ namespace=tool.namespace,+ ),+ "description": description,+ "parameters": parameters,+ }+ if strict:+ function["strict"] = True+ definition: JsonObject = {"type": "function", "function": function}+ _add_cache_control(definition, tool.cache_control)+ return definition+++def _tool_choice(+ request: InferenceRequest,+ *,+ tool_names: OpenAIToolNameCodec,+) -> JsonValue:+ choice = request.tool_choice+ if choice is None:+ return "auto"+ if choice.mode is ToolChoiceMode.AUTO:+ return "auto"+ if choice.mode is ToolChoiceMode.NONE:+ return "none"+ if choice.mode is ToolChoiceMode.REQUIRED:+ return "required"+ if choice.kind is None or choice.name is None:+ raise OpenAIConversionError("specific tool choice has no identity")+ return {+ "type": "function",+ "function": {+ "name": tool_names.encode(+ choice.name,+ kind=choice.kind,+ namespace=choice.namespace,+ )+ },+ }+++def _tool_call(+ item: ToolCallItem,+ *,+ tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope | None,+) -> JsonObject:+ if item.kind is ToolCallKind.CUSTOM:+ arguments_value: JsonValue = {"input": _custom_input_text(item.input)}+ else:+ arguments_value = item.input+ call: JsonObject = {+ "id": item.call_id,+ "type": "function",+ "function": {+ "name": tool_names.encode(+ item.name,+ kind=item.kind,+ namespace=item.namespace,+ ),+ "arguments": json.dumps(+ thaw_json(arguments_value),+ ensure_ascii=False,+ separators=(",", ":"),+ ),+ },+ }+ if extra_content := _tool_extra_content(+ item.artifacts,+ replay_scope=replay_scope,+ ):+ call["extra_content"] = extra_content+ return call+++def _custom_input_text(value: JsonValue) -> str:+ if isinstance(value, str):+ return value+ if isinstance(value, Mapping):+ raw = value.get("input")+ if isinstance(raw, str):+ return raw+ return json.dumps(thaw_json(value), ensure_ascii=False, separators=(",", ":"))+++def _reasoning_details(+ artifacts: tuple[ReplayArtifact, ...],+ *,+ replay_scope: ReplayCompatibilityScope | None,+) -> list[JsonValue]:+ details: list[JsonValue] = []+ for artifact in artifacts:+ if (+ artifact.kind is not ReplayArtifactKind.REASONING_DETAILS+ or not _scope_matches(artifact, replay_scope)+ ):+ continue+ payload = artifact.payload+ if isinstance(payload, str):+ try:+ parsed = json.loads(payload)+ except json.JSONDecodeError:+ continue+ if isinstance(parsed, list):+ details.extend(cast(list[JsonValue], parsed))+ elif isinstance(parsed, dict):+ details.append(cast(JsonValue, parsed))+ elif isinstance(payload, Sequence) and not isinstance(payload, str):+ details.extend(payload)+ else:+ details.append(payload)+ return details+++def _tool_extra_content(+ artifacts: tuple[ReplayArtifact, ...],+ *,+ replay_scope: ReplayCompatibilityScope | None,+) -> JsonObject:+ result: JsonObject = {}+ for artifact in artifacts:+ if not _scope_matches(artifact, replay_scope):+ continue+ if artifact.kind is ReplayArtifactKind.THOUGHT_SIGNATURE and isinstance(+ artifact.payload, str+ ):+ result["google"] = {"thought_signature": artifact.payload}+ elif artifact.kind is ReplayArtifactKind.TOOL_EXTRA_CONTENT and isinstance(+ artifact.payload, Mapping+ ):+ result.update(thaw_json_object(artifact.payload))+ return result+++def _scope_matches(+ artifact: ReplayArtifact,+ replay_scope: ReplayCompatibilityScope | None,+) -> bool:+ return replay_scope is not None and artifact.scope == replay_scope+++def _add_cache_control(target: JsonObject, cache_control: CacheControl | None) -> None:+ if cache_control is None:+ return+ value: dict[str, str] = {"type": cache_control.type.value}+ if cache_control.ttl is not None:+ value["ttl"] = cache_control.ttl.value+ target["cache_control"] = value+++def _coalesce_user_messages(+ messages: list[JsonObject],+) -> list[JsonObject]:+ result: list[JsonObject] = []+ for message in messages:+ if (+ message.get("role") == "user"+ and result+ and result[-1].get("role") == "user"+ ):+ previous = result[-1]+ previous["content"] = _merge_user_content(+ previous.get("content"),+ message.get("content"),+ )+ else:+ result.append(message)+ return result+++def _merge_user_content(first: JsonValue, second: JsonValue) -> JsonValue:+ if isinstance(first, str) and isinstance(second, str):+ return f"{first}\n\n{second}"+ first_parts = _user_content_parts(first)+ second_parts = _user_content_parts(second)+ if (+ first_parts+ and second_parts+ and first_parts[-1].get("type") == "text"+ and second_parts[0].get("type") == "text"+ and "cache_control" not in first_parts[-1]+ and "cache_control" not in second_parts[0]+ ):+ first_text = str(first_parts[-1].get("text", ""))+ second_text = str(second_parts.pop(0).get("text", ""))+ first_parts[-1]["text"] = f"{first_text}\n\n{second_text}"+ return [*first_parts, *second_parts]+++def _user_content_parts(content: JsonValue) -> list[JsonObject]:+ if isinstance(content, str):+ return [{"type": "text", "text": content}]+ if isinstance(content, Sequence) and not isinstance(content, str):+ parts: list[JsonObject] = []+ for part in content:+ if not isinstance(part, Mapping):+ raise OpenAIConversionError("OpenAI Chat produced invalid user content")+ parts.append(thaw_json_object(part))+ return parts+ raise OpenAIConversionError("OpenAI Chat produced invalid user content")+++def _close_tool_result_turns(+ messages: list[JsonObject],+) -> list[JsonObject]:+ result: list[JsonObject] = []+ for message in messages:+ if (+ message.get("role") == "user"+ and result+ and result[-1].get("role") == "tool"+ ):+ result.append(+ _SyntheticOpenAIToolTurnBoundary(role="assistant", content=" ")+ )+ result.append(message)+ return resultdiff --git a/src/free_claude_code/providers/openai_chat/request_policy.py b/src/free_claude_code/providers/openai_chat/request_policy.pyindex 2d15a395..f03b1a7e 100644--- a/src/free_claude_code/providers/openai_chat/request_policy.py+++ b/src/free_claude_code/providers/openai_chat/request_policy.py@@ -1,36 +1,42 @@"""Request-body policy for OpenAI-compatible chat providers."""from collections.abc import Callable, Iterable-from copy import deepcopyfrom dataclasses import dataclass, field-from typing import Any, Literal+from typing import Literalfrom loguru import loggerfrom free_claude_code.application.errors import InvalidRequestError-from free_claude_code.core.anthropic import (- OpenAIToolNameCodec,+from free_claude_code.core.inference import (+ InferenceRequest,+ ReplayCompatibilityScope,+ thaw_json_object,+)+from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec++from .request_codec import (+ OpenAIConversionError,ReasoningReplayMode,build_base_request_body,)-from free_claude_code.core.anthropic.conversion import OpenAIConversionError-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.reasoning import ReasoningPolicyMaxTokensField = Literal["max_tokens", "max_completion_tokens"]OpenAIChatPostprocessor = Callable[- [dict[str, Any], MessagesRequest, ReasoningPolicy], None+ [JsonObject, InferenceRequest, ReasoningPolicy], None]-ExtraBodyValidator = Callable[[dict[str, Any]], None]+ExtraBodyValidator = Callable[[JsonObject], None]@dataclass(frozen=True, slots=True)class OpenAIChatRequestPolicy:- """Provider policy for Anthropic-to-OpenAI chat request conversion."""+ """Provider policy for canonical-to-OpenAI Chat request encoding."""provider_name: strreasoning_replay: ReasoningReplayModeinclude_extra_body: bool = False+ postprocessor_consumes_extra_body: bool = Falseextra_body_validator: ExtraBodyValidator | None = Nonereject_extra_body_message: str | None = Nonedefault_max_tokens: int | None = None@@ -41,113 +47,72 @@ class OpenAIChatRequestPolicy:def build_openai_chat_request_body(- request_data: MessagesRequest,+ request_data: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,policy: OpenAIChatRequestPolicy,+ tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope | None,postprocessors: Iterable[OpenAIChatPostprocessor] = (),-) -> dict[str, Any]:- """Build an OpenAI-compatible chat request body from an Anthropic request."""+) -> JsonObject:+ """Build an OpenAI-compatible Chat request body from canonical input."""logger.debug("{}_REQUEST: conversion start model={} msgs={}",policy.provider_name,- request_data.model,- len(request_data.messages),+ provider_model,+ request_data.message_count,)try:body = build_base_request_body(request_data,+ provider_model=provider_model,+ tool_names=tool_names,+ replay_scope=replay_scope,default_max_tokens=policy.default_max_tokens,reasoning_replay=policy.reasoning_replay,)except OpenAIConversionError as exc:raise InvalidRequestError(str(exc)) from exc- request_extra = request_data.extra_body- if isinstance(request_extra, dict) and request_extra:+ extension = request_data.openai_chat_extension+ if extension is not None and extension.extra_body:if policy.reject_extra_body_message:raise InvalidRequestError(policy.reject_extra_body_message)if policy.include_extra_body:- extra_body = deepcopy(request_extra)+ extra_body = thaw_json_object(extension.extra_body)if policy.extra_body_validator is not None:try:policy.extra_body_validator(extra_body)except ValueError as exc:raise InvalidRequestError(str(exc)) from excbody["extra_body"] = extra_body+ elif not policy.postprocessor_consumes_extra_body:+ raise InvalidRequestError(+ f"{policy.provider_name} does not support caller extra_body."+ )_apply_common_openai_chat_policy(body, policy)for postprocess in postprocessors:postprocess(body, request_data, reasoning)- _encode_openai_tool_names(body, OpenAIToolNameCodec.from_request(request_data))-logger.debug("{}_REQUEST: conversion done model={} msgs={} tools={}",policy.provider_name,body.get("model"),- len(body.get("messages", [])),- len(body.get("tools", [])),+ _sequence_length(body.get("messages")),+ _sequence_length(body.get("tools")),)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 _sequence_length(value: object) -> int:+ return len(value) if isinstance(value, list | tuple) else 0def _apply_common_openai_chat_policy(- body: dict[str, Any], policy: OpenAIChatRequestPolicy+ body: JsonObject, policy: OpenAIChatRequestPolicy) -> None:if policy.strip_message_names:_strip_message_names(body.get("messages"))@@ -162,7 +127,7 @@ def _apply_common_openai_chat_policy(body["n"] = 1-def _strip_message_names(messages: Any) -> None:+def _strip_message_names(messages: JsonValue) -> None:if not isinstance(messages, list):returnfor message in messages:@@ -170,7 +135,7 @@ def _strip_message_names(messages: Any) -> None:message.pop("name", None)-def _normalize_max_completion_tokens(body: dict[str, Any]) -> None:+def _normalize_max_completion_tokens(body: JsonObject) -> None:if "max_completion_tokens" in body:body.pop("max_tokens", None)returndiff --git a/src/free_claude_code/providers/openai_chat/tool_calls.py b/src/free_claude_code/providers/openai_chat/tool_calls.pyindex 174f4352..3f06a752 100644--- a/src/free_claude_code/providers/openai_chat/tool_calls.py+++ b/src/free_claude_code/providers/openai_chat/tool_calls.py@@ -1,27 +1,36 @@"""OpenAI-chat tool-call assembly helpers."""+import hashlibimport jsonimport uuidfrom collections.abc import Callable, Iteratorfrom dataclasses import dataclass, fieldfrom typing import Any-from free_claude_code.core.anthropic import OpenAIToolNameCodec-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.streaming import (- parse_complete_tool_input,- tool_schemas_by_name,-)+from loguru import logger+from free_claude_code.core.inference import (+ CustomTool,InferenceEvent,+ InferenceRequest,InferenceStreamLedger,ReplayArtifact,ReplayArtifactKind,ReplayArtifactOrigin,ReplayAttachment,+ ReplayCompatibilityScope,ToolCallKind,ToolCallState,)+from free_claude_code.core.json_types import JsonObject+from free_claude_code.providers.openai_chat.recovery import (+ parse_complete_tool_input,+ tool_schemas_by_name,+)+from free_claude_code.providers.openai_compat import (+ OpenAIToolIdentity,+ OpenAIToolNameCodec,+)RecordToolExtraContent = Callable[[str, dict[str, Any]], None]@@ -70,23 +79,38 @@ class OpenAIToolCallCollector:def completed_calls(self,- request: MessagesRequest,+ request: InferenceRequest,*,tool_names: OpenAIToolNameCodec | None = None,tool_argument_aliases: dict[str, dict[str, str]] | None = None,) -> tuple[dict[str, Any], ...] | None:"""Return complete schema-valid calls, or None when output is incomplete."""schemas = tool_schemas_by_name(request)+ request_identities = {+ OpenAIToolIdentity(+ ToolCallKind.CUSTOM+ if isinstance(tool, CustomTool)+ else ToolCallKind.FUNCTION,+ tool.name,+ tool.namespace,+ )+ for tool in request.tools+ }completed: list[dict[str, Any]] = []for index in sorted(self._calls):state = self._calls[index]wire_name = state.name.strip()- name = tool_names.decode(wire_name) if tool_names is not None else wire_name- if not name or name not in schemas:+ identity = (+ tool_names.decode_identity(wire_name)+ if tool_names is not None+ else OpenAIToolIdentity(ToolCallKind.FUNCTION, wire_name)+ )+ name = identity.name+ if not name or identity not in request_identities:return Nonearguments = "".join(state.argument_parts)aliases = (- tool_argument_aliases.get(name, {})+ tool_argument_aliases.get(wire_name, {})if tool_argument_aliases is not Noneelse {})@@ -102,7 +126,7 @@ class OpenAIToolCallCollector:"index": index,"id": state.tool_id,"function": {- "name": name,+ "name": wire_name,"arguments": arguments,},}@@ -120,10 +144,11 @@ def iter_heuristic_tool_use_events() -> Iterator[InferenceEvent]:"""Emit canonical events for one heuristic tool-use block."""name = tool_use.get("name")+ identity = OpenAIToolIdentity(ToolCallKind.FUNCTION, str(name or ""))if tool_names is not None and isinstance(name, str):- decoded_name = tool_names.decode(name)- if decoded_name != name:- tool_use = {**tool_use, "name": decoded_name}+ identity = tool_names.decode_identity(name)+ if identity.name != name:+ tool_use = {**tool_use, "name": identity.name}if tool_use.get("name") == "Task" and isinstance(tool_use.get("input"), dict):task_input = tool_use["input"]if task_input.get("run_in_background") is not False:@@ -134,7 +159,8 @@ def iter_heuristic_tool_use_events(tool_index,str(tool_use["id"]),str(tool_use["name"]),- kind=ToolCallKind.FUNCTION,+ kind=identity.kind,+ namespace=identity.namespace,)yield ledger.emit_tool_delta(tool_index, json.dumps(tool_use["input"]))yield ledger.stop_tool_block(tool_index)@@ -182,7 +208,7 @@ def started_tool_states(def all_emitted_tools_complete(- ledger: InferenceStreamLedger, request: MessagesRequest+ ledger: InferenceStreamLedger, request: InferenceRequest) -> bool:"""Return whether every emitted tool block has schema-valid input."""schemas = tool_schemas_by_name(request)@@ -201,9 +227,15 @@ class OpenAIToolCallAssembler:"""Assemble OpenAI tool-call deltas into canonical tool events."""def __init__(- self, *, record_extra_content: RecordToolExtraContent | None = None+ self,+ *,+ replay_scope: ReplayCompatibilityScope,+ record_extra_content: RecordToolExtraContent | None = None,) -> None:+ self._replay_scope = replay_scopeself._record_extra_content = record_extra_content+ self._task_arg_buffers: dict[int, str] = {}+ self._task_args_emitted: set[int] = set()def process_tool_call(self,@@ -237,18 +269,23 @@ class OpenAIToolCallAssembler:if extra_content:ledger.set_tool_artifacts(tc_index,- _tool_replay_artifacts(extra_content),+ _tool_replay_artifacts(extra_content, scope=self._replay_scope),)if isinstance(incoming_name, str) and incoming_name:- resolved_name = _decode_streamed_tool_name(+ resolved_identity = _decode_streamed_tool_identity(incoming_name,tool_index=tc_index,tool_names=tool_names,buffers=tool_name_buffers,)- if resolved_name is not None:- ledger.blocks.register_tool_name(tc_index, resolved_name)+ if resolved_identity is not None:+ ledger.blocks.register_tool_identity(+ tc_index,+ resolved_identity.name,+ kind=resolved_identity.kind,+ namespace=resolved_identity.namespace,+ )state = ledger.blocks.tool_states.get(tc_index)resolved_id = (state.call_id if state and state.call_id else None) or tc.get(@@ -268,6 +305,8 @@ class OpenAIToolCallAssembler:tc_index,tool_id,display_name,+ kind=state.kind if state else ToolCallKind.FUNCTION,+ namespace=state.namespace if state else None,artifacts=start_artifacts,)state = ledger.blocks.tool_states[tc_index]@@ -278,6 +317,7 @@ class OpenAIToolCallAssembler:ledger,tc_index,pre,+ tool_names=tool_names,tool_argument_aliases=tool_argument_aliases,tool_argument_alias_buffers=tool_argument_alias_buffers,)@@ -297,6 +337,7 @@ class OpenAIToolCallAssembler:ledger,tc_index,arguments,+ tool_names=tool_names,tool_argument_aliases=tool_argument_aliases,tool_argument_alias_buffers=tool_argument_alias_buffers,)@@ -305,8 +346,34 @@ class OpenAIToolCallAssembler:self, ledger: InferenceStreamLedger) -> Iterator[InferenceEvent]:"""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, buffered in list(self._task_arg_buffers.items()):+ if not buffered or tool_index in self._task_args_emitted:+ continue+ output = "{}"+ try:+ parsed = json.loads(buffered)+ if isinstance(parsed, dict):+ _normalize_task_run_in_background(parsed)+ output = json.dumps(parsed)+ except (json.JSONDecodeError, TypeError, ValueError) as exc:+ state = ledger.blocks.tool_states.get(tool_index)+ digest = hashlib.sha256(+ buffered.encode("utf-8", errors="replace")+ ).hexdigest()[:16]+ logger.warning(+ "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",+ state.call_id if state is not None and state.call_id else "unknown",+ len(buffered),+ digest,+ exc,+ )+ self._task_args_emitted.add(tool_index)+ self._task_arg_buffers.pop(tool_index, None)+ yield ledger.emit_tool_delta(tool_index, output)++ def buffered_task_args(self, tool_index: int) -> str:+ """Return provider-owned Task arguments that have not been emitted yet."""+ return self._task_arg_buffers.get(tool_index, "")def flush_tool_name_buffers(self,@@ -334,6 +401,7 @@ class OpenAIToolCallAssembler:def flush_tool_argument_alias_buffers(self,ledger: InferenceStreamLedger,+ tool_names: OpenAIToolNameCodec,tool_argument_aliases: dict[str, dict[str, str]],tool_argument_alias_buffers: dict[int, str],) -> Iterator[InferenceEvent]:@@ -345,7 +413,13 @@ class OpenAIToolCallAssembler:state = ledger.blocks.tool_states.get(tool_index)if state is None or state.name == "Task":continue- aliases = tool_argument_aliases.get(state.name, {})+ aliases = tool_argument_aliases_for_identity(+ tool_argument_aliases,+ tool_names=tool_names,+ kind=state.kind,+ name=state.name,+ namespace=state.namespace,+ )if not aliases:continuerestored = self._restore_aliased_tool_arguments(buffered_args, aliases)@@ -361,6 +435,7 @@ class OpenAIToolCallAssembler:tc_index: int,args: str,*,+ tool_names: OpenAIToolNameCodec | None,tool_argument_aliases: dict[str, dict[str, str]] | None = None,tool_argument_alias_buffers: dict[int, str] | None = None,) -> Iterator[InferenceEvent]:@@ -371,12 +446,31 @@ class OpenAIToolCallAssembler:if state is None:returnif state.name == "Task":- parsed = ledger.blocks.buffer_task_args(tc_index, args)- if parsed is not None:- yield ledger.emit_tool_delta(tc_index, json.dumps(parsed))+ if tc_index in self._task_args_emitted:+ return+ buffered = self._task_arg_buffers.get(tc_index, "") + args+ self._task_arg_buffers[tc_index] = buffered+ try:+ parsed = json.loads(buffered)+ except json.JSONDecodeError, TypeError, ValueError:+ return+ if not isinstance(parsed, dict):+ return+ _normalize_task_run_in_background(parsed)+ self._task_args_emitted.add(tc_index)+ self._task_arg_buffers.pop(tc_index, None)+ yield ledger.emit_tool_delta(tc_index, json.dumps(parsed))returnaliases = (- tool_argument_aliases.get(state.name, {}) if tool_argument_aliases else {}+ tool_argument_aliases_for_identity(+ tool_argument_aliases,+ tool_names=tool_names,+ kind=state.kind,+ name=state.name,+ namespace=state.namespace,+ )+ if tool_argument_aliases+ else {})if aliases:if tool_argument_alias_buffers is None:@@ -407,6 +501,24 @@ class OpenAIToolCallAssembler:self._record_extra_content(tool_call_id, extra_content)+def tool_argument_aliases_for_identity(+ aliases: dict[str, dict[str, str]],+ *,+ tool_names: OpenAIToolNameCodec | None,+ kind: ToolCallKind,+ name: str,+ namespace: str | None,+) -> dict[str, str]:+ """Resolve provider-private aliases by their exact upstream tool identity."""++ wire_name = (+ tool_names.encode(name, kind=kind, namespace=namespace)+ if tool_names is not None+ else name+ )+ return aliases.get(wire_name, {})++def restore_tool_argument_aliases(argument_json: str,aliases: dict[str, str],@@ -443,31 +555,40 @@ def _merge_tool_name(existing: str, incoming: str) -> str:return "".join((existing, incoming))-def _decode_streamed_tool_name(+def _normalize_task_run_in_background(args: JsonObject) -> None:+ if args.get("run_in_background") is not False:+ args["run_in_background"] = False+++def _decode_streamed_tool_identity(incoming: str,*,tool_index: int,tool_names: OpenAIToolNameCodec | None,buffers: dict[int, str] | None,-) -> str | None:- if tool_names is None or not tool_names.has_aliases:- return incoming+) -> OpenAIToolIdentity | None:+ if tool_names is None:+ return OpenAIToolIdentity(ToolCallKind.FUNCTION, incoming)+ if not tool_names.has_aliases:+ return tool_names.decode_identity(incoming)if buffers is None:- return tool_names.decode(incoming)+ return tool_names.decode_identity(incoming)combined = _merge_tool_name(buffers.get(tool_index, ""), incoming)if tool_names.is_alias(combined):buffers.pop(tool_index, None)- return tool_names.decode(combined)+ return tool_names.decode_identity(combined)if tool_names.is_alias_prefix(combined):buffers[tool_index] = combinedreturn Nonebuffers.pop(tool_index, None)- return tool_names.decode(combined)+ return tool_names.decode_identity(combined)def _tool_replay_artifacts(extra_content: dict[str, Any],+ *,+ scope: ReplayCompatibilityScope,) -> tuple[ReplayArtifact, ...]:google = extra_content.get("google")if isinstance(google, dict):@@ -479,6 +600,7 @@ def _tool_replay_artifacts(kind=ReplayArtifactKind.THOUGHT_SIGNATURE,attachment=ReplayAttachment.TOOL_CALL,payload=signature,+ scope=scope,),)return (@@ -487,5 +609,6 @@ def _tool_replay_artifacts(kind=ReplayArtifactKind.TOOL_EXTRA_CONTENT,attachment=ReplayAttachment.TOOL_CALL,payload=extra_content,+ scope=scope,),)diff --git a/src/free_claude_code/providers/openai_codex/provider.py b/src/free_claude_code/providers/openai_codex/provider.pyindex 53882025..a72ff347 100644--- a/src/free_claude_code/providers/openai_codex/provider.py+++ b/src/free_claude_code/providers/openai_codex/provider.py@@ -12,20 +12,19 @@ import httpxfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfo-from 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.inference import InferenceEvent+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ ReplayCompatibilityScope,+)from free_claude_code.core.openai_responses import (ResponsesConversionError,- ResponsesEventDecoder,- ResponsesStreamFailure,- build_responses_provider_request,)from free_claude_code.core.reasoning import (DEFAULT_REASONING_POLICY,@@ -45,6 +44,16 @@ 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_compat import (+ OpenAIToolNameCodec,+ openai_replay_scope,+)+from free_claude_code.providers.openai_responses import (+ ResponsesEventDecoder,+ ResponsesRequestEncodingError,+ ResponsesStreamFailure,+ build_responses_request_body,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -96,13 +105,18 @@ class OpenAICodexProvider(BaseProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:"""Validate and adapt the private Codex request before upstream I/O."""- self._build_body(request, reasoning=reasoning)+ self._build_body(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ )async def cleanup(self) -> None:"""Close only provider-owned transport resources."""@@ -175,9 +189,10 @@ class OpenAICodexProvider(BaseProvider):def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,@@ -185,24 +200,37 @@ class OpenAICodexProvider(BaseProvider):"""Stream private Responses output as canonical inference events."""tool_names = OpenAIToolNameCodec.from_request(request)- body = self._build_body(request, reasoning=reasoning)+ replay_scope = self._replay_scope(provider_model)+ body = self._build_body(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ )return self._run_stream(body,input_tokens=input_tokens,request_id=request_id,response_model=response_model or request.model,tool_names=tool_names,+ replay_scope=replay_scope,)- @staticmethoddef _build_body(- request: MessagesRequest,+ self,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> dict[str, Any]:try:- body = build_responses_provider_request(request, reasoning=reasoning)- except ResponsesConversionError as exc:+ body = build_responses_request_body(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=self._replay_scope(provider_model),+ )+ except (ResponsesConversionError, ResponsesRequestEncodingError) as exc:raise InvalidRequestError(str(exc)) from exc# The private Codex backend rejects these public Responses fields.# Codex itself omits the output cap and uses separate internal metadata.@@ -210,6 +238,14 @@ class OpenAICodexProvider(BaseProvider):body.pop("metadata", None)return body+ @staticmethod+ def _replay_scope(provider_model: str) -> ReplayCompatibilityScope:+ return openai_replay_scope(+ "openai",+ provider_model,+ replay_format="codex-responses",+ )+async def _run_stream(self,body: dict[str, Any],@@ -218,6 +254,7 @@ class OpenAICodexProvider(BaseProvider):request_id: str | None,response_model: str,tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope,) -> AsyncIterator[InferenceEvent]:execution = self._admission.start_execution(request_id=request_id)provider_stream = self._run_stream_execution(@@ -226,6 +263,7 @@ class OpenAICodexProvider(BaseProvider):request_id=request_id,response_model=response_model,tool_names=tool_names,+ replay_scope=replay_scope,execution=execution,)try:@@ -250,6 +288,7 @@ class OpenAICodexProvider(BaseProvider):request_id: str | None,response_model: str,tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope,execution: ProviderExecution,) -> AsyncIterator[InferenceEvent]:"""Run one Codex execution while retaining Responses transport ownership."""@@ -276,6 +315,7 @@ class OpenAICodexProvider(BaseProvider):model=response_model,input_tokens=input_tokens,tool_names=tool_names,+ replay_scope=replay_scope,)for event in stream.start():for held in recovery.push(event):diff --git a/src/free_claude_code/providers/openai_compat/__init__.py b/src/free_claude_code/providers/openai_compat/__init__.pynew file mode 100644index 00000000..7c3af6bb--- /dev/null+++ b/src/free_claude_code/providers/openai_compat/__init__.py@@ -0,0 +1,15 @@+"""Shared upstream OpenAI transport helpers."""++from .replay import openai_replay_scope+from .tool_names import (+ OPENAI_TOOL_NAME_MAX_LENGTH,+ OpenAIToolIdentity,+ OpenAIToolNameCodec,+)++__all__ = [+ "OPENAI_TOOL_NAME_MAX_LENGTH",+ "OpenAIToolIdentity",+ "OpenAIToolNameCodec",+ "openai_replay_scope",+]diff --git a/src/free_claude_code/providers/openai_compat/replay.py b/src/free_claude_code/providers/openai_compat/replay.pynew file mode 100644index 00000000..a205d0b3--- /dev/null+++ b/src/free_claude_code/providers/openai_compat/replay.py@@ -0,0 +1,18 @@+"""Route-scoped replay identity for OpenAI-compatible transports."""++import hashlib++from free_claude_code.core.inference import ReplayCompatibilityScope+++def openai_replay_scope(+ provider_identity: str,+ provider_model: str,+ *,+ replay_format: str,+) -> ReplayCompatibilityScope:+ """Return an opaque deterministic scope for one replay-compatible route."""++ material = "\0".join((provider_identity, provider_model, replay_format))+ digest = hashlib.sha256(material.encode("utf-8")).hexdigest()+ return ReplayCompatibilityScope(f"openai-{digest}")diff --git a/src/free_claude_code/providers/openai_compat/tool_names.py b/src/free_claude_code/providers/openai_compat/tool_names.pynew file mode 100644index 00000000..e7e1e1ff--- /dev/null+++ b/src/free_claude_code/providers/openai_compat/tool_names.py@@ -0,0 +1,173 @@+"""Request-scoped reversible tool identity for OpenAI transports."""++import hashlib+import re+from collections import Counter+from collections.abc import Iterable+from dataclasses import dataclass++from free_claude_code.core.inference import (+ CustomTool,+ InferenceRequest,+ ToolCallItem,+ ToolCallKind,+ ToolChoiceMode,+)++OPENAI_TOOL_NAME_MAX_LENGTH = 64+_ALIAS_DIGEST_LENGTH = 16+_PORTABLE_TOOL_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")+_INVALID_TOOL_NAME_CHARACTERS = re.compile(r"[^A-Za-z0-9_-]+")+++@dataclass(frozen=True, slots=True)+class OpenAIToolIdentity:+ """Canonical tool identity represented by one upstream wire name."""++ kind: ToolCallKind+ name: str+ namespace: str | None = None+++@dataclass(frozen=True, slots=True)+class OpenAIToolNameCodec:+ """Map canonical identities to deterministic OpenAI-compatible names."""++ _identity_to_wire: dict[OpenAIToolIdentity, str]+ _wire_to_identity: dict[str, OpenAIToolIdentity]+ _aliased_names: frozenset[str]++ @classmethod+ def from_request(cls, request: InferenceRequest) -> OpenAIToolNameCodec:+ """Build the codec from definitions, choice, and prior calls."""++ identities: list[OpenAIToolIdentity] = [+ OpenAIToolIdentity(+ ToolCallKind.CUSTOM+ if isinstance(tool, CustomTool)+ else ToolCallKind.FUNCTION,+ tool.name,+ tool.namespace,+ )+ for tool in request.tools+ ]+ choice = request.tool_choice+ if choice is not None and choice.mode is ToolChoiceMode.SPECIFIC:+ if choice.kind is None or choice.name is None:+ raise ValueError("specific tool choice is missing its identity")+ identities.append(+ OpenAIToolIdentity(choice.kind, choice.name, choice.namespace)+ )+ identities.extend(+ OpenAIToolIdentity(item.kind, item.name, item.namespace)+ for item in request.items+ if isinstance(item, ToolCallItem)+ )+ return cls.from_identities(identities)++ @classmethod+ def from_names(cls, names: Iterable[str]) -> OpenAIToolNameCodec:+ """Build function-tool identities for compatibility-focused unit tests."""++ return cls.from_identities(+ OpenAIToolIdentity(ToolCallKind.FUNCTION, name) for name in names+ )++ @classmethod+ def from_identities(+ cls,+ identities: Iterable[OpenAIToolIdentity],+ ) -> OpenAIToolNameCodec:+ unique = sorted(+ set(identities),+ key=lambda identity: (+ identity.namespace or "",+ identity.name,+ identity.kind.value,+ ),+ )+ candidates = [_readable_identity(identity) for identity in unique]+ counts = Counter(candidates)+ reserved: set[str] = set()+ identity_to_wire: dict[OpenAIToolIdentity, str] = {}+ wire_to_identity: dict[str, OpenAIToolIdentity] = {}+ aliased: set[str] = set()+ for identity, candidate in zip(unique, candidates, strict=True):+ if (+ counts[candidate] == 1+ and _PORTABLE_TOOL_NAME.fullmatch(candidate)+ and candidate not in reserved+ ):+ wire_name = candidate+ else:+ wire_name = _unique_alias(identity, candidate, reserved)+ aliased.add(wire_name)+ reserved.add(wire_name)+ identity_to_wire[identity] = wire_name+ wire_to_identity[wire_name] = identity+ return cls(identity_to_wire, wire_to_identity, frozenset(aliased))++ @property+ def has_aliases(self) -> bool:+ return bool(self._aliased_names)++ def encode(+ self,+ name: str,+ *,+ kind: ToolCallKind = ToolCallKind.FUNCTION,+ namespace: str | None = None,+ ) -> str:+ identity = OpenAIToolIdentity(kind, name, namespace)+ return self._identity_to_wire.get(identity, _readable_identity(identity))++ def decode_identity(self, wire_name: str) -> OpenAIToolIdentity:+ return self._wire_to_identity.get(+ wire_name,+ OpenAIToolIdentity(ToolCallKind.FUNCTION, wire_name),+ )++ def decode(self, wire_name: str) -> str:+ """Return the canonical name for one known wire identity."""++ return self.decode_identity(wire_name).name++ def is_alias(self, value: str) -> bool:+ return value in self._aliased_names++ def is_unchanged_name(self, value: str) -> bool:+ return value in self._wire_to_identity and value not in self._aliased_names++ def is_alias_prefix(self, value: str) -> bool:+ return bool(value) and any(+ alias != value and alias.startswith(value) for alias in self._aliased_names+ )+++def _readable_identity(identity: OpenAIToolIdentity) -> str:+ if identity.namespace:+ return f"{identity.namespace}__{identity.name}"+ return identity.name+++def _unique_alias(+ identity: OpenAIToolIdentity,+ candidate: str,+ reserved: set[str],+) -> str:+ readable = _INVALID_TOOL_NAME_CHARACTERS.sub("_", candidate).strip("_-") or "tool"+ max_readable_length = OPENAI_TOOL_NAME_MAX_LENGTH - _ALIAS_DIGEST_LENGTH - 1+ readable = readable[:max_readable_length].rstrip("_-") or "tool"+ identity_key = "\0".join(+ (identity.kind.value, identity.namespace or "", identity.name)+ )+ attempt = 0+ while True:+ digest_input = identity_key if attempt == 0 else f"{identity_key}\0{attempt}"+ digest = hashlib.sha256(digest_input.encode("utf-8")).hexdigest()[+ :_ALIAS_DIGEST_LENGTH+ ]+ alias = f"{readable}_{digest}"+ if alias not in reserved:+ return alias+ attempt += 1diff --git a/src/free_claude_code/providers/openai_responses/__init__.py b/src/free_claude_code/providers/openai_responses/__init__.pyindex 79eb5d63..639ed27c 100644--- a/src/free_claude_code/providers/openai_responses/__init__.py+++ b/src/free_claude_code/providers/openai_responses/__init__.py@@ -1,5 +1,13 @@"""Standard OpenAI Responses provider transport."""+from .events import ResponsesEventDecoder, ResponsesStreamFailure+from .request_codec import ResponsesRequestEncodingError, build_responses_request_bodyfrom .transport import OpenAIResponsesTransport-__all__ = ["OpenAIResponsesTransport"]+__all__ = [+ "OpenAIResponsesTransport",+ "ResponsesEventDecoder",+ "ResponsesRequestEncodingError",+ "ResponsesStreamFailure",+ "build_responses_request_body",+]diff --git a/src/free_claude_code/core/openai_responses/provider_events.py b/src/free_claude_code/providers/openai_responses/events.pysimilarity index 85%rename from src/free_claude_code/core/openai_responses/provider_events.pyrename to src/free_claude_code/providers/openai_responses/events.pyindex 21307737..4c58c3ad 100644--- a/src/free_claude_code/core/openai_responses/provider_events.py+++ b/src/free_claude_code/providers/openai_responses/events.py@@ -3,7 +3,6 @@from collections.abc import Mappingfrom dataclasses import dataclass-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.inference import (FinishReason,InferenceEvent,@@ -13,9 +12,12 @@ from free_claude_code.core.inference import (ReplayArtifactKind,ReplayArtifactOrigin,ReplayAttachment,+ ReplayCompatibilityScope,TokenMeasurement,+ ToolCallKind,UsageSource,)+from free_claude_code.providers.openai_compat import OpenAIToolNameCodecclass ResponsesStreamFailure(RuntimeError):@@ -32,6 +34,8 @@ class _ToolState:tool_index: intcall_id: strname: str+ kind: ToolCallKind+ namespace: str | Nonestarted: bool = Falsereceived_delta: bool = Falsestopped: bool = False@@ -47,11 +51,13 @@ class ResponsesEventDecoder:model: str,input_tokens: int,tool_names: OpenAIToolNameCodec | None = None,+ replay_scope: ReplayCompatibilityScope,) -> None:self.ledger = InferenceStreamLedger(response_id, model, input_tokens)self.completed = Falseself.generated_output = Falseself._tool_names = tool_names or OpenAIToolNameCodec.from_names(())+ self._replay_scope = replay_scopeself._tools: dict[str, _ToolState] = {}self._encrypted_reasoning: dict[str, str] = {}@@ -70,7 +76,10 @@ class ResponsesEventDecoder:return self._reasoning_delta(data)if event_type == "response.output_text.delta":return self._text_delta(data)- if event_type == "response.function_call_arguments.delta":+ if event_type in {+ "response.function_call_arguments.delta",+ "response.custom_tool_call_input.delta",+ }:return self._tool_delta(data)if event_type == "response.output_item.done":return self._item_done(data)@@ -85,11 +94,18 @@ class ResponsesEventDecoder:if not isinstance(item, dict):return []item_id = _string(item.get("id"))- if item.get("type") == "function_call" and item_id:+ if item.get("type") in {"function_call", "custom_tool_call"} and item_id:+ identity = self._tool_names.decode_identity(_string(item.get("name")))self._tools[item_id] = _ToolState(tool_index=len(self._tools),call_id=_string(item.get("call_id")) or item_id,- name=self._tool_names.decode(_string(item.get("name"))),+ name=identity.name,+ kind=(+ ToolCallKind.CUSTOM+ if item.get("type") == "custom_tool_call"+ else identity.kind+ ),+ namespace=identity.namespace,)if item.get("type") == "reasoning" and item_id:encrypted = item.get("encrypted_content")@@ -126,6 +142,8 @@ class ResponsesEventDecoder:tool_index=len(self._tools),call_id=item_id,name="",+ kind=ToolCallKind.FUNCTION,+ namespace=None,)self._tools[item_id] = stateevents = list(self.ledger.close_content_blocks())@@ -142,20 +160,32 @@ class ResponsesEventDecoder:return []item_type = item.get("type")item_id = _string(item.get("id"))- if item_type == "function_call":+ if item_type in {"function_call", "custom_tool_call"}:state = self._tools.get(item_id)if state is None:+ identity = self._tool_names.decode_identity(_string(item.get("name")))state = _ToolState(tool_index=len(self._tools),call_id=_string(item.get("call_id")) or item_id,- name=self._tool_names.decode(_string(item.get("name"))),+ name=identity.name,+ kind=(+ ToolCallKind.CUSTOM+ if item_type == "custom_tool_call"+ else identity.kind+ ),+ namespace=identity.namespace,)self._tools[item_id] = stateif not state.name:- state.name = self._tool_names.decode(_string(item.get("name")))+ identity = self._tool_names.decode_identity(_string(item.get("name")))+ state.name = identity.name+ state.kind = identity.kind+ state.namespace = identity.namespaceevents = list(self.ledger.close_content_blocks())events.extend(self._ensure_tool_started(state))- arguments = item.get("arguments")+ arguments = item.get(+ "input" if item_type == "custom_tool_call" else "arguments"+ )if not state.received_delta and isinstance(arguments, str) and arguments:events.append(self.ledger.emit_tool_delta(state.tool_index, arguments))self.generated_output = True@@ -176,6 +206,7 @@ class ResponsesEventDecoder:kind=ReplayArtifactKind.ENCRYPTED_REASONING,attachment=ReplayAttachment.REASONING,payload=encrypted,+ scope=self._replay_scope,)))@@ -193,6 +224,8 @@ class ResponsesEventDecoder:state.tool_index,state.call_id,state.name,+ kind=state.kind,+ namespace=state.namespace,)]diff --git a/src/free_claude_code/providers/openai_responses/request_codec.py b/src/free_claude_code/providers/openai_responses/request_codec.pynew file mode 100644index 00000000..3349e070--- /dev/null+++ b/src/free_claude_code/providers/openai_responses/request_codec.py@@ -0,0 +1,349 @@+"""Encode canonical inference requests for an OpenAI Responses upstream."""++import json+from collections.abc import Mapping, Sequence++from free_claude_code.core.inference import (+ Base64MediaSource,+ CustomTool,+ DocumentContent,+ FunctionTool,+ ImageContent,+ InferenceItem,+ InferenceRequest,+ InstructionItem,+ MessageItem,+ MessageRole,+ ReasoningItem,+ RefusalContent,+ ReplayAttachment,+ ReplayCompatibilityScope,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolChoiceMode,+ ToolResultItem,+ UrlMediaSource,+ replay_payload_text,+ thaw_json,+ thaw_json_object,+)+from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec+++class ResponsesRequestEncodingError(ValueError):+ """Canonical semantics cannot be represented by Responses without loss."""+++def build_responses_request_body(+ request: InferenceRequest,+ *,+ provider_model: str,+ reasoning: ReasoningPolicy,+ tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope,+) -> dict[str, object]:+ """Build one stateless Responses request from canonical values."""++ _validate_request(request)+ instructions: list[str] = []+ input_items: list[dict[str, object]] = []+ for items in _turns(request.items):+ for item in items:+ if isinstance(item, InstructionItem):+ _require_no_cache_control(item.cache_control, "instruction")+ instructions.append(item.text)+ elif isinstance(item, MessageItem):+ input_items.append(_message_item(item))+ elif isinstance(item, ReasoningItem):+ input_items.append(_reasoning_item(item, replay_scope=replay_scope))+ elif isinstance(item, ToolCallItem):+ input_items.append(+ _tool_call_item(+ item,+ tool_names=tool_names,+ replay_scope=replay_scope,+ )+ )+ elif isinstance(item, ToolResultItem):+ input_items.append(_tool_result_item(item))++ if not input_items:+ raise ResponsesRequestEncodingError(+ "OpenAI Responses requires at least one conversational input item"+ )++ body: dict[str, object] = {+ "model": provider_model,+ "input": input_items,+ "stream": True,+ "store": False,+ "include": ["reasoning.encrypted_content"],+ }+ if instructions:+ body["instructions"] = "\n\n".join(instructions)+ if request.max_output_tokens is not None:+ body["max_output_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"] = thaw_json_object(request.metadata)+ if request.tools:+ body["tools"] = [+ _tool_definition(tool, tool_names=tool_names) for tool in request.tools+ ]+ if request.tool_choice is not None:+ body["tool_choice"] = _tool_choice(request, tool_names=tool_names)+ elif request.tools:+ body["tool_choice"] = "auto"+ if request.parallel_tool_calls is not None:+ body["parallel_tool_calls"] = request.parallel_tool_calls+ if config := _reasoning_config(reasoning):+ body["reasoning"] = config+ return body+++def _validate_request(request: InferenceRequest) -> None:+ unsupported: list[str] = []+ if request.stop_sequences:+ unsupported.append("stop_sequences")+ if request.top_k is not None:+ unsupported.append("top_k")+ if request.extensions:+ unsupported.append("extensions")+ if unsupported:+ raise ResponsesRequestEncodingError(+ f"OpenAI Responses cannot represent these canonical fields: {unsupported}"+ )+++def _turns(items: tuple[InferenceItem, ...]) -> list[list[InferenceItem]]:+ turns: list[list[InferenceItem]] = []+ turn_indexes: dict[str, int] = {}+ top_level: list[InferenceItem] = []+ for item in items:+ turn_id = item.turn_id+ if turn_id is None:+ top_level.append(item)+ continue+ index = turn_indexes.get(turn_id)+ if index is None:+ index = len(turns)+ turn_indexes[turn_id] = index+ turns.append([])+ turns[index].append(item)+ return ([top_level] if top_level else []) + turns+++def _message_item(item: MessageItem) -> dict[str, object]:+ content: list[dict[str, object]] = []+ for part in item.content:+ if isinstance(part, TextContent):+ _require_no_cache_control(part.cache_control, "message text")+ content.append(+ {+ "type": (+ "input_text" if item.role is MessageRole.USER else "output_text"+ ),+ "text": part.text,+ }+ )+ elif isinstance(part, RefusalContent):+ if item.role is MessageRole.USER:+ content.append({"type": "input_text", "text": part.refusal})+ else:+ content.append({"type": "refusal", "refusal": part.refusal})+ elif isinstance(part, ImageContent):+ if item.role is not MessageRole.USER:+ raise ResponsesRequestEncodingError(+ "Responses cannot replay assistant image content"+ )+ _require_no_cache_control(part.cache_control, "image")+ content.append({"type": "input_image", "image_url": _image_url(part)})+ elif isinstance(part, DocumentContent):+ raise ResponsesRequestEncodingError(+ "Responses transport does not support canonical document content"+ )+ return {"type": "message", "role": item.role.value, "content": content}+++def _image_url(content: ImageContent) -> str:+ if isinstance(content.source, UrlMediaSource):+ return content.source.url+ if isinstance(content.source, Base64MediaSource):+ return f"data:{content.source.media_type};base64,{content.source.data}"+ raise ResponsesRequestEncodingError("unsupported canonical image source")+++def _reasoning_item(+ item: ReasoningItem,+ *,+ replay_scope: ReplayCompatibilityScope,+) -> dict[str, object]:+ result: dict[str, object] = {+ "type": "reasoning",+ "summary": (+ [{"type": "summary_text", "text": item.reasoning}] if item.reasoning else []+ ),+ }+ matching = [+ artifact+ for artifact in item.artifacts+ if artifact.attachment is ReplayAttachment.REASONING+ and artifact.scope == replay_scope+ ]+ if matching:+ if len(matching) != 1:+ raise ResponsesRequestEncodingError(+ "Responses encrypted reasoning accepts one scoped replay artifact"+ )+ result["encrypted_content"] = replay_payload_text(matching[0])+ return result+++def _tool_call_item(+ item: ToolCallItem,+ *,+ tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope,+) -> dict[str, object]:+ if any(+ artifact.scope == replay_scope+ and artifact.attachment is ReplayAttachment.TOOL_CALL+ for artifact in item.artifacts+ ):+ raise ResponsesRequestEncodingError(+ "Responses has no standard tool-call replay carrier"+ )+ name = tool_names.encode(+ item.name,+ kind=item.kind,+ namespace=item.namespace,+ )+ if item.kind is ToolCallKind.CUSTOM:+ custom_input = thaw_json(item.input)+ return {+ "type": "custom_tool_call",+ "call_id": item.call_id,+ "name": name,+ "input": (+ custom_input+ if isinstance(custom_input, str)+ else json.dumps(custom_input, ensure_ascii=False, separators=(",", ":"))+ ),+ }+ return {+ "type": "function_call",+ "call_id": item.call_id,+ "name": name,+ "arguments": json.dumps(+ thaw_json(item.input), ensure_ascii=False, separators=(",", ":")+ ),+ }+++def _tool_result_item(item: ToolResultItem) -> dict[str, object]:+ return {+ "type": "function_call_output",+ "call_id": item.call_id,+ "output": _serialize_tool_result(item.content),+ }+++def _serialize_tool_result(content: JsonValue) -> str:+ if content is None:+ return ""+ if isinstance(content, str):+ return content+ if isinstance(content, Mapping):+ return json.dumps(thaw_json(content), ensure_ascii=False)+ if isinstance(content, Sequence):+ parts: list[str] = []+ for value in content:+ if isinstance(value, Mapping) and value.get("type") == "text":+ text = value.get("text")+ parts.append(text if isinstance(text, str) else str(text or ""))+ elif isinstance(value, Mapping | Sequence) and not isinstance(value, str):+ parts.append(json.dumps(thaw_json(value), ensure_ascii=False))+ else:+ parts.append(str(value))+ return "\n".join(parts)+ return str(content)+++def _tool_definition(+ tool: FunctionTool | CustomTool,+ *,+ tool_names: OpenAIToolNameCodec,+) -> dict[str, object]:+ kind = (+ ToolCallKind.CUSTOM if isinstance(tool, CustomTool) else ToolCallKind.FUNCTION+ )+ name = tool_names.encode(tool.name, kind=kind, namespace=tool.namespace)+ _require_no_cache_control(tool.cache_control, "tool definition")+ if isinstance(tool, FunctionTool):+ return {+ "type": "function",+ "name": name,+ "description": tool.description,+ "parameters": thaw_json_object(tool.input_schema),+ "strict": tool.strict,+ }+ result: dict[str, object] = {+ "type": "custom",+ "name": name,+ "description": tool.description,+ "format": {"type": tool.format.type.value},+ }+ custom_format = result["format"]+ if isinstance(custom_format, dict):+ if tool.format.syntax is not None:+ custom_format["syntax"] = tool.format.syntax+ if tool.format.definition is not None:+ custom_format["definition"] = tool.format.definition+ return result+++def _tool_choice(+ request: InferenceRequest,+ *,+ tool_names: OpenAIToolNameCodec,+) -> object:+ choice = request.tool_choice+ if choice is None or choice.mode is ToolChoiceMode.AUTO:+ return "auto"+ if choice.mode is ToolChoiceMode.NONE:+ return "none"+ if choice.mode is ToolChoiceMode.REQUIRED:+ return "required"+ if choice.name is None or choice.kind is None:+ raise ResponsesRequestEncodingError("specific tool choice has no identity")+ return {+ "type": "custom" if choice.kind is ToolCallKind.CUSTOM else "function",+ "name": tool_names.encode(+ choice.name,+ kind=choice.kind,+ namespace=choice.namespace,+ ),+ }+++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 {}+++def _require_no_cache_control(value: object, path: str) -> None:+ if value is not None:+ raise ResponsesRequestEncodingError(+ f"Responses cannot represent {path} cache_control"+ )diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex 38c2bd30..f6672bf4 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -11,16 +11,15 @@ from openai.types.responses import ResponseStreamEventfrom openai.types.responses.response_create_params import ResponseCreateParamsStreamingfrom free_claude_code.application.errors import InvalidRequestError-from 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.inference import InferenceEvent+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ ReplayCompatibilityScope,+)from free_claude_code.core.openai_responses import (ResponsesConversionError,- ResponsesEventDecoder,- ResponsesStreamFailure,- build_responses_provider_request,)from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.core.trace import trace_event@@ -35,11 +34,18 @@ 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_compat import (+ OpenAIToolNameCodec,+ openai_replay_scope,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,)+from .events import ResponsesEventDecoder, ResponsesStreamFailure+from .request_codec import ResponsesRequestEncodingError, build_responses_request_body+class _TruncatedResponsesStream(RetryableProviderProtocolError):"""A Responses stream ended without a terminal lifecycle event."""@@ -79,43 +85,66 @@ class OpenAIResponsesTransport:def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:- self._build_body(request, reasoning=reasoning)+ self._build_body(request, provider_model=provider_model, reasoning=reasoning)def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,input_tokens: int,request_id: str | None,response_model: str,reasoning: ReasoningPolicy,) -> AsyncIterator[InferenceEvent]:- body = self._build_body(request, reasoning=reasoning)+ body = self._build_body(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ )tool_names = OpenAIToolNameCodec.from_request(request)+ replay_scope = openai_replay_scope(+ self._provider_name,+ provider_model,+ replay_format="responses",+ )return self._run_stream(body,input_tokens=input_tokens,request_id=request_id,response_model=response_model,tool_names=tool_names,+ replay_scope=replay_scope,)- @staticmethoddef _build_body(- request: MessagesRequest,+ self,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> ResponseCreateParamsStreaming:try:return cast(ResponseCreateParamsStreaming,- build_responses_provider_request(request, reasoning=reasoning),+ build_responses_request_body(+ request,+ provider_model=provider_model,+ reasoning=reasoning,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=openai_replay_scope(+ self._provider_name,+ provider_model,+ replay_format="responses",+ ),+ ),)- except ResponsesConversionError as exc:+ except (ResponsesConversionError, ResponsesRequestEncodingError) as exc:raise InvalidRequestError(str(exc)) from excasync def _run_stream(@@ -126,6 +155,7 @@ class OpenAIResponsesTransport:request_id: str | None,response_model: str,tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope,) -> AsyncIterator[InferenceEvent]:execution = self._admission.start_execution(request_id=request_id)provider_stream = self._run_execution(@@ -134,6 +164,7 @@ class OpenAIResponsesTransport:request_id=request_id,response_model=response_model,tool_names=tool_names,+ replay_scope=replay_scope,execution=execution,)try:@@ -158,6 +189,7 @@ class OpenAIResponsesTransport:request_id: str | None,response_model: str,tool_names: OpenAIToolNameCodec,+ replay_scope: ReplayCompatibilityScope,execution: ProviderExecution,) -> AsyncIterator[InferenceEvent]:recovery = RecoveryController()@@ -180,6 +212,7 @@ class OpenAIResponsesTransport:model=response_model,input_tokens=input_tokens,tool_names=tool_names,+ replay_scope=replay_scope,)for event in stream_adapter.start():for held in recovery.push(event):diff --git a/src/free_claude_code/providers/opencode/provider.py b/src/free_claude_code/providers/opencode/provider.pyindex d48f116d..298d5889 100644--- a/src/free_claude_code/providers/opencode/provider.py+++ b/src/free_claude_code/providers/opencode/provider.py@@ -8,9 +8,7 @@ import httpxfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.inference import InferenceEvent+from free_claude_code.core.inference import InferenceEvent, InferenceRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -20,6 +18,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,+ ReasoningReplayMode,)from free_claude_code.providers.openai_responses import OpenAIResponsesTransport@@ -121,32 +120,42 @@ class OpenCodeProvider(OpenAIChatProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:"""Validate synchronously when a route snapshot is already warm."""snapshot = self._catalog.current_snapshotif snapshot is None:return- route = self._require_route(snapshot, request.model)- routed = _routed_request(request, route)+ route = self._require_route(snapshot, provider_model)if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_stream(routed, reasoning=reasoning)+ self._responses.preflight_stream(+ request,+ provider_model=route.upstream_model_id,+ reasoning=reasoning,+ )return- super().preflight_stream(routed, reasoning=reasoning)+ super().preflight_stream(+ request,+ provider_model=route.upstream_model_id,+ reasoning=reasoning,+ )def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> AsyncIterator[InferenceEvent]:return self._dispatch_stream(request,+ provider_model=provider_model,input_tokens=input_tokens,request_id=request_id,response_model=response_model or request.model,@@ -155,31 +164,41 @@ class OpenCodeProvider(OpenAIChatProvider):async def _dispatch_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,input_tokens: int,request_id: str | None,response_model: str,reasoning: ReasoningPolicy,) -> AsyncIterator[InferenceEvent]:snapshot = await self._catalog.snapshot(request_id=request_id)- route = self._require_route(snapshot, request.model)- routed = _routed_request(request, route)+ route = self._require_route(snapshot, provider_model)selected_stream: AsyncIterator[InferenceEvent] | None = Nonetry:if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_stream(routed, reasoning=reasoning)+ self._responses.preflight_stream(+ request,+ provider_model=route.upstream_model_id,+ reasoning=reasoning,+ )selected_stream = self._responses.stream_response(- routed,+ request,+ provider_model=route.upstream_model_id,input_tokens=input_tokens,request_id=request_id,response_model=response_model,reasoning=reasoning,)else:- super().preflight_stream(routed, reasoning=reasoning)+ super().preflight_stream(+ request,+ provider_model=route.upstream_model_id,+ reasoning=reasoning,+ )selected_stream = super().stream_response(- routed,+ request,+ provider_model=route.upstream_model_id,input_tokens=input_tokens,request_id=request_id,response_model=response_model,@@ -227,13 +246,3 @@ def create_opencode_provider(admission=admission,catalog_client=catalog_client,)---def _routed_request(- request: MessagesRequest,- route: OpenCodeModelRoute,-) -> MessagesRequest:- return request.model_copy(- update={"model": route.upstream_model_id},- deep=True,- )diff --git a/src/free_claude_code/providers/vertex/client.py b/src/free_claude_code/providers/vertex/client.pyindex 5eb207e5..4b156f48 100644--- a/src/free_claude_code/providers/vertex/client.py+++ b/src/free_claude_code/providers/vertex/client.py@@ -6,7 +6,6 @@ from typing import Anyimport httpxfrom free_claude_code.application.model_metadata import ProviderModelInfo-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.providers.admission import (ProviderAdmissionController,ProviderOperationKind,@@ -25,6 +24,7 @@ from free_claude_code.providers.model_listing import (from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatRequestPolicy,+ ReasoningReplayMode,)from .auth import GoogleAccessTokenProviderdiff --git a/tests/api/model_fallback_support.py b/tests/api/model_fallback_support.pyindex e01428ec..50d780ea 100644--- a/tests/api/model_fallback_support.py+++ b/tests/api/model_fallback_support.py@@ -8,9 +8,8 @@ from fastapi.testclient import TestClientfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.inference import InferenceEvent+from free_claude_code.core.inference import InferenceEvent, InferenceRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom tests.api.support import create_test_appfrom tests.inference_support import text_event_stream@@ -49,26 +48,28 @@ class ControlledFallbackProvider:def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:- del reasoning- self.preflight_models.append(request.model)+ del request, reasoning+ self.preflight_models.append(provider_model)if self._preflight_error is not None:raise self._preflight_errorasync def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,) -> AsyncIterator[InferenceEvent]:del input_tokens, request_id, reasoning- self.stream_models.append(request.model)+ self.stream_models.append(provider_model)public_model = response_model or request.modelself.response_models.append(public_model)try:diff --git a/tests/api/test_api.py b/tests/api/test_api.pyindex c2ed2a7b..640f5cac 100644--- a/tests/api/test_api.py+++ b/tests/api/test_api.py@@ -4,6 +4,15 @@ import pytestfrom fastapi.testclient import TestClientfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import (+ InferenceRequest,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MessageItem,+ MessageRole,+ TextContent,+)from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom tests.api.support import create_test_app@@ -161,7 +170,7 @@ def test_auto_mode_classifier_without_stream_returns_json(client: TestClient):assert body["type"] == "message"assert body["usage"] == {"input_tokens": 0, "output_tokens": 0}routed_request = _stream_response_calls[0][0][0]- assert routed_request.stream is False+ assert isinstance(routed_request, InferenceRequest)assert _stream_response_calls[0][1]["reasoning"] == ReasoningPolicy.off()@@ -261,13 +270,16 @@ def test_create_message_preserves_system_role_messages(client: TestClient):assert response.status_code == 200routed_request = _stream_response_calls[0][0][0]- assert [message.role for message in routed_request.messages] == [- "user",- "system",- "user",- ]- assert routed_request.messages[1].content == "system prompt"- assert routed_request.system is None+ assert routed_request.items == (+ MessageItem("turn_0", MessageRole.USER, (TextContent("context"),)),+ InstructionItem(+ text="system prompt",+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TRANSCRIPT,+ turn_id="turn_1",+ ),+ MessageItem("turn_2", MessageRole.USER, (TextContent("Hi"),)),+ )def test_model_mapping(client: TestClient):@@ -283,7 +295,8 @@ def test_model_mapping(client: TestClient):assert len(_stream_response_calls) == 1args = _stream_response_calls[0][0]kwargs = _stream_response_calls[0][1]- assert args[0].model != "claude-3-haiku-20240307"+ assert args[0].model == "claude-3-haiku-20240307"+ assert kwargs["provider_model"] != args[0].modelassert kwargs["reasoning"] == ReasoningPolicy.provider_default()diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.pyindex 7752b793..f84bd51b 100644--- a/tests/api/test_api_handlers.py+++ b/tests/api/test_api_handlers.py@@ -20,7 +20,13 @@ from free_claude_code.core.anthropic.models import (TokenCountRequest,)from free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.inference import InferenceEvent+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ InstructionItem,+ MessageItem,+ TextContent,+)from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom tests.inference_support import text_event_stream@@ -45,16 +51,20 @@ class FakeProvider:*,failure: ExecutionFailure | None = None,) -> None:- self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []- self.requests: list[MessagesRequest] = []+ self.preflight_calls: list[tuple[InferenceRequest, str, ReasoningPolicy]] = []+ self.requests: list[InferenceRequest] = []self.stream_kwargs: list[dict[str, Any]] = []self.events = text_event_stream("ok") if events is None else eventsself.failure = failuredef preflight_stream(- self, request: MessagesRequest, *, reasoning: ReasoningPolicy+ self,+ request: InferenceRequest,+ *,+ provider_model: str,+ reasoning: ReasoningPolicy,) -> None:- self.preflight_calls.append((request, reasoning))+ self.preflight_calls.append((request, provider_model, reasoning))async def cleanup(self) -> None:return None@@ -64,9 +74,10 @@ class FakeProvider:async def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,@@ -75,6 +86,7 @@ class FakeProvider:self.stream_kwargs.append({"input_tokens": input_tokens,+ "provider_model": provider_model,"request_id": request_id,"response_model": response_model,"reasoning": reasoning,@@ -126,7 +138,8 @@ async def test_messages_handler_passes_routed_request_and_stream_metadata() -> Nbody = await _streaming_body_text(response)assert "message_start" in body- assert provider.requests[0].model == "test-model"+ assert provider.requests[0].model == "nvidia_nim/test-model"+ assert provider.stream_kwargs[0]["provider_model"] == "test-model"assert provider.stream_kwargs[0]["input_tokens"] > 0assert provider.stream_kwargs[0]["request_id"].startswith("req_")assert provider.stream_kwargs[0]["response_model"] == "nvidia_nim/test-model"@@ -142,8 +155,9 @@ async def test_messages_handler_preflight_invalid_request_stays_http_error(class RejectPreflightProvider(FakeProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:raise InvalidRequestError("bad tool shape")@@ -266,9 +280,10 @@ async def test_messages_handler_stream_false_provider_exception_keeps_status() -class FailingProvider(FakeProvider):async def stream_response(self,- request: Any,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,@@ -277,6 +292,7 @@ async def test_messages_handler_stream_false_provider_exception_keeps_status() -self.stream_kwargs.append({"input_tokens": input_tokens,+ "provider_model": provider_model,"request_id": request_id,"response_model": response_model,"reasoning": reasoning,@@ -339,12 +355,16 @@ async def test_messages_handler_normalizes_safety_classifier_policy(assert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.off()- assert provider.requests[0].model == "test-model"- assert provider.requests[0].system == system- assert provider.preflight_calls[0][0].stop_sequences is None- assert provider.requests[0].stop_sequences is None+ assert provider.requests[0].model == "nvidia_nim/test-model"+ assert provider.preflight_calls[0][1] == "test-model"+ assert any(+ isinstance(item, InstructionItem) and item.text == system+ for item in provider.requests[0].items+ )+ assert provider.preflight_calls[0][0].stop_sequences == ()+ assert provider.requests[0].stop_sequences == ()assert request.stop_sequences == [classifier_stop_sequence]assert _trace_events(trace_mock, "free_claude_code.api.route.safety_classifier_policy"@@ -387,9 +407,9 @@ async def test_messages_handler_preserves_thinking_for_non_classifier() -> None:assert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.provider_default()+ assert provider.preflight_calls[0][2] == ReasoningPolicy.provider_default()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()- assert provider.requests[0].stop_sequences == ["</severity>"]+ assert provider.requests[0].stop_sequences == ("</severity>",)assert (_trace_events(trace_mock,@@ -417,9 +437,9 @@ async def test_messages_handler_keeps_existing_no_thinking_for_classifier() -> Nassert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.off()- assert provider.requests[0].stop_sequences is None+ assert provider.requests[0].stop_sequences == ()assert request.stop_sequences == ["</block>"]assert _trace_events(trace_mock, "free_claude_code.api.route.safety_classifier_policy"@@ -455,8 +475,8 @@ async def test_messages_handler_forces_no_thinking_without_classifier_stop_hint(assert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()- assert provider.requests[0].stop_sequences is None+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()+ assert provider.requests[0].stop_sequences == ()assert _trace_events(trace_mock, "free_claude_code.api.route.safety_classifier_policy") == [@@ -490,13 +510,13 @@ async def test_messages_handler_preserves_unowned_classifier_stop_sequences() ->assert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()- assert provider.preflight_calls[0][0].stop_sequences == [+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()+ assert provider.preflight_calls[0][0].stop_sequences == ("custom","custom","tail",- ]- assert provider.requests[0].stop_sequences == ["custom", "custom", "tail"]+ )+ assert provider.requests[0].stop_sequences == ("custom", "custom", "tail")assert request.stop_sequences == original_stops@@ -522,6 +542,33 @@ async def test_messages_handler_optimization_intercepts_before_provider_executioprovider_resolver.assert_not_called()+async def test_invalid_shortcut_shaped_request_is_rejected_before_interception() -> (+ None+):+ provider_resolver = MagicMock()+ handler = MessagesHandler(Settings(), provider_resolver=provider_resolver)+ request = MessagesRequest.model_validate(+ {+ "model": "nvidia_nim/test-model",+ "max_tokens": 100,+ "messages": [{"role": "user", "content": "quota check"}],+ "client_extension": True,+ }+ )++ with (+ patch(+ "free_claude_code.api.handlers.messages.try_optimizations",+ side_effect=AssertionError("invalid request reached local interception"),+ ),+ pytest.raises(InvalidRequestError, match=r"request\.client_extension"),+ ):+ await handler.create(request)++ provider_resolver.assert_not_called()++@pytest.mark.asyncioasync def test_responses_handler_bypasses_message_only_optimizations() -> None:provider = FakeProvider()@@ -541,7 +588,14 @@ 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.requests[0].message_count == 1+ assert any(+ isinstance(item, MessageItem)+ and item.content+ and isinstance(item.content[0], TextContent)+ and item.content[0].text == "quota check"+ for item in provider.requests[0].items+ )@pytest.mark.asyncio@@ -561,7 +615,7 @@ 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.preflight_calls[0][2] == ReasoningPolicy.provider_default()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()assert (_trace_events(@@ -575,7 +629,7 @@ async def test_responses_handler_does_not_apply_safety_classifier_policy() -> Nodef test_token_count_handler_routes_and_counts_tokens() -> None:handler = TokenCountHandler(Settings(),- token_counter=lambda messages, system, tools: len(messages) + 41,+ token_counter=lambda request: request.message_count + 41,)with patch("free_claude_code.api.handlers.token_count.trace_event") as trace:diff --git a/tests/api/test_auth.py b/tests/api/test_auth.pyindex f4ebab44..9afbdb41 100644--- a/tests/api/test_auth.py+++ b/tests/api/test_auth.py@@ -19,7 +19,7 @@ def test_proxy_auth_requires_canonical_bearer_header():"messages": [{"role": "user", "content": "hello"}],}- with patch("free_claude_code.api.routes.get_token_count", return_value=1):+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=1):r = client.post("/v1/messages/count_tokens", json=payload)assert r.status_code == 401assert r.json() == {"detail": "Missing proxy authentication token"}@@ -59,7 +59,7 @@ def test_proxy_auth_ignores_conflicting_legacy_headers():"messages": [{"role": "user", "content": "hello"}],}- with patch("free_claude_code.api.routes.get_token_count", return_value=2):+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=2):r = client.post("/v1/messages/count_tokens",json=payload,@@ -99,7 +99,7 @@ def test_proxy_auth_token_normalizes_configured_whitespace():"messages": [{"role": "user", "content": "hello"}],}- with patch("free_claude_code.api.routes.get_token_count", return_value=3):+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=3):r = client.post("/v1/messages/count_tokens",json=payload,diff --git a/tests/api/test_execution_failure_contract.py b/tests/api/test_execution_failure_contract.pyindex 770a5b4c..015eb2e0 100644--- a/tests/api/test_execution_failure_contract.py+++ b/tests/api/test_execution_failure_contract.py@@ -9,11 +9,11 @@ import pytestfrom fastapi.testclient import TestClientfrom free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.inference import (InferenceEvent,+ InferenceRequest,InferenceStreamLedger,ResponseStarted,)@@ -79,22 +79,24 @@ class StalledProvider:def preflight_stream(self,- _request: MessagesRequest,+ _request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:- del reasoning+ del provider_model, reasoningasync def stream_response(self,- _request: MessagesRequest,+ _request: InferenceRequest,*,input_tokens: int,+ provider_model: str,request_id: str,response_model: str,reasoning: ReasoningPolicy,) -> AsyncIterator[InferenceEvent]:- del input_tokens, request_id, response_model, reasoning+ del input_tokens, provider_model, request_id, response_model, reasoningtry:await asyncio.Event().wait()yield ResponseStarted("response_unreachable", "test-model")diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.pyindex 04184cf1..00496103 100644--- a/tests/api/test_openai_responses.py+++ b/tests/api/test_openai_responses.py@@ -11,18 +11,26 @@ from free_claude_code.core.inference import (FinishReason,InferenceEvent,InferenceStreamLedger,+ MessageItem,+ MessageRole,+ ReasoningItem,ReplayArtifact,ReplayArtifactKind,ReplayArtifactOrigin,ReplayAttachment,ResponseStarted,+ TextContent,+ ToolCallItem,ToolCallKind,+ ToolChoiceMode,+ ToolResultItem,)from free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,ReasoningPolicy,)+from free_claude_code.core.replay_envelope import decode_replay_envelopefrom tests.api.support import create_test_appfrom tests.inference_support import reported_usage@@ -122,10 +130,12 @@ def test_create_response_stream_routes_through_provider()assert provider.preflight_stream.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 == "nvidia_nim/test-model"+ assert routed.items == (+ MessageItem("turn_0", MessageRole.USER, (TextContent("Hello"),)),+ )+ assert routed.max_output_tokens == 32+ assert provider.stream_kwargs[0]["provider_model"] == "test-model"assert provider.stream_kwargs[0]["request_id"] == response.headers["request-id"]@@ -182,7 +192,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_rejects_unknown_top_level_extensions_before_provider(responses_client: tuple[TestClient, FakeProvider],) -> None:client, provider = responses_client@@ -196,8 +206,51 @@ def test_create_response_accepts_unknown_top_level_extensions(},)- assert response.status_code == 200- assert provider.requests[0].messages[0].content == "Hello"+ assert response.status_code == 400+ assert "provider_extension" in response.json()["error"]["message"]+ assert provider.requests == []+++ "override",+ [+ {"store": True},+ {"previous_response_id": "resp_1"},+ {"include": []},+ {"prompt_cache_key": ""},+ {"reasoning": {"summary": "concise"}},+ {+ "tools": [{"type": "web_search"}],+ "tool_choice": "required",+ },+ {"tool_choice": {"type": "web_search"}},+ {"input": [{"type": "input_image", "image_url": "https://invalid"}]},+ ],+)+def test_invalid_responses_semantics_fail_before_provider_resolution(+ override: dict[str, object],+) -> None:+ provider = FakeProvider(_anthropic_text_stream("unused"))+ app = create_test_app()+ payload: dict[str, object] = {+ "model": "nvidia_nim/test-model",+ "input": "Hello",+ }+ payload.update(override)++ with (+ patch(+ "free_claude_code.api.routes.resolve_provider",+ return_value=provider,+ ) as resolve_provider,+ TestClient(app) as client,+ ):+ response = client.post("/v1/responses", json=payload)++ assert response.status_code == 400+ resolve_provider.assert_not_called()+ provider.preflight_stream.assert_not_called()+ assert provider.requests == []def test_create_response_pre_start_provider_error_returns_openai_error() -> None:@@ -284,7 +337,9 @@ def test_create_response_stream_bypasses_local_message_optimizations() -> None: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].items == (+ MessageItem("turn_0", MessageRole.USER, (TextContent("quota check"),)),+ )def test_create_response_stream_false_returns_openai_error(@@ -416,7 +471,9 @@ def test_create_response_malformed_provider_function_call_fails_stream() -> Nonedef test_create_response_accepts_codex_namespace_tool_request() -> None:- provider = FakeProvider(_anthropic_tool_stream(tool_name="mcp__node_repl__js"))+ provider = FakeProvider(+ _anthropic_tool_stream(tool_name="js", namespace="mcp__node_repl")+ )app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -451,7 +508,9 @@ def test_create_response_accepts_codex_namespace_tool_request() -> None:assert response.status_code == 200routed = provider.requests[0]- assert [tool.name for tool in routed.tools] == ["mcp__node_repl__js"]+ assert [(tool.name, tool.namespace) for tool in routed.tools] == [+ ("js", "mcp__node_repl")+ ]completed = parse_sse_text(response.text)[-1].data["response"]call = completed["output"][0]assert call["namespace"] == "mcp__node_repl"@@ -459,7 +518,9 @@ def test_create_response_accepts_codex_namespace_tool_request() -> None:def test_create_response_accepts_muse_code_request_shape() -> None:- provider = FakeProvider(_anthropic_tool_stream(tool_name="muse__read_file"))+ provider = FakeProvider(+ _anthropic_tool_stream(tool_name="read_file", namespace="muse")+ )app = create_test_app()with (patch("free_claude_code.api.routes.resolve_provider", return_value=provider),@@ -502,13 +563,16 @@ def test_create_response_accepts_muse_code_request_shape() -> None:assert response.status_code == 200routed = provider.requests[0]- assert routed.max_tokens == 64- assert routed.output_config == {"effort": "high"}+ assert routed.max_output_tokens == 64+ assert routed.reasoning.control is ReasoningControl.ON+ assert routed.reasoning.effort is ReasoningEffort.HIGHassert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy(- control=ReasoningControl.DEFAULT,+ control=ReasoningControl.ON,effort=ReasoningEffort.HIGH,)- assert [tool.name for tool in routed.tools] == ["muse__read_file"]+ assert [(tool.name, tool.namespace) for tool in routed.tools] == [+ ("read_file", "muse")+ ]completed = parse_sse_text(response.text)[-1].data["response"]call = completed["output"][0]assert call["namespace"] == "muse"@@ -520,6 +584,7 @@ def test_create_response_accepts_codex_custom_tool_request() -> None:_anthropic_tool_stream(tool_name="apply_patch",partial_json='{"input":"*** Begin Patch"}',+ kind=ToolCallKind.CUSTOM,))app = create_test_app()@@ -548,7 +613,10 @@ def test_create_response_accepts_codex_custom_tool_request() -> None:assert response.status_code == 200routed = provider.requests[0]assert [tool.name for tool in routed.tools] == ["apply_patch"]- assert routed.tool_choice == {"type": "tool", "name": "apply_patch"}+ assert routed.tool_choice is not None+ assert routed.tool_choice.mode is ToolChoiceMode.SPECIFIC+ assert routed.tool_choice.kind is ToolCallKind.CUSTOM+ assert routed.tool_choice.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"]@@ -637,16 +705,19 @@ def test_create_response_replays_prior_reasoning_as_reasoning_content() -> None:assert response.status_code == 200routed = 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"+ assert routed.items == (+ ReasoningItem("turn_0", "Need the tool."),+ ToolCallItem(+ turn_id="turn_0",+ call_id="call_1",+ kind=ToolCallKind.FUNCTION,+ name="echo",+ input={},+ ),+ ToolResultItem("turn_1", "call_1", "ok"),+ ReasoningItem("turn_2", "Use the result."),+ MessageItem("turn_3", MessageRole.USER, (TextContent("continue"),)),+ )def test_create_response_quarantines_malformed_prior_function_call() -> None:@@ -681,9 +752,10 @@ def test_create_response_quarantines_malformed_prior_function_call() -> None:assert response.status_code == 200routed = 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"+ assert routed.items == (+ MessageItem("turn_0", MessageRole.USER, (TextContent("hello"),)),+ MessageItem("turn_1", MessageRole.USER, (TextContent("continue"),)),+ )completed = parse_sse_text(response.text)[-1].data["response"]assert completed["output"][0]["content"][0]["text"] == "done"@@ -695,7 +767,7 @@ def test_create_response_quarantines_malformed_prior_function_call() -> None:({"effort": "low"},ReasoningPolicy(- control=ReasoningControl.DEFAULT,+ control=ReasoningControl.ON,effort=ReasoningEffort.LOW,),),@@ -723,8 +795,8 @@ def test_create_response_preserves_and_resolves_reasoning_effort(assert response.status_code == 200routed = provider.requests[0]- assert routed.thinking is None- assert routed.output_config == reasoning+ assert routed.reasoning.control is expected_policy.control+ assert routed.reasoning.effort is expected_policy.effortassert provider.stream_kwargs[0]["reasoning"] == expected_policyassert provider.preflight_stream.call_args.kwargs["reasoning"] == expected_policy@@ -747,16 +819,21 @@ def test_create_response_maps_redacted_thinking_to_encrypted_reasoning() -> Noneassert response.status_code == 200completed = 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 len(completed["output"]) == 1+ output = completed["output"][0]+ assert output["type"] == "reasoning"+ assert output["status"] == "completed"+ assert output["summary"] == []+ artifacts = decode_replay_envelope(+ output["encrypted_content"],+ attachment=ReplayAttachment.REASONING,+ )+ assert artifacts is not None+ assert len(artifacts) == 1+ assert artifacts[0].origin is ReplayArtifactOrigin.ANTHROPIC+ assert artifacts[0].kind is ReplayArtifactKind.REDACTED_THINKING+ assert artifacts[0].payload == "opaque-redacted"+ assert "content" not in outputdef test_create_response_unsupported_tool_returns_openai_error(@@ -776,7 +853,7 @@ def test_create_response_unsupported_tool_returns_openai_error(assert response.status_code == 400payload = response.json()assert payload["error"]["type"] == "invalid_request_error"- assert "Unsupported Responses tool type" in payload["error"]["message"]+ assert "tools[0].type" in payload["error"]["message"]def _anthropic_text_stream(@@ -806,6 +883,9 @@ def _anthropic_text_stream(def _anthropic_tool_stream(tool_name: str = "echo",partial_json: str = '{"value":"FCC"}',+ *,+ kind: ToolCallKind = ToolCallKind.FUNCTION,+ namespace: str | None = None,) -> list[InferenceEvent]:ledger = InferenceStreamLedger("response_test", "test-model", 3)events: list[InferenceEvent] = [ledger.start_response()]@@ -814,7 +894,8 @@ def _anthropic_tool_stream(0,"toolu_1",tool_name,- kind=ToolCallKind.FUNCTION,+ kind=kind,+ namespace=namespace,))events.append(ledger.emit_tool_delta(0, partial_json))diff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.pyindex a75d70dc..79bea775 100644--- a/tests/api/test_request_lifetime.py+++ b/tests/api/test_request_lifetime.py@@ -21,8 +21,11 @@ from free_claude_code.application.ports import (TaskController,)from free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import MessagesRequest-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ InferenceStreamLedger,+)from free_claude_code.core.reasoning import ReasoningPolicy@@ -386,22 +389,24 @@ class _ControlledProvider:def preflight_stream(self,- _request: MessagesRequest,+ _request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:- del reasoning+ del provider_model, reasoningasync def stream_response(self,- _request: MessagesRequest,+ _request: InferenceRequest,*,input_tokens: int,+ provider_model: str,request_id: str,response_model: str,reasoning: ReasoningPolicy,) -> AsyncIterator[InferenceEvent]:- del input_tokens, response_model, reasoning+ del input_tokens, provider_model, response_model, reasoningself.request_ids.append(request_id)try:for chunk in self._chunks:diff --git a/tests/api/test_request_utils.py b/tests/api/test_request_utils.pyindex 9312238e..c2a8bc38 100644--- a/tests/api/test_request_utils.py+++ b/tests/api/test_request_utils.py@@ -10,11 +10,27 @@ from free_claude_code.api.detection import (is_quota_check_request,is_title_generation_request,)-from free_claude_code.core.anthropic import get_token_countfrom free_claude_code.core.anthropic.models import (Message,MessagesRequest,- SystemContent,+)+from free_claude_code.core.inference import (+ Base64MediaSource,+ FunctionTool,+ ImageContent,+ InferenceItem,+ InferenceRequest,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MessageItem,+ MessageRole,+ ReasoningItem,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolResultItem,+ get_inference_token_count,)@@ -326,240 +342,145 @@ class TestPrefixDetectionRequest:assert command == "ls -la"-class TestGetTokenCount:- """Tests for get_token_count function."""-- def test_empty_messages(self):- """Test token count with empty messages."""- count = get_token_count([])- assert count >= 1 # Returns max(1, tokens)-- def test_simple_message(self):- """Test token count with simple text message."""- msg = MagicMock()- msg.content = "Hello world"-- count = get_token_count([msg])- assert count > 0- # "Hello world" is ~2-3 tokens plus overhead- assert count >= 3-- def test_special_token_text_is_counted_as_plain_text(self):- """Tiktoken special-token strings should not break token estimates."""- msg = MagicMock()- msg.content = "<|endoftext|>"-- count = get_token_count([msg], system="<|endoftext|>")- assert count > 0-- def test_message_with_system_prompt(self):- """Test token count includes system prompt."""- msg = MagicMock()- msg.content = "Hello"-- count = get_token_count([msg], system="You are a helpful assistant")- assert count > 0-- def test_message_with_list_content(self):- """Test token count with list content blocks."""- text_block = MagicMock()- text_block.type = "text"- text_block.text = "Hello world"-- msg = MagicMock()- msg.content = [text_block]-- count = get_token_count([msg])- assert count > 0-- def test_message_with_thinking_block(self):- """Test token count includes thinking blocks."""- thinking_block = MagicMock()- thinking_block.type = "thinking"- thinking_block.thinking = "Let me think about this..."-- msg = MagicMock()- msg.content = [thinking_block]+def _message(turn_id: str, text: str) -> MessageItem:+ return MessageItem(+ turn_id=turn_id,+ role=MessageRole.USER,+ content=(TextContent(text),),+ )- count = get_token_count([msg])- assert count > 0- def test_message_with_tool_use(self):- """Test token count includes tool use blocks."""- tool_block = MagicMock()- tool_block.type = "tool_use"- tool_block.name = "search"- tool_block.input = {"query": "test"}+def _token_request(+ *items: InferenceItem,+ tools: tuple[FunctionTool, ...] = (),+) -> InferenceRequest:+ return InferenceRequest(model="provider/model", items=items, tools=tools)- msg = MagicMock()- msg.content = [tool_block]- count = get_token_count([msg])- assert count > 0+class TestGetInferenceTokenCount:+ """Canonical token accounting uses the same transcript as execution."""- def test_message_with_tool_result(self):- """Test token count includes tool result blocks."""- result_block = MagicMock()- result_block.type = "tool_result"- result_block.content = "Search results here"+ def test_empty_request_has_nonzero_floor(self) -> None:+ assert get_inference_token_count(_token_request()) == 1- msg = MagicMock()- msg.content = [result_block]-- count = get_token_count([msg])- assert count > 0-- def test_message_with_tools(self):- """Test token count includes tool definitions."""- msg = MagicMock()- msg.content = "Use the search tool"-- tool = MagicMock()- tool.name = "search"- tool.description = "Search for information"- tool.input_schema = {"type": "object", "properties": {}}-- count = get_token_count([msg], tools=[tool])- assert count > 0-- def test_system_as_list(self):- """Test token count with system as list of blocks."""- msg = MagicMock()- msg.content = "Hello"+ def test_plain_and_special_token_text_are_counted(self) -> None:+ ordinary = get_inference_token_count(_token_request(_message("turn_0", "Hi")))+ special = get_inference_token_count(+ _token_request(_message("turn_0", "<|endoftext|>"))+ )- block = MagicMock()- block.text = "System prompt"+ assert ordinary > 0+ assert special > 0++ def test_top_level_instruction_contributes_content_and_overhead(self) -> None:+ message = _message("turn_0", "Hello")+ without_instruction = get_inference_token_count(_token_request(message))+ with_instruction = get_inference_token_count(+ _token_request(+ InstructionItem(+ text="You are a helpful assistant.",+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ ),+ message,+ )+ )- count = get_token_count([msg], system=[block])- assert count > 0+ assert with_instruction >= without_instruction + 4- def test_tool_result_with_dict_content(self):- """Test token count with tool result containing dict content."""- result_block = MagicMock()- result_block.type = "tool_result"- result_block.content = {"result": "data"}+ def test_transcript_instruction_contributes_to_same_turn(self) -> None:+ message = _message("turn_0", "Hello")+ instruction = InstructionItem(+ text="New instructions",+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TRANSCRIPT,+ turn_id="turn_1",+ )- msg = MagicMock()- msg.content = [result_block]+ assert get_inference_token_count(+ _token_request(message, instruction)+ ) > get_inference_token_count(_token_request(message))++ def test_reasoning_tool_call_and_tool_result_are_counted(self) -> None:+ request = _token_request(+ _message("turn_0", "Use the search tool"),+ ReasoningItem(turn_id="turn_1", reasoning="Need current information"),+ ToolCallItem(+ turn_id="turn_1",+ call_id="call_abc123",+ kind=ToolCallKind.FUNCTION,+ name="search",+ input={"query": "test"},+ ),+ ToolResultItem(+ turn_id="turn_2",+ call_id="call_abc123",+ content={"result": "data"},+ ),+ )- count = get_token_count([msg])- assert count > 0+ assert get_inference_token_count(request) > 0++ def test_tool_definition_contributes_to_count(self) -> None:+ message = _message("turn_0", "Use the search tool")+ without_tool = get_inference_token_count(_token_request(message))+ with_tool = get_inference_token_count(+ _token_request(+ message,+ tools=(+ FunctionTool(+ name="search",+ description="Search for information",+ input_schema={"type": "object", "properties": {}},+ ),+ ),+ )+ )- def test_multiple_messages_overhead(self):- """Test that multiple messages include overhead."""- msg1 = MagicMock()- msg1.content = "Hi"+ assert with_tool > without_tool++ def test_multiple_messages_include_per_turn_overhead(self) -> None:+ first = _message("turn_0", "Hi")+ second = _message("turn_1", "Hello")++ assert get_inference_token_count(+ _token_request(first, second)+ ) > get_inference_token_count(_token_request(first))++ def test_base64_image_uses_media_floor(self) -> None:+ request = _token_request(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(+ ImageContent(+ Base64MediaSource(+ media_type="image/png",+ data="x" * 3_000,+ )+ ),+ ),+ )+ )- msg2 = MagicMock()- msg2.content = "Hello"+ assert get_inference_token_count(request) >= 85- count_single = get_token_count([msg1])- count_double = get_token_count([msg1, msg2])-- # Double message should have more tokens (including overhead)- assert count_double > count_single-- def test_inline_system_message_contributes_to_token_count(self):- """Mid-conversation system content remains part of the counted transcript."""- user_message = Message(role="user", content="Hello")- inline_system = Message(role="system", content="New instructions")-- without_inline_system = get_token_count([user_message])- with_inline_system = get_token_count([user_message, inline_system])-- assert with_inline_system > without_inline_system-- def test_per_message_overhead_four_tokens(self):- """Per-message overhead is 4 tokens (was 3)."""- msg = MagicMock()- msg.content = "x" # Minimal content- count = get_token_count([msg])- # 1 msg * 4 overhead + content tokens- assert count >= 5-- def test_system_overhead_added(self):- """System prompt adds ~4 tokens overhead."""- msg = MagicMock()- msg.content = "Hi"- count_no_sys = get_token_count([msg])- count_with_sys = get_token_count([msg], system="You are helpful")- assert count_with_sys >= count_no_sys + 4-- def test_system_as_typed_content_blocks(self):- """Typed system content blocks are counted."""- msg = MagicMock()- msg.content = "Hi"- count_no_sys = get_token_count([msg])- system_blocks = [- SystemContent(type="text", text="System prompt from typed block")- ]- count_with_system = get_token_count([msg], system=system_blocks)- assert count_with_system > count_no_sys-- def test_tool_use_includes_id(self):- """Tool use blocks count id field."""- tool_block = MagicMock()- tool_block.type = "tool_use"- tool_block.name = "search"- tool_block.input = {"q": "test"}- tool_block.id = "call_abc123"- msg = MagicMock()- msg.content = [tool_block]- count = get_token_count([msg])- assert count > 0-- def test_tool_result_includes_tool_use_id(self):- """Tool result blocks count tool_use_id field."""- result_block = MagicMock()- result_block.type = "tool_result"- result_block.content = "ok"- result_block.tool_use_id = "call_xyz"- msg = MagicMock()- msg.content = [result_block]- count = get_token_count([msg])- assert count > 0-- def test_unrecognized_block_type_fallback(self):- """Unrecognized block types are tokenized via json.dumps fallback."""- unknown_block = {"type": "custom", "spec": "data"}- msg = MagicMock()- msg.content = [unknown_block]- count = get_token_count([msg])- assert count > 0-- def test_message_with_image_block(self):- """Test token count includes image blocks."""- image_block = MagicMock()- image_block.type = "image"- image_block.source = {- "type": "base64",- "media_type": "image/png",- "data": "x" * 3000,- }- msg = MagicMock()- msg.content = [image_block]- count = get_token_count([msg])- assert count >= 85-- def test_image_block_with_dict_source(self):- """Image block with dict-style source is counted."""- image_block = {"type": "image", "source": {"data": "a" * 10000}}- msg = MagicMock()- msg.content = [image_block]- count = get_token_count([msg])- assert count >= 85-- def test_known_payload_structural_overhead(self):- """Protocol overhead remains separate from plain-text estimation."""+ def test_known_payload_structural_overhead(self) -> None:system_text = "You are a helpful assistant."user_text = "Hello, how are you?"- msg = MagicMock()- msg.content = user_text+ request = _token_request(+ InstructionItem(+ text=system_text,+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ ),+ _message("turn_0", user_text),+ )with patch(- "free_claude_code.core.anthropic.tokens.estimate_text_tokens",+ "free_claude_code.core.inference.tokens.estimate_text_tokens",side_effect=len,):- count = get_token_count([msg], system=system_text)+ count = get_inference_token_count(request)assert count == len(system_text) + len(user_text) + 4 + 4diff --git a/tests/api/test_routes_optimizations.py b/tests/api/test_routes_optimizations.pyindex 84ec12e3..3ea5c3f1 100644--- a/tests/api/test_routes_optimizations.py+++ b/tests/api/test_routes_optimizations.py@@ -128,7 +128,7 @@ def test_count_tokens_endpoint(client):"messages": [{"role": "user", "content": "hello"}],}- with patch("free_claude_code.api.routes.get_token_count", return_value=5):+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=5):response = client.post("/v1/messages/count_tokens", json=payload)assert response.status_code == 200@@ -136,14 +136,14 @@ def test_count_tokens_endpoint(client):def test_count_tokens_error_returns_500(client):- """When get_token_count raises, count_tokens returns 500."""+ """When canonical token counting raises, count_tokens returns 500."""payload = {"model": "claude-3-sonnet","messages": [{"role": "user", "content": "hello"}],}with patch(- "free_claude_code.api.routes.get_token_count",+ "free_claude_code.api.routes.get_inference_token_count",side_effect=RuntimeError("token error"),):response = client.post("/v1/messages/count_tokens", json=payload)diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.pyindex c1f475a6..a2219867 100644--- a/tests/api/test_web_server_tools.py+++ b/tests/api/test_web_server_tools.py@@ -33,7 +33,7 @@ from free_claude_code.application.routing import (ModelRouter,ProviderModelTarget,ResolvedModelRoute,- RoutedMessagesRequest,+ RoutedInferenceRequest,)from free_claude_code.config.provider_catalog import PROVIDER_CATALOGfrom free_claude_code.config.reasoning import ReasoningPreference@@ -53,7 +53,9 @@ from free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.inference import (FinishReason,InferenceEvent,+ InferenceRequest,InferenceStreamLedger,+ ToolChoiceMode,)from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.core.version import package_version@@ -87,9 +89,9 @@ class FixedProviderModelRouter(ModelRouter):self._fixed_provider_id = provider_idself._fixed_provider_model = provider_model- def resolve_messages_request(- self, request: MessagesRequest- ) -> RoutedMessagesRequest:+ def resolve_inference_request(+ self, request: InferenceRequest+ ) -> RoutedInferenceRequest:provider_model = self._fixed_provider_model or request.modeltarget = ProviderModelTarget(provider_id=self._fixed_provider_id,@@ -102,10 +104,8 @@ class FixedProviderModelRouter(ModelRouter):fallbacks=(),reasoning_preference=ReasoningPreference.OFF,)- routed = request.model_copy(deep=True)- routed.model = resolved.primary.provider_model- return RoutedMessagesRequest(- request=routed,+ return RoutedInferenceRequest(+ request=request,resolved=resolved,reasoning=ReasoningPolicy.off(),)@@ -127,19 +127,24 @@ class ScriptedSelectionProvider:self.failure_after_events = failure_after_eventsself.wait_for = wait_forself.started = asyncio.Event()- self.requests: list[MessagesRequest] = []+ self.requests: list[InferenceRequest] = []self.stream_kwargs: list[dict[str, object]] = []self.close_count = 0def preflight_stream(- self, request: MessagesRequest, *, reasoning: ReasoningPolicy+ self,+ request: InferenceRequest,+ *,+ provider_model: str,+ reasoning: ReasoningPolicy,) -> None:return Noneasync def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,input_tokens: int,request_id: str,response_model: str,@@ -149,6 +154,7 @@ class ScriptedSelectionProvider:self.stream_kwargs.append({"input_tokens": input_tokens,+ "provider_model": provider_model,"request_id": request_id,"response_model": response_model,"reasoning": reasoning,@@ -506,13 +512,14 @@ async def test_automatic_web_search_replays_provider_response_when_declined(assert provider.close_count == 1assert len(provider.requests) == 1translated = provider.requests[0]- assert translated.model == "upstream-model"- assert translated.tool_choice == {"type": "auto"}- assert translated.tools is not None+ assert translated.model == "claude-haiku-4-5-20251001"+ assert translated.tool_choice is not None+ assert translated.tool_choice.mode is ToolChoiceMode.AUTOassert [tool.name for tool in translated.tools] == [HIDDEN_WEB_SEARCH_NAME]assert provider.stream_kwargs == [{"input_tokens": provider.stream_kwargs[0]["input_tokens"],+ "provider_model": "upstream-model","request_id": "req_automatic_declined","response_model": "claude-haiku-4-5-20251001","reasoning": ReasoningPolicy.off(),diff --git a/tests/application/test_execution.py b/tests/application/test_execution.pyindex 43076af8..ee413221 100644--- a/tests/application/test_execution.py+++ b/tests/application/test_execution.py@@ -2,6 +2,7 @@import asynciofrom collections.abc import AsyncIterator+from dataclasses import FrozenInstanceErrorfrom unittest.mock import MagicMock, patchimport pytest@@ -11,13 +12,19 @@ from free_claude_code.application.execution import ProviderExecutorfrom free_claude_code.application.routing import (ProviderModelTarget,ResolvedModelRoute,- RoutedMessagesRequest,+ RoutedInferenceRequest,)from free_claude_code.config.reasoning import ReasoningPreference-from 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.inference import InferenceEvent, TextDelta+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ MessageItem,+ MessageRole,+ TextContent,+ TextDelta,+)from free_claude_code.core.reasoning import ReasoningPolicy@@ -27,29 +34,32 @@ def _event(label: str) -> TextDelta:class FakeProvider:def __init__(self) -> None:- self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []+ self.preflight_calls: list[tuple[InferenceRequest, str, ReasoningPolicy]] = []self.stream_calls: list[dict[str, object]] = []self.stream_close_calls = 0def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:- self.preflight_calls.append((request, reasoning))+ self.preflight_calls.append((request, provider_model, reasoning))async def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,) -> AsyncIterator[InferenceEvent]:self._record_stream_call(request,+ provider_model=provider_model,input_tokens=input_tokens,request_id=request_id,response_model=response_model,@@ -62,8 +72,9 @@ class FakeProvider:def _record_stream_call(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,input_tokens: int,request_id: str | None,response_model: str | None,@@ -72,6 +83,7 @@ class FakeProvider:self.stream_calls.append({"request": request,+ "provider_model": provider_model,"input_tokens": input_tokens,"request_id": request_id,"response_model": response_model,@@ -108,15 +120,17 @@ class ControlledProvider(FakeProvider):async def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,) -> AsyncIterator[InferenceEvent]:self._record_stream_call(request,+ provider_model=provider_model,input_tokens=input_tokens,request_id=request_id,response_model=response_model,@@ -142,8 +156,9 @@ class ControlledProvider(FakeProvider):class FailingPreflightProvider(FakeProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:raise ValueError("invalid provider request")@@ -156,8 +171,9 @@ class ApplicationErrorPreflightProvider(FakeProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy,) -> None:raise self._error@@ -166,9 +182,10 @@ class ApplicationErrorPreflightProvider(FakeProvider):class FailingStreamConstructionProvider(FakeProvider):def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,@@ -186,12 +203,18 @@ def _target(provider_id: str, provider_model: str) -> ProviderModelTarget:def _routed_request(*fallbacks: ProviderModelTarget,-) -> RoutedMessagesRequest:- request = MessagesRequest(+) -> RoutedInferenceRequest:+ request = InferenceRequest(model="provider-model",- messages=[Message(role="user", content="hello")],+ items=(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("hello"),),+ ),+ ),)- return RoutedMessagesRequest(+ return RoutedInferenceRequest(request=request,resolved=ResolvedModelRoute(original_model="gateway-model",@@ -211,7 +234,7 @@ def _executor_stream() -> AsyncIterator[InferenceEvent]:executor = ProviderExecutor(lambda _provider_id: provider,- token_counter=lambda _messages, _system, _tools: 17,+ token_counter=lambda _request: 17,progress_timeout_seconds=timeout_seconds,)return executor.stream(@@ -231,22 +254,25 @@ async def test_executor_uses_structural_provider_port_and_preflights_eagerly() -executor = ProviderExecutor(lambda _provider_id: provider,progress_timeout_seconds=60.0,- token_counter=lambda _messages, _system, _tools: 17,+ token_counter=lambda _request: 17,)stream = executor.stream(routed,wire_api="messages",raw_log_label="FULL_PAYLOAD",- raw_log_payload=request.model_dump(),+ raw_log_payload={},request_id="req_application",)- assert provider.preflight_calls == [(request, ReasoningPolicy.on())]+ assert provider.preflight_calls == [+ (request, "provider-model", ReasoningPolicy.on())+ ]assert [chunk async for chunk in stream] == [_event("provider-event")]assert provider.stream_calls == [{"request": request,+ "provider_model": "provider-model","input_tokens": 17,"request_id": "req_application","response_model": "gateway-model",@@ -310,7 +336,7 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primaryexecutor = ProviderExecutor(resolve,- token_counter=lambda _messages, _system, _tools: 17,+ token_counter=lambda _request: 17,progress_timeout_seconds=60.0,generation_id=7,)@@ -332,9 +358,11 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primaryassert order == ["fallback-resolved"]assert primary.stream_close_calls == 1assert fallback.stream_close_calls == 1- assert fallback.preflight_calls[0][0].model == "fallback-model"+ assert fallback.preflight_calls[0][0].model == "provider-model"+ assert fallback.preflight_calls[0][1] == "fallback-model"assert fallback.stream_calls[0] == {"request": fallback.preflight_calls[0][0],+ "provider_model": "fallback-model","input_tokens": 17,"request_id": "req_fallback","response_model": "gateway-model",@@ -559,31 +587,15 @@ async def test_lazy_fallback_preflight_application_error_stops_unchanged() -> No@pytest.mark.asyncio-async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:- class MutatingProvider(ControlledProvider):- async def stream_response(- self,- request: MessagesRequest,- input_tokens: int = 0,- *,- request_id: str | None = None,- response_model: str | None = None,- reasoning: ReasoningPolicy,- ) -> AsyncIterator[InferenceEvent]:- request.messages[0].content = "mutated"- async for chunk in super().stream_response(- request,- input_tokens,- request_id=request_id,- response_model=response_model,- reasoning=reasoning,- ):- yield chunk-- primary = MutatingProvider([_execution_failure("primary")])+async def test_candidate_request_is_immutable_and_models_are_explicit() -> None:+ primary = ControlledProvider([_execution_failure("primary")])fallback = FakeProvider()providers = {"provider": primary, "fallback": fallback}routed = _routed_request(_target("fallback", "model"))+ field_name = "model"+ with pytest.raises(FrozenInstanceError):+ setattr(routed.request, field_name, "mutated")+executor = ProviderExecutor(providers.__getitem__,progress_timeout_seconds=60.0,@@ -599,10 +611,11 @@ async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:request_id="req_isolated",)]- fallback_request = fallback.stream_calls[0]["request"]- assert isinstance(fallback_request, MessagesRequest)- assert fallback_request.messages[0].content == "hello"- assert routed.request.messages[0].content == "hello"+ assert primary.stream_calls[0]["request"] is routed.request+ assert primary.stream_calls[0]["provider_model"] == "provider-model"+ assert fallback.stream_calls[0]["request"] is routed.request+ assert fallback.stream_calls[0]["provider_model"] == "model"+ assert routed.request.model == "provider-model"@pytest.mark.asyncio@@ -612,7 +625,7 @@ async def test_closing_executor_stream_closes_provider_stream_once() -> None:executor = ProviderExecutor(lambda _provider_id: provider,progress_timeout_seconds=60.0,- token_counter=lambda _messages, _system, _tools: 17,+ token_counter=lambda _request: 17,)stream = executor.stream(routed,@@ -642,7 +655,7 @@ async def test_stream_construction_failure_remains_deferred_to_iteration() -> Noexecutor = ProviderExecutor(resolve,progress_timeout_seconds=60.0,- token_counter=lambda _messages, _system, _tools: 17,+ token_counter=lambda _request: 17,)stream = executor.stream(@@ -779,9 +792,9 @@ async def test_empty_chunks_do_not_renew_provider_progress() -> None:@pytest.mark.asyncioasync def test_fallback_transition_does_not_reset_shared_progress_deadline() -> None:- timeout_seconds = 0.2+ timeout_seconds = 0.3primary = ControlledProvider(- [DelayStep(0.06), _execution_failure("primary overloaded")]+ [DelayStep(0.12), _execution_failure("primary overloaded")])fallback_wait = WaitStep()fallback = ControlledProvider([fallback_wait])@@ -809,7 +822,7 @@ async def test_fallback_transition_does_not_reset_shared_progress_deadline() ->elapsed = loop.time() - startedassert fallback_wait.started.is_set()assert exc_info.value.kind == FailureKind.TIMEOUT- assert elapsed < 0.24+ assert elapsed < 0.4assert primary.stream_close_calls == fallback.stream_close_calls == 1timeout_trace = next(call.kwargsdiff --git a/tests/application/test_reasoning.py b/tests/application/test_reasoning.pyindex fbbc527a..dbd99500 100644--- a/tests/application/test_reasoning.py+++ b/tests/application/test_reasoning.py@@ -5,7 +5,7 @@ from free_claude_code.application.reasoning import (resolve_reasoning_policy,)from free_claude_code.config.reasoning import ReasoningPreference-from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import ClientReasoningIntentfrom free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,@@ -13,24 +13,19 @@ from free_claude_code.core.reasoning import ()-def _request(**overrides) -> MessagesRequest:- payload = {- "model": "provider/model",- "messages": [{"role": "user", "content": "hello"}],- }- payload.update(overrides)- return MessagesRequest.model_validate(payload)--def test_client_without_reasoning_control_uses_provider_default() -> None:- assert client_reasoning_policy(_request()) == ReasoningPolicy.provider_default()+ assert (+ client_reasoning_policy(ClientReasoningIntent())+ == ReasoningPolicy.provider_default()+ )def test_client_reasoning_preserves_effort_and_exact_budget() -> None:policy = client_reasoning_policy(- _request(- thinking={"type": "enabled", "budget_tokens": 4096},- output_config={"effort": "xhigh"},+ ClientReasoningIntent(+ control=ReasoningControl.ON,+ effort=ReasoningEffort.XHIGH,+ budget_tokens=4096,))@@ -41,7 +36,7 @@ def test_client_reasoning_preserves_effort_and_exact_budget() -> None:def test_named_effort_preserves_intent_without_exact_client_budget() -> None:- policy = client_reasoning_policy(_request(output_config={"effort": "high"}))+ policy = client_reasoning_policy(ClientReasoningIntent(effort=ReasoningEffort.HIGH))assert policy == ReasoningPolicy(control=ReasoningControl.DEFAULT,@@ -51,21 +46,10 @@ def test_named_effort_preserves_intent_without_exact_client_budget() -> None:assert policy.requests_reasoning is True-def test_invalid_budget_does_not_implicitly_enable_reasoning() -> None:- policy = client_reasoning_policy(_request(thinking={"budget_tokens": 0}))-- assert policy == ReasoningPolicy.provider_default()--- "messages_request",- [- _request(thinking={"type": "disabled"}),- _request(output_config={"effort": "none"}),- ],-)-def test_client_disable_is_explicit(messages_request: MessagesRequest) -> None:- policy = client_reasoning_policy(messages_request)+def test_client_disable_is_explicit() -> None:+ policy = client_reasoning_policy(+ ClientReasoningIntent(control=ReasoningControl.OFF)+ )assert policy.control is ReasoningControl.OFFassert policy.output_enabled is False@@ -74,9 +58,9 @@ def test_client_disable_is_explicit(messages_request: MessagesRequest) -> None:def test_disabled_thinking_preserves_independent_effort_intent() -> None:policy = client_reasoning_policy(- _request(- thinking={"type": "disabled"},- output_config={"effort": "medium"},+ ClientReasoningIntent(+ control=ReasoningControl.OFF,+ effort=ReasoningEffort.MEDIUM,))@@ -89,7 +73,7 @@ def test_disabled_thinking_preserves_independent_effort_intent() -> None:def test_fixed_route_effort_overrides_client_disable() -> None:policy = resolve_reasoning_policy(- _request(thinking={"type": "disabled"}),+ ClientReasoningIntent(control=ReasoningControl.OFF),ReasoningPreference.MAX,)@@ -98,7 +82,10 @@ def test_fixed_route_effort_overrides_client_disable() -> None:def test_fixed_off_overrides_client_enable() -> None:policy = resolve_reasoning_policy(- _request(thinking={"type": "enabled", "budget_tokens": 1024}),+ ClientReasoningIntent(+ control=ReasoningControl.ON,+ budget_tokens=1024,+ ),ReasoningPreference.OFF,)@@ -106,16 +93,16 @@ def test_fixed_off_overrides_client_enable() -> None:def test_client_preference_preserves_client_policy() -> None:- request = _request(output_config={"effort": "low"})+ intent = ClientReasoningIntent(effort=ReasoningEffort.LOW)assert resolve_reasoning_policy(- request, ReasoningPreference.CLIENT- ) == client_reasoning_policy(request)+ intent, ReasoningPreference.CLIENT+ ) == client_reasoning_policy(intent)def test_unresolved_inherit_is_rejected() -> None:with pytest.raises(ValueError, match="must be resolved"):- resolve_reasoning_policy(_request(), ReasoningPreference.INHERIT)+ resolve_reasoning_policy(ClientReasoningIntent(), ReasoningPreference.INHERIT)@pytest.mark.parametrize("budget", [0, -1, True])diff --git a/tests/application/test_routing.py b/tests/application/test_routing.pyindex 009b7c90..13013fa5 100644--- a/tests/application/test_routing.py+++ b/tests/application/test_routing.py@@ -7,11 +7,7 @@ from free_claude_code.application.routing import ModelRouterfrom free_claude_code.config.provider_catalog import PROVIDER_CATALOGfrom free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic.models import (- Message,- MessagesRequest,- TokenCountRequest,-)+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort@@ -31,6 +27,10 @@ def settings():return settings+def _request(model: str) -> InferenceRequest:+ return InferenceRequest(model=model, items=())++def test_model_router_resolves_default_model(settings):resolved = ModelRouter(settings).resolve("claude-3-opus")@@ -45,14 +45,10 @@ def test_model_router_resolves_default_model(settings):def test_model_router_applies_opus_override(settings):settings.model_opus = "open_router/deepseek/deepseek-r1"- request = MessagesRequest(- model="claude-opus-4-20250514",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )- routed = ModelRouter(settings).resolve_messages_request(request)+ request = _request("claude-opus-4-20250514")+ routed = ModelRouter(settings).resolve_inference_request(request)- assert routed.request.model == "deepseek/deepseek-r1"+ assert routed.request.model == "claude-opus-4-20250514"assert (routed.resolved.primary.provider_model_ref == "open_router/deepseek/deepseek-r1")@@ -64,15 +60,9 @@ def test_model_router_applies_opus_override(settings):def test_model_router_applies_fable_override(settings):settings.model_fable = "open_router/anthropic/claude-fable-5"- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="claude-fable-5",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )- )+ routed = ModelRouter(settings).resolve_inference_request(_request("claude-fable-5"))- assert routed.request.model == "anthropic/claude-fable-5"+ assert routed.request.model == "claude-fable-5"assert (routed.resolved.primary.provider_model_ref== "open_router/anthropic/claude-fable-5"@@ -110,30 +100,22 @@ def test_model_router_resolves_route_reasoning_preferences(settings):def test_model_router_applies_haiku_override(settings):settings.model_haiku = "lmstudio/qwen2.5-7b"- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="claude-3-haiku-20240307",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("claude-3-haiku-20240307"))- assert routed.request.model == "qwen2.5-7b"+ assert routed.request.model == "claude-3-haiku-20240307"assert routed.resolved.primary.provider_model_ref == "lmstudio/qwen2.5-7b"def test_model_router_applies_sonnet_override(settings):settings.model_sonnet = "nvidia_nim/meta/llama-3.3-70b-instruct"- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="claude-sonnet-4-20250514",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("claude-sonnet-4-20250514"))- assert routed.request.model == "meta/llama-3.3-70b-instruct"+ assert routed.request.model == "claude-sonnet-4-20250514"assert (routed.resolved.primary.provider_model_ref== "nvidia_nim/meta/llama-3.3-70b-instruct"@@ -141,15 +123,11 @@ def test_model_router_applies_sonnet_override(settings):def test_model_router_routes_prefixed_provider_model_directly(settings):- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="deepseek/deepseek-chat",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("deepseek/deepseek-chat"))- assert routed.request.model == "deepseek-chat"+ assert routed.request.model == "deepseek/deepseek-chat"assert routed.resolved.original_model == "deepseek/deepseek-chat"assert routed.resolved.primary.provider_id == "deepseek"assert routed.resolved.primary.provider_model == "deepseek-chat"@@ -157,59 +135,43 @@ def test_model_router_routes_prefixed_provider_model_directly(settings):def test_model_router_routes_explicit_opencode_zen_prefix(settings):- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="opencode_zen/kimi-k2.6",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("opencode_zen/kimi-k2.6"))- assert routed.request.model == "kimi-k2.6"+ assert routed.request.model == "opencode_zen/kimi-k2.6"assert routed.resolved.primary.provider_id == "opencode_zen"assert routed.resolved.primary.provider_model_ref == "opencode_zen/kimi-k2.6"def test_model_router_routes_wafer_provider_model_directly(settings):- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="wafer/DeepSeek-V4-Pro",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("wafer/DeepSeek-V4-Pro"))- assert routed.request.model == "DeepSeek-V4-Pro"+ assert routed.request.model == "wafer/DeepSeek-V4-Pro"assert routed.resolved.primary.provider_id == "wafer"assert routed.resolved.primary.provider_model == "DeepSeek-V4-Pro"assert routed.resolved.primary.provider_model_ref == "wafer/DeepSeek-V4-Pro"def test_model_router_routes_minimax_provider_model_directly(settings):- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="minimax/MiniMax-M3",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("minimax/MiniMax-M3"))- assert routed.request.model == "MiniMax-M3"+ assert routed.request.model == "minimax/MiniMax-M3"assert routed.resolved.primary.provider_id == "minimax"assert routed.resolved.primary.provider_model == "MiniMax-M3"assert routed.resolved.primary.provider_model_ref == "minimax/MiniMax-M3"def test_model_router_routes_gateway_encoded_provider_model_directly(settings):- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"))- assert routed.request.model == "deepseek-ai/deepseek-v4-pro"+ assert routed.request.model == "anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"assert (routed.resolved.original_model== "anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"@@ -223,15 +185,14 @@ def test_model_router_routes_gateway_encoded_provider_model_directly(settings):def test_model_router_routes_no_thinking_gateway_model_directly(settings):- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro",- max_tokens=100,- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro"))- assert routed.request.model == "deepseek-ai/deepseek-v4-pro"+ assert (+ routed.request.model+ == "claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro"+ )assert (routed.resolved.original_model== "claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro"@@ -245,11 +206,8 @@ def test_direct_provider_model_uses_root_policy_without_model_name_guessing(settsettings.reasoning_policy = ReasoningPreference.LOWsettings.reasoning_opus = ReasoningPreference.MAX- routed = ModelRouter(settings).resolve_messages_request(- MessagesRequest(- model="open_router/anthropic/claude-opus-4",- messages=[Message(role="user", content="hello")],- )+ routed = ModelRouter(settings).resolve_inference_request(+ _request("open_router/anthropic/claude-opus-4"))assert routed.resolved.primary.provider_id == "open_router"@@ -260,13 +218,11 @@ def test_direct_provider_model_uses_root_policy_without_model_name_guessing(settdef test_model_router_routes_token_count_request(settings):settings.model_haiku = "lmstudio/qwen2.5-7b"- request = TokenCountRequest(- model="claude-3-haiku-20240307",- messages=[Message(role="user", content="hello")],- )+ request = _request("claude-3-haiku-20240307")routed = ModelRouter(settings).resolve_token_count_request(request)- assert routed.request.model == "qwen2.5-7b"+ assert routed.request.model == "claude-3-haiku-20240307"+ assert routed.resolved.primary.provider_model == "qwen2.5-7b"assert request.model == "claude-3-haiku-20240307"diff --git a/tests/contracts/test_import_boundaries.py b/tests/contracts/test_import_boundaries.pyindex 9b4bf9ff..d9d6a5fe 100644--- a/tests/contracts/test_import_boundaries.py+++ b/tests/contracts/test_import_boundaries.py@@ -500,6 +500,56 @@ def test_core_does_not_import_provider_transport_sdks() -> None:assert sorted(offenders) == []+def test_application_and_providers_do_not_import_protocol_request_models() -> None:+ forbidden_symbols = {+ "Message",+ "MessagesRequest",+ "SystemContent",+ "TokenCountRequest",+ "Tool",+ }+ owner_modules = {+ "free_claude_code.core.anthropic",+ "free_claude_code.core.anthropic.models",+ }+ offenders: list[str] = []+ for root in (_PACKAGE_ROOT / "application", _PACKAGE_ROOT / "providers"):+ for path in root.rglob("*.py"):+ tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))+ relative = path.relative_to(_REPO_ROOT).as_posix()+ for node in ast.walk(tree):+ if (+ not isinstance(node, ast.ImportFrom)+ or node.module not in owner_modules+ ):+ continue+ offenders.extend(+ f"{relative}:{node.lineno}: {node.module}.{alias.name}"+ for alias in node.names+ if alias.name in forbidden_symbols+ )++ assert sorted(offenders) == []+++def test_removed_request_bridge_modules_do_not_return() -> None:+ removed_modules = {+ "core/anthropic/conversion.py",+ "core/anthropic/openai_tool_names.py",+ "core/anthropic/request_serialization.py",+ "core/anthropic/request_snapshot.py",+ "core/anthropic/streaming/recovery.py",+ "core/anthropic/tokens.py",+ "core/openai_responses/adapter.py",+ "core/openai_responses/input.py",+ "core/openai_responses/provider_events.py",+ "core/openai_responses/provider_input.py",+ "core/openai_responses/tools.py",+ }++ assert all(not (_PACKAGE_ROOT / module).exists() for module in removed_modules)++def test_providers_do_not_own_wire_error_type_literals() -> None:wire_types = {"api_error",diff --git a/tests/core/anthropic/test_models.py b/tests/core/anthropic/test_models.pyindex 39f789d9..1298f76e 100644--- a/tests/core/anthropic/test_models.py+++ b/tests/core/anthropic/test_models.py@@ -1,9 +1,10 @@import pytestfrom pydantic import ValidationError-from free_claude_code.core.anthropic.conversion import (- OpenAIConversionError,- build_base_request_body,+from free_claude_code.core.anthropic.ingress import (+ AnthropicIngressError,+ messages_to_inference_request,+ token_count_to_inference_request,)from free_claude_code.core.anthropic.models import (ContentBlockDocument,@@ -12,6 +13,23 @@ from free_claude_code.core.anthropic.models import (MessagesRequest,TokenCountRequest,)+from free_claude_code.core.inference import (+ CacheTTL,+ DocumentContent,+ ImageContent,+ InstructionItem,+ MessageItem,+ ReasoningItem,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ReplayCompatibilityScope,+ TextContent,+ ToolCallItem,+)+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort+from free_claude_code.core.replay_envelope import encode_replay_envelopedef test_messages_request_parses_without_model_mapping_side_effects():@@ -118,7 +136,7 @@ def test_messages_request_preserves_inline_system_block_metadata():}-def test_messages_request_ignores_internal_routing_fields_when_supplied():+def test_messages_ingress_rejects_internal_routing_fields_when_supplied() -> None:request = MessagesRequest.model_validate({"model": "target-model",@@ -130,8 +148,8 @@ def test_messages_request_ignores_internal_routing_fields_when_supplied():)assert request.model == "target-model"- assert "original_model" not in request.model_dump()- assert "resolved_provider_model" not in request.model_dump()+ with pytest.raises(AnthropicIngressError, match="original_model"):+ messages_to_inference_request(request)def test_token_count_request_parses_without_model_mapping_side_effects():@@ -295,9 +313,7 @@ def test_content_block_descriptions_remain_in_the_public_schema() -> None:)-def test_messages_request_dump_preserves_public_defaults_and_excludes_internal_fields() -> (- None-):+def test_messages_ingress_rejects_unknown_fields_after_permissive_wire_parse() -> None:request = MessagesRequest.model_validate({"model": "model",@@ -310,18 +326,11 @@ def test_messages_request_dump_preserves_public_defaults_and_excludes_internal_f})- dumped = request.model_dump(exclude_none=True)-- assert dumped == {- "model": "model",- "messages": [{"role": "user", "content": "hello"}],- "stream": False,- "thinking": {"enabled": True, "type": "adaptive"},- "client_extension": {"enabled": True},- }+ with pytest.raises(AnthropicIngressError, match="client_extension"):+ messages_to_inference_request(request)-def test_token_count_request_accepts_extras_but_excludes_internal_fields() -> None:+def test_token_count_ingress_rejects_unknown_internal_fields() -> None:request = TokenCountRequest.model_validate({"model": "model",@@ -333,15 +342,11 @@ def test_token_count_request_accepts_extras_but_excludes_internal_fields() -> No})- assert request.model_extra == {"client_extension": "accepted"}- assert request.model_dump(exclude_none=True) == {- "model": "model",- "messages": [{"role": "user", "content": "hello"}],- "client_extension": "accepted",- }+ with pytest.raises(AnthropicIngressError, match="client_extension"):+ token_count_to_inference_request(request)-def test_openai_conversion_rejects_unknown_top_level_anthropic_extensions() -> None:+def test_anthropic_ingress_rejects_unknown_top_level_extensions() -> None:request = MessagesRequest.model_validate({"model": "model",@@ -350,5 +355,323 @@ def test_openai_conversion_rejects_unknown_top_level_anthropic_extensions() -> N})- with pytest.raises(OpenAIConversionError, match="client_extension"):- build_base_request_body(request)+ with pytest.raises(AnthropicIngressError, match="client_extension"):+ messages_to_inference_request(request)+++def test_messages_ingress_preserves_cache_controls_at_supported_locations() -> None:+ request = MessagesRequest.model_validate(+ {+ "model": "model",+ "system": [+ {+ "type": "text",+ "text": "Top-level",+ "cache_control": {"type": "ephemeral", "ttl": "5m"},+ }+ ],+ "messages": [+ {+ "role": "system",+ "content": [+ {+ "type": "text",+ "text": "Inline",+ "cache_control": {"type": "ephemeral", "ttl": "1h"},+ }+ ],+ },+ {+ "role": "user",+ "content": [+ {+ "type": "text",+ "text": "Inspect",+ "cache_control": {"type": "ephemeral"},+ },+ {+ "type": "image",+ "source": {+ "type": "url",+ "url": "https://example.invalid/image.png",+ },+ "cache_control": {"type": "ephemeral"},+ },+ {+ "type": "document",+ "source": {"type": "file", "file_id": "file_1"},+ "cache_control": {"type": "ephemeral"},+ },+ ],+ },+ ],+ "tools": [+ {+ "name": "lookup",+ "input_schema": {"type": "object"},+ "cache_control": {"type": "ephemeral"},+ }+ ],+ }+ )++ canonical = messages_to_inference_request(request)++ top_level, inline, *message_items = canonical.items+ assert isinstance(top_level, InstructionItem)+ assert top_level.cache_control is not None+ assert top_level.cache_control.ttl is CacheTTL.FIVE_MINUTES+ assert isinstance(inline, InstructionItem)+ assert inline.cache_control is not None+ assert inline.cache_control.ttl is CacheTTL.ONE_HOUR+ assert all(isinstance(item, MessageItem) for item in message_items)+ content = tuple(+ item.content[0] for item in message_items if isinstance(item, MessageItem)+ )+ assert [type(part) for part in content] == [+ TextContent,+ ImageContent,+ DocumentContent,+ ]+ text, image, document = content+ assert isinstance(text, TextContent)+ assert isinstance(image, ImageContent)+ assert isinstance(document, DocumentContent)+ assert text.cache_control is not None+ assert image.cache_control is not None+ assert document.cache_control is not None+ assert canonical.tools[0].cache_control is not None+++def test_messages_ingress_normalizes_known_no_op_controls() -> None:+ request = MessagesRequest.model_validate(+ {+ "model": "model",+ "messages": [{"role": "user", "content": "Hello"}],+ "context_management": {+ "edits": [{"type": "clear_thinking_20251015", "keep": "all"}]+ },+ "output_config": {"effort": "high"},+ "mcp_servers": [],+ }+ )++ canonical = messages_to_inference_request(request)++ assert canonical.reasoning.control is ReasoningControl.DEFAULT+ assert canonical.reasoning.effort is ReasoningEffort.HIGH+++def test_messages_ingress_normalizes_claude_thinking_display_hint() -> None:+ request = MessagesRequest.model_validate(+ {+ "model": "model",+ "messages": [{"role": "user", "content": "Hello"}],+ "thinking": {"type": "adaptive", "display": "omitted"},+ }+ )++ canonical = messages_to_inference_request(request)++ assert canonical.reasoning.control is ReasoningControl.ON++[email protected]("display", [None, "", "shown", False, {"mode": "omitted"}])+def test_messages_ingress_rejects_unknown_thinking_display_values(+ display: object,+) -> None:+ request = MessagesRequest.model_validate(+ {+ "model": "model",+ "messages": [{"role": "user", "content": "Hello"}],+ "thinking": {"type": "adaptive", "display": display},+ }+ )++ with pytest.raises(AnthropicIngressError, match=r"thinking\.display"):+ messages_to_inference_request(request)+++def test_messages_replay_carriers_restore_reasoning_and_tool_artifacts() -> None:+ scope = ReplayCompatibilityScope("provider:model")+ reasoning_artifact = ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ scope=scope,+ payload="opaque-reasoning",+ )+ tool_artifact = ReplayArtifact(+ origin=ReplayArtifactOrigin.GOOGLE,+ kind=ReplayArtifactKind.THOUGHT_SIGNATURE,+ attachment=ReplayAttachment.TOOL_CALL,+ scope=scope,+ payload="opaque-tool",+ )+ request = MessagesRequest.model_validate(+ {+ "model": "model",+ "messages": [+ {+ "role": "assistant",+ "content": [+ {+ "type": "thinking",+ "thinking": "summary",+ "signature": encode_replay_envelope((reasoning_artifact,)),+ },+ {+ "type": "tool_use",+ "id": "call_1",+ "name": "lookup",+ "input": {},+ "extra_content": {+ "fcc_replay": encode_replay_envelope((tool_artifact,))+ },+ },+ ],+ }+ ],+ "tools": [{"name": "lookup", "input_schema": {"type": "object"}}],+ }+ )++ canonical = messages_to_inference_request(request)+ reasoning = next(+ item for item in canonical.items if isinstance(item, ReasoningItem)+ )+ tool_call = next(item for item in canonical.items if isinstance(item, ToolCallItem))++ assert reasoning.artifacts == (reasoning_artifact,)+ assert tool_call.artifacts == (tool_artifact,)+++ ("override", "match"),+ [+ (+ {+ "context_management": {+ "edits": [{"type": "clear_thinking_20251015", "keep": "last"}]+ }+ },+ "context_management",+ ),+ ({"output_config": {"format": {"type": "json"}}}, "output_config.format"),+ (+ {"mcp_servers": [{"type": "url", "url": "https://example.invalid"}]},+ "mcp_servers",+ ),+ ({"thinking": {"type": "future"}}, "thinking.type"),+ (+ {"thinking": {"type": "adaptive", "client_extension": True}},+ "thinking.client_extension",+ ),+ (+ {+ "messages": [+ {+ "role": "user",+ "content": "Hello",+ "client_extension": True,+ }+ ]+ },+ "messages\\[0\\].client_extension",+ ),+ (+ {+ "system": [+ {+ "type": "text",+ "text": "System",+ "cache_control": {"type": "ephemeral", "ttl": "2h"},+ }+ ]+ },+ "system\\[0\\].cache_control.ttl",+ ),+ (+ {+ "messages": [+ {+ "role": "user",+ "content": [+ {+ "type": "text",+ "text": "Hello",+ "cache_control": {"type": "persistent"},+ }+ ],+ }+ ]+ },+ "cache_control.type",+ ),+ (+ {+ "messages": [+ {+ "role": "user",+ "content": [+ {+ "type": "image",+ "source": {+ "type": "url",+ "url": "https://example.invalid/image.png",+ "caption": "silently dropped",+ },+ }+ ],+ }+ ]+ },+ "source.caption",+ ),+ (+ {+ "messages": [+ {+ "role": "user",+ "content": [+ {+ "type": "document",+ "source": {+ "type": "file",+ "file_id": "file_1",+ "filename": "ignored.pdf",+ },+ }+ ],+ }+ ]+ },+ "source.filename",+ ),+ (+ {+ "tools": [+ {+ "name": "lookup",+ "input_schema": {"type": "object"},+ "client_extension": True,+ }+ ]+ },+ "tools\\[0\\].client_extension",+ ),+ ],+)+def test_messages_ingress_rejects_active_or_unknown_nested_semantics(+ override: dict[str, object],+ match: str,+) -> None:+ payload: dict[str, object] = {+ "model": "model",+ "messages": [{"role": "user", "content": "Hello"}],+ }+ payload.update(override)+ request = MessagesRequest.model_validate(payload)++ with pytest.raises(AnthropicIngressError, match=match):+ messages_to_inference_request(request)diff --git a/tests/core/anthropic/test_openai_tool_names.py b/tests/core/anthropic/test_openai_tool_names.pyindex 908aae01..1646768b 100644--- a/tests/core/anthropic/test_openai_tool_names.py+++ b/tests/core/anthropic/test_openai_tool_names.py@@ -1,25 +1,27 @@import re-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec+import pytest++from free_claude_code.core.anthropic.ingress import AnthropicIngressError+from free_claude_code.core.inference import InferenceRequest+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec+from tests.providers.request_factory import make_messages_request_PORTABLE_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")-def _request(*names: str) -> MessagesRequest:- return MessagesRequest.model_validate(- {- "model": "test-model",- "messages": [{"role": "user", "content": "hello"}],- "tools": [- {- "name": name,- "description": "test",- "input_schema": {"type": "object"},- }- for name in names- ],- }+def _request(*names: str) -> InferenceRequest:+ return make_messages_request(+ "test-model",+ messages=[{"role": "user", "content": "hello"}],+ tools=[+ {+ "name": name,+ "description": "test",+ "input_schema": {"type": "object"},+ }+ for name in names+ ],)@@ -98,44 +100,41 @@ def test_codec_collects_forced_choice_and_history_names_without_mutation() -> Nodeclared = "safe_tool"forced = "mcp__forced__" + "f" * 70historical = "mcp__historical__" + "h" * 70- request = MessagesRequest.model_validate(- {- "model": "test-model",- "messages": [- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "call_1",- "name": historical,- "input": {},- }- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_1",- "content": "done",- }- ],- },- ],- "tools": [{"name": declared, "input_schema": {"type": "object"}}],- "tool_choice": {"type": "tool", "name": forced},- }+ request = make_messages_request(+ "test-model",+ messages=[+ {+ "role": "assistant",+ "content": [+ {+ "type": "tool_use",+ "id": "call_1",+ "name": historical,+ "input": {},+ }+ ],+ },+ {+ "role": "user",+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": "call_1",+ "content": "done",+ }+ ],+ },+ ],+ tools=[{"name": declared, "input_schema": {"type": "object"}}],+ tool_choice={"type": "tool", "name": forced},)- snapshot = request.model_dump()codec = OpenAIToolNameCodec.from_request(request)assert codec.encode(declared) == declaredassert codec.decode(codec.encode(forced)) == forcedassert codec.decode(codec.encode(historical)) == historical- assert request.model_dump() == snapshot+ assert request.model == "test-model"def test_only_generated_aliases_are_decoded_and_prefixes_are_detected() -> None:@@ -152,8 +151,6 @@ def test_only_generated_aliases_are_decoded_and_prefixes_are_detected() -> None:assert codec.decode("unknown_tool") == "unknown_tool"-def test_empty_name_retains_existing_invalid_identity() -> None:- codec = OpenAIToolNameCodec.from_request(_request(""))-- assert codec.encode("") == ""- assert codec.decode("") == ""+def test_empty_tool_name_is_rejected_before_codec_construction() -> None:+ with pytest.raises(AnthropicIngressError, match="non-empty"):+ _request("")diff --git a/tests/core/anthropic/test_request_serialization.py b/tests/core/anthropic/test_request_serialization.pyindex 3a9ffbba..612b6ea7 100644--- a/tests/core/anthropic/test_request_serialization.py+++ b/tests/core/anthropic/test_request_serialization.py@@ -1,6 +1,5 @@-"""Anthropic request parsing and public-field serialization."""+"""Anthropic public-wire parsing contracts."""-from free_claude_code.core.anthropic import dump_messages_requestfrom free_claude_code.core.anthropic.models import (ContentBlockServerToolUse,ContentBlockText,@@ -10,55 +9,6 @@ from free_claude_code.core.anthropic.models import ()-def test_dump_preserves_public_fields_and_nested_extensions() -> None:- request = MessagesRequest.model_validate(- {- "model": "m",- "max_tokens": 20,- "messages": [- {- "role": "user",- "content": [- {- "type": "text",- "text": "hi",- "cache_control": {"type": "ephemeral"},- }- ],- }- ],- "context_management": {"edits": [{"type": "clear"}]},- "output_config": {"some": "hint"},- }- )-- body = dump_messages_request(request)-- assert body["messages"][0]["content"][0]["cache_control"] == {"type": "ephemeral"}- assert body["context_management"] == {"edits": [{"type": "clear"}]}- assert body["output_config"] == {"some": "hint"}---def test_dump_excludes_unknown_client_hints_and_fcc_routing_state() -> None:- request = MessagesRequest.model_validate(- {- "model": "m",- "messages": [{"role": "user", "content": "x"}],- "reasoning_effort": "none",- "unknown_client_hint": {"mode": "local"},- }- )- request.original_model = "claude"- request.resolved_provider_model = "upstream"-- body = dump_messages_request(request)-- assert "reasoning_effort" not in body- assert "unknown_client_hint" not in body- assert "original_model" not in body- assert "resolved_provider_model" not in body--def test_pydantic_discriminator_still_distinguishes_blocks() -> None:message = Message.model_validate({diff --git a/tests/core/anthropic/test_stream_repair.py b/tests/core/anthropic/test_stream_repair.pyindex 9b42c665..698dd699 100644--- a/tests/core/anthropic/test_stream_repair.py+++ b/tests/core/anthropic/test_stream_repair.py@@ -1,6 +1,6 @@-"""Neutral Anthropic continuation and tool-repair helpers."""+"""OpenAI Chat continuation and tool-repair helpers."""-from free_claude_code.core.anthropic.streaming import (+from free_claude_code.providers.openai_chat.recovery import (ToolSchema,accept_tool_json_repair,continuation_suffix,diff --git a/tests/core/anthropic/test_text_tools.py b/tests/core/anthropic/test_text_tools.pyindex 82107cf7..88993365 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 tools as tool_parsers+from free_claude_code.providers.openai_chat import function_tags as tool_parsers+from free_claude_code.providers.openai_chat.function_tags import FunctionTagToolParser+from free_claude_code.providers.openai_compat import OpenAIToolNameCodecfrom tests.providers.request_factory import make_messages_requestdiff --git a/tests/core/openai_responses/test_conversion.py b/tests/core/openai_responses/test_conversion.pyindex 5adac9ba..2bc4bdd0 100644--- a/tests/core/openai_responses/test_conversion.py+++ b/tests/core/openai_responses/test_conversion.py@@ -1,22 +1,43 @@-from typing import Any-import pytest+from free_claude_code.core.inference import (+ CustomTool,+ CustomToolFormatType,+ FunctionTool,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MessageItem,+ MessageRole,+ ReasoningItem,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ReplayCompatibilityScope,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolChoiceMode,+ ToolResultItem,+)from free_claude_code.core.openai_responses import (- OpenAIResponsesAdapter,OpenAIResponsesRequest,+ ResponsesConversionError,+ responses_to_inference_request,)+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort+from free_claude_code.core.replay_envelope import encode_replay_envelope-_ADAPTER = OpenAIResponsesAdapter()-_CONVERSION_ERROR = OpenAIResponsesAdapter.ConversionError+def _ingest(payload: dict[str, object]):+ return responses_to_inference_request(+ OpenAIResponsesRequest.model_validate(payload)+ ).request-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(+def test_responses_string_input_becomes_canonical_instruction_and_message() -> None:+ request = _ingest({"model": "nvidia_nim/test-model","instructions": "System instructions",@@ -28,20 +49,41 @@ def test_responses_string_input_converts_to_anthropic_message() -> None:})- 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(+ assert request.model == "nvidia_nim/test-model"+ assert request.items == (+ InstructionItem(+ text="System instructions",+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ ),+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("Hello"),),+ ),+ )+ assert request.max_output_tokens == 64+ assert request.temperature == 0.2+ assert request.top_p == 0.9+ assert request.metadata == {"trace": "abc"}+++ ("effort", "control", "expected_effort"),+ [+ ("none", ReasoningControl.OFF, None),+ ("low", ReasoningControl.ON, ReasoningEffort.LOW),+ ("medium", ReasoningControl.ON, ReasoningEffort.MEDIUM),+ ("high", ReasoningControl.ON, ReasoningEffort.HIGH),+ ("xhigh", ReasoningControl.ON, ReasoningEffort.XHIGH),+ ],+)+def test_responses_reasoning_effort_becomes_canonical_intent(effort: str,+ control: ReasoningControl,+ expected_effort: ReasoningEffort | None,) -> None:- payload = _to_anthropic_payload(+ request = _ingest({"model": "nvidia_nim/test-model","input": "Hello",@@ -49,12 +91,12 @@ def test_responses_reasoning_effort_is_preserved_for_application_policy(})- assert payload["output_config"] == {"effort": effort}- assert "thinking" not in payload+ assert request.reasoning.control is control+ assert request.reasoning.effort is expected_effort-def test_responses_messages_tools_and_tool_results_convert() -> None:- payload = _to_anthropic_payload(+def test_responses_messages_tools_and_results_preserve_semantics() -> None:+ request = _ingest({"model": "deepseek/deepseek-chat","input": [@@ -89,195 +131,137 @@ def test_responses_messages_tools_and_tool_results_convert() -> None:"type": "object","properties": {"value": {"type": "string"}},},+ "strict": True,}],"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": {+ assert request.items == (+ InstructionItem(+ text="Developer rules",+ origin=InstructionOrigin.DEVELOPER,+ placement=InstructionPlacement.TRANSCRIPT,+ turn_id="turn_0",+ ),+ MessageItem(+ turn_id="turn_1",+ role=MessageRole.USER,+ content=(TextContent("Use the tool"),),+ ),+ ToolCallItem(+ turn_id="turn_2",+ call_id="call_1",+ kind=ToolCallKind.FUNCTION,+ name="echo",+ input={"value": "FCC"},+ ),+ ToolResultItem(+ turn_id="turn_3",+ call_id="call_1",+ content="FCC",+ ),+ )+ assert request.tools == (+ FunctionTool(+ name="echo",+ description="Echo a value",+ input_schema={"type": "object","properties": {"value": {"type": "string"}},},- }- ]- assert payload["tool_choice"] == {"type": "tool", "name": "echo"}+ strict=True,+ ),+ )+ assert request.tool_choice is not None+ assert request.tool_choice.mode is ToolChoiceMode.SPECIFIC+ assert request.tool_choice.name == "echo"-def test_responses_tool_choice_none_disables_forwarded_tools() -> None:- payload = _to_anthropic_payload(+def test_none_choice_retains_definitions_but_disables_tool_calls() -> None:+ request = _ingest({- "model": "deepseek/deepseek-chat",+ "model": "model","input": "Reply without tools","tools": [{"type": "function","name": "echo",- "parameters": {- "type": "object",- "properties": {"value": {"type": "string"}},- },+ "parameters": {"type": "object", "properties": {}},}],"tool_choice": "none",})- assert "tools" not in payload- assert "tool_choice" not in payload+ assert [tool.name for tool in request.tools] == ["echo"]+ assert request.tool_choice is not None+ assert request.tool_choice.mode is ToolChoiceMode.NONE-def test_responses_namespace_tools_flatten_for_anthropic() -> None:- payload = _to_anthropic_payload(+def test_passive_responses_controls_are_accepted_only_at_the_settled_values() -> None:+ request = _ingest({- "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",- },+ "model": "model",+ "input": "Hello",+ "stream": True,+ "store": False,+ "previous_response_id": None,+ "include": ["reasoning.encrypted_content"],+ "prompt_cache_key": "session-1",+ "reasoning": {"summary": "auto"},})- 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"}+ assert request.model == "model"+ assert request.reasoning.control is ReasoningControl.DEFAULT-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",+ ("override", "match"),+ [+ ({"stream": False}, "stream=false"),+ ({"store": True}, "store=true"),+ ({"previous_response_id": "resp_1"}, "previous_response_id"),+ ({"include": []}, "include must be exactly"),+ (+ {+ "include": [+ "reasoning.encrypted_content",+ "reasoning.encrypted_content",+ ]},- }- )-- 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"},- }- )+ "include must be exactly",+ ),+ (+ {"include": ["reasoning.encrypted_content", "message.output_text"]},+ "include must be exactly",+ ),+ ({"include": ["reasoning.encrypted_contents"]}, "include must be exactly"),+ ({"prompt_cache_key": ""}, "prompt_cache_key"),+ ({"prompt_cache_key": " "}, "prompt_cache_key"),+ ({"prompt_cache_key": 42}, "prompt_cache_key"),+ ({"reasoning": {"summary": "concise"}}, "reasoning.summary"),+ ({"reasoning": {"summary": []}}, "reasoning.summary"),+ ({"provider_extension": True}, "request.provider_extension"),+ ],+)+def test_responses_passive_field_near_misses_are_rejected(+ override: dict[str, object],+ match: str,+) -> None:+ payload: dict[str, object] = {"model": "model", "input": "Hello"}+ payload.update(override)- 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"}+ with pytest.raises(ResponsesConversionError, match=match):+ _ingest(payload)-def test_responses_namespaced_custom_tool_flattens_for_anthropic() -> None:- payload = _to_anthropic_payload(+def test_namespace_and_custom_tool_identity_remain_structured() -> None:+ request = _ingest({- "model": "nvidia_nim/test-model",+ "model": "model","input": "Use shell","tools": [{@@ -301,17 +285,26 @@ def test_responses_namespaced_custom_tool_flattens_for_anthropic() -> None:})- assert payload["tools"][0]["name"] == "mcp__shell__exec"- assert payload["tools"][0]["description"] == (- "Run shell text\n\nCustom tool input format: unconstrained text."+ assert request.tools == (+ CustomTool(+ name="exec",+ description="Run shell text",+ format=request.tools[0].format,+ namespace="mcp__shell",+ ),)- assert payload["tool_choice"] == {"type": "tool", "name": "mcp__shell__exec"}+ assert isinstance(request.tools[0], CustomTool)+ assert request.tools[0].format.type is CustomToolFormatType.TEXT+ assert request.tool_choice is not None+ assert request.tool_choice.kind is ToolCallKind.CUSTOM+ assert request.tool_choice.name == "exec"+ assert request.tool_choice.namespace == "mcp__shell"-def test_responses_passive_codex_built_in_tools_are_ignored() -> None:- payload = _to_anthropic_payload(+def test_passive_hosted_tools_are_removed_but_executable_tools_remain() -> None:+ request = _ingest({- "model": "nvidia_nim/test-model",+ "model": "model","input": "Hello","tools": [{"type": "web_search", "external_web_access": True},@@ -326,215 +319,115 @@ def test_responses_passive_codex_built_in_tools_are_ignored() -> None:})- assert payload["tools"] == [- {"name": "echo", "input_schema": {"type": "object", "properties": {}}}- ]+ assert [tool.name for tool in request.tools] == ["echo"]-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"+ ("raw_choice", "expected_mode"),+ [+ (None, None),+ ("auto", ToolChoiceMode.AUTO),+ ("none", ToolChoiceMode.NONE),+ ("required", ToolChoiceMode.REQUIRED),+ ({"type": "function", "name": "echo"}, ToolChoiceMode.SPECIFIC),+ ],+)+def test_ambient_and_executable_tool_combinations_preserve_client_choice(+ raw_choice: object,+ expected_mode: ToolChoiceMode | None,+) -> None:+ payload: dict[str, object] = {+ "model": "model",+ "input": "Hello",+ "tools": [+ {"type": "web_search"},+ {"type": "image_generation"},+ {"type": "tool_search"},+ {+ "type": "function",+ "name": "echo",+ "parameters": {"type": "object"},+ },+ ],+ }+ if raw_choice is not None:+ payload["tool_choice"] = raw_choice+ request = _ingest(payload)-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 [tool.name for tool in request.tools] == ["echo"]+ assert (+ request.tool_choice.mode if request.tool_choice is not None else None+ ) is expected_mode- 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",- }- ],- },- ]+ ("raw_choice", "expected_mode"),+ [+ (None, None),+ ("auto", ToolChoiceMode.AUTO),+ ("none", ToolChoiceMode.NONE),+ ],+)+def test_ambient_only_tools_are_safe_no_ops_when_not_required(+ raw_choice: object,+ expected_mode: ToolChoiceMode | None,+) -> None:+ payload: dict[str, object] = {+ "model": "model",+ "input": "Hello",+ "tools": [{"type": "web_search"}, {"type": "tool_search"}],+ }+ if raw_choice is not None:+ payload["tool_choice"] = raw_choice-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",- },- ],- }- )+ request = _ingest(payload)- 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"},- },- ],- }- ]+ assert request.tools == ()+ assert (+ request.tool_choice.mode if request.tool_choice is not None else None+ ) is expected_mode-def test_responses_groups_consecutive_prior_tool_outputs() -> None:- payload = _to_anthropic_payload(+def test_prior_custom_call_preserves_kind_namespace_and_raw_input() -> None:+ request = _ingest({- "model": "nvidia_nim/test-model",+ "model": "model","input": [{- "type": "function_call",+ "type": "custom_tool_call","call_id": "call_1",- "name": "echo",- "arguments": '{"value":"FCC"}',- },- {- "type": "function_call",- "call_id": "call_2",- "name": "echo",- "arguments": '{"value":"Codex"}',+ "namespace": "mcp__shell",+ "name": "exec",+ "input": "printf FCC",},{- "type": "function_call_output",+ "type": "custom_tool_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",- },- ],- }+ call, result = request.items+ assert isinstance(call, ToolCallItem)+ assert call.kind is ToolCallKind.CUSTOM+ assert call.namespace == "mcp__shell"+ assert call.input == "printf FCC"+ assert isinstance(result, ToolResultItem)+ assert result.call_id == call.call_id-def test_responses_reasoning_between_tool_call_and_output_attaches_to_tool_message() -> (- None-):- payload = _to_anthropic_payload(+def test_reasoning_stays_attached_to_the_following_tool_turn() -> None:+ request = _ingest({- "model": "nvidia_nim/test-model",+ "model": "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",@@ -550,62 +443,44 @@ def test_responses_encrypted_reasoning_attaches_before_tool_call() -> None:})- 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(+ reasoning, call, result = request.items+ assert isinstance(reasoning, ReasoningItem)+ assert isinstance(call, ToolCallItem)+ assert reasoning.turn_id == call.turn_id+ assert reasoning.reasoning == "Need the result."+ assert isinstance(result, ToolResultItem)+++def test_responses_encrypted_reasoning_carrier_restores_scoped_artifacts() -> None:+ artifact = ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,+ kind=ReplayArtifactKind.REASONING_DETAILS,+ attachment=ReplayAttachment.REASONING,+ scope=ReplayCompatibilityScope("provider:model"),+ payload=[{"type": "reasoning.text", "text": "opaque"}],+ )+ request = _ingest({- "model": "nvidia_nim/test-model",+ "model": "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",+ "encrypted_content": encode_replay_envelope((artifact,)),},+ {"role": "assistant", "content": "Done"},+ {"role": "user", "content": "Continue"},],})- assert payload["messages"][0]["reasoning_content"] == ""+ reasoning = next(item for item in request.items if isinstance(item, ReasoningItem))+ assert reasoning.artifacts == (artifact,)-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(+def test_malformed_prior_call_quarantines_only_it_and_matching_output() -> None:+ request = _ingest({- "model": "nvidia_nim/test-model",+ "model": "model","input": [{"role": "user", "content": "hello"},{@@ -635,38 +510,26 @@ def test_responses_malformed_prior_function_call_is_quarantined() -> None:})- 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"},- ]+ assert all(+ not isinstance(item, ToolCallItem | ToolResultItem)+ or item.call_id != "call_bad"+ for item in request.items+ )+ assert any(+ isinstance(item, ToolCallItem) and item.call_id == "call_good"+ for item in request.items+ )+ assert any(+ isinstance(item, ToolResultItem) and item.call_id == "call_good"+ for item in request.items+ )-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(+def test_malformed_only_call_has_no_routable_message() -> None:+ with pytest.raises(ResponsesConversionError, match="must contain a message"):+ _ingest({- "model": "nvidia_nim/test-model",+ "model": "model","input": [{"type": "function_call",@@ -682,3 +545,54 @@ def test_responses_malformed_only_function_call_still_has_no_routable_message()],})+++ ("payload", "match"),+ [+ (+ {+ "model": "model",+ "input": "Hello",+ "tools": [{"type": "web_search_preview"}],+ },+ "tools\\[0\\]\\.type",+ ),+ (+ {+ "model": "model",+ "input": "Hello",+ "tools": [{"type": "web_search"}],+ "tool_choice": "required",+ },+ "needs at least one executable",+ ),+ (+ {+ "model": "model",+ "input": "Hello",+ "tool_choice": {"type": "web_search"},+ },+ "cannot be selected explicitly",+ ),+ ],+)+def test_unsupported_or_active_hosted_tool_semantics_are_rejected(+ payload: dict[str, object],+ match: str,+) -> None:+ with pytest.raises(ResponsesConversionError, match=match):+ _ingest(payload)++[email protected]("part_type", ["input_image", "input_file", "computer_call"])+def test_unsupported_responses_input_types_are_rejected_explicitly(+ part_type: str,+) -> None:+ with pytest.raises(ResponsesConversionError, match=part_type):+ _ingest(+ {+ "model": "model",+ "input": [{"type": part_type, "image_url": "https://example.invalid"}],+ }+ )diff --git a/tests/core/openai_responses/test_provider_input.py b/tests/core/openai_responses/test_provider_input.pyindex 5b2b7978..4480e1e4 100644--- a/tests/core/openai_responses/test_provider_input.py+++ b/tests/core/openai_responses/test_provider_input.py@@ -2,99 +2,154 @@ import jsonimport pytest-from free_claude_code.application.reasoning import client_reasoning_policy-from 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 ResponsesConversionError-from free_claude_code.core.openai_responses.provider_input import (- build_responses_provider_request,+from free_claude_code.core.inference import (+ Base64MediaSource,+ CacheControl,+ CustomTool,+ CustomToolFormat,+ CustomToolFormatType,+ DocumentContent,+ FileMediaSource,+ FunctionTool,+ ImageContent,+ InferenceRequest,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MessageItem,+ MessageRole,+ OpenAIChatExtension,+ ReasoningItem,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ReplayCompatibilityScope,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolChoice,+ ToolChoiceMode,+ ToolResultItem,)from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec+from free_claude_code.providers.openai_responses.request_codec import (+ ResponsesRequestEncodingError,+ build_responses_request_body,+)-_KEEP_ALL_THINKING_EDIT = {- "type": "clear_thinking_20251015",- "keep": "all",-}+_SCOPE = ReplayCompatibilityScope("openai_responses:test-model")-def test_build_responses_provider_request_preserves_multiturn_protocol() -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "max_tokens": 4096,- "system": "System instructions",- "messages": [- {- "role": "assistant",- "content": [- {"type": "thinking", "thinking": "summary"},- {"type": "redacted_thinking", "data": "opaque"},- {"type": "text", "text": "Calling a tool"},- {- "type": "tool_use",- "id": "call_1",- "name": "lookup",- "input": {"q": "value"},- },- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_1",- "content": {"answer": 42},- },- {"type": "text", "text": "Continue"},- {- "type": "image",- "source": {- "type": "base64",- "media_type": "image/png",- "data": "aGVsbG8=",- },- },- ],+def _body(+ request: InferenceRequest,+ *,+ scope: ReplayCompatibilityScope = _SCOPE,+ reasoning: ReasoningPolicy = ReasoningPolicy.provider_default(),+) -> dict[str, object]:+ return build_responses_request_body(+ request,+ provider_model="test-model",+ reasoning=reasoning,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=scope,+ )+++def test_responses_request_codec_preserves_multiturn_canonical_semantics() -> None:+ request = InferenceRequest(+ model="gateway-model",+ max_output_tokens=4_096,+ items=(+ InstructionItem(+ text="System instructions",+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ ),+ ReasoningItem(+ turn_id="turn_0",+ reasoning="summary",+ artifacts=(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload="opaque",+ scope=_SCOPE,+ ),+ ),+ ),+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.ASSISTANT,+ content=(TextContent("Calling a tool"),),+ ),+ ToolCallItem(+ turn_id="turn_0",+ call_id="call_1",+ kind=ToolCallKind.FUNCTION,+ name="lookup",+ input={"q": "value"},+ ),+ ToolResultItem(+ turn_id="turn_1",+ call_id="call_1",+ content={"answer": 42},+ ),+ MessageItem(+ turn_id="turn_1",+ role=MessageRole.USER,+ content=(+ TextContent("Continue"),+ ImageContent(+ Base64MediaSource(+ media_type="image/png",+ data="aGVsbG8=",+ )+ ),+ ),+ ),+ ),+ tools=(+ FunctionTool(+ name="lookup",+ description="Look up a value",+ input_schema={+ "type": "object",+ "properties": {"q": {"type": "string"}},},- ],- "tools": [- {- "name": "lookup",- "description": "Look up a value",- "input_schema": {- "type": "object",- "properties": {"q": {"type": "string"}},- },- }- ],- "tool_choice": {"type": "tool", "name": "lookup"},- }+ ),+ ),+ tool_choice=ToolChoice(+ ToolChoiceMode.SPECIFIC,+ kind=ToolCallKind.FUNCTION,+ name="lookup",+ ),)- body = build_responses_provider_request(+ body = _body(request,reasoning=ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),)- assert body["model"] == "gpt-test"+ assert body["model"] == "test-model"assert body["instructions"] == "System instructions"- assert body["max_output_tokens"] == 4096+ assert body["max_output_tokens"] == 4_096assert body["stream"] is Trueassert body["store"] is Falseassert body["include"] == ["reasoning.encrypted_content"]assert body["reasoning"] == {"effort": "xhigh", "summary": "auto"}assert body["tool_choice"] == {"type": "function", "name": "lookup"}- assert body["input"][0] == {+ input_items = body["input"]+ assert isinstance(input_items, list)+ assert input_items[0] == {"type": "reasoning","summary": [{"type": "summary_text", "text": "summary"}],"encrypted_content": "opaque",}- assert body["input"][1]["role"] == "assistant"- assert body["input"][2] == {+ assert input_items[1]["role"] == "assistant"+ assert input_items[2] == {"type": "function_call","call_id": "call_1","name": "lookup",@@ -102,427 +157,224 @@ def test_build_responses_provider_request_preserves_multiturn_protocol() -> None{"q": "value"}, ensure_ascii=False, separators=(",", ":")),}- assert body["input"][3] == {+ assert input_items[3] == {"type": "function_call_output","call_id": "call_1","output": '{"answer": 42}',}- assert body["input"][4]["content"][1] == {+ assert input_items[4]["content"][1] == {"type": "input_image","image_url": "data:image/png;base64,aGVsbG8=",}-def test_build_responses_provider_request_accepts_claude_client_controls() -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "thinking": {"type": "adaptive", "display": "omitted"},- "context_management": {"edits": [_KEEP_ALL_THINKING_EDIT]},- "output_config": {"effort": "high"},- }- )- snapshot = request.model_dump()-- body = build_responses_provider_request(- request,- reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),- )-- assert body["reasoning"] == {"effort": "high", "summary": "auto"}- assert "context_management" not in body- assert "output_config" not in body- assert request.model_dump() == snapshot---def test_build_responses_provider_request_materializes_auto_tool_choice() -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "Use the echo tool."}],- "tools": [- {- "name": "echo",- "description": "Echo a value.",- "input_schema": {- "type": "object",- "properties": {"value": {"type": "string"}},- "required": ["value"],- },- }- ],- }+def test_only_scope_matched_reasoning_artifact_is_replayed() -> None:+ request = InferenceRequest(+ model="gateway-model",+ items=(+ ReasoningItem(+ turn_id="turn_0",+ reasoning="summary",+ artifacts=(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload="opaque",+ scope=_SCOPE,+ ),+ ),+ ),+ MessageItem(+ turn_id="turn_1",+ role=MessageRole.USER,+ content=(TextContent("Continue"),),+ ),+ ),)- body = build_responses_provider_request(+ matching = _body(request)+ incompatible = _body(request,- reasoning=ReasoningPolicy.off(),+ scope=ReplayCompatibilityScope("openai_responses:other-model"),)- assert body["tool_choice"] == "auto"---def test_build_responses_provider_request_omits_choice_without_tools() -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "Hello"}],- }+ matching_input = matching["input"]+ incompatible_input = incompatible["input"]+ assert isinstance(matching_input, list)+ assert isinstance(incompatible_input, list)+ assert matching_input[0]["encrypted_content"] == "opaque"+ assert "encrypted_content" not in incompatible_input[0]+++def test_namespaced_and_custom_tool_identity_is_encoded_once() -> None:+ request = InferenceRequest(+ model="gateway-model",+ items=(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("Use tools"),),+ ),+ ),+ tools=(+ FunctionTool(+ name="lookup",+ namespace="mcp__db",+ description=None,+ input_schema={"type": "object"},+ ),+ CustomTool(+ name="patch",+ namespace="repo",+ description="Apply a patch",+ format=CustomToolFormat(+ CustomToolFormatType.GRAMMAR,+ syntax="lark",+ definition="start: /.+/",+ ),+ ),+ ),+ tool_choice=ToolChoice(+ ToolChoiceMode.SPECIFIC,+ kind=ToolCallKind.CUSTOM,+ name="patch",+ namespace="repo",+ ),)- body = build_responses_provider_request(- request,- reasoning=ReasoningPolicy.off(),- )+ body = _body(request)- assert "tools" not in body- assert "tool_choice" not in body+ tools = body["tools"]+ assert isinstance(tools, list)+ assert [tool["name"] for tool in tools] == ["mcp__db__lookup", "repo__patch"]+ assert body["tool_choice"] == {"type": "custom", "name": "repo__patch"}-def test_build_responses_provider_request_uses_resolved_reasoning_policy() -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "output_config": {"effort": "low"},- }+def test_auto_choice_is_materialized_only_when_tools_exist() -> None:+ message = MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("Hello"),),)-- body = build_responses_provider_request(- request,- reasoning=ReasoningPolicy.on(effort=ReasoningEffort.MAX),+ without_tools = _body(InferenceRequest(model="model", items=(message,)))+ with_tools = _body(+ InferenceRequest(+ model="model",+ items=(message,),+ tools=(+ FunctionTool(+ name="echo",+ description=None,+ input_schema={"type": "object"},+ ),+ ),+ ))- assert body["reasoning"] == {"effort": "max", "summary": "auto"}+ assert "tool_choice" not in without_tools+ assert with_tools["tool_choice"] == "auto"- "context_management",- [- None,- {},- {"edits": []},- {"edits": [_KEEP_ALL_THINKING_EDIT]},- {"edits": [_KEEP_ALL_THINKING_EDIT, _KEEP_ALL_THINKING_EDIT]},- ],-)-def test_build_responses_provider_request_accepts_noop_context_management(- context_management: dict[str, object] | None,-) -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "context_management": context_management,- }+def test_resolved_reasoning_policy_is_the_only_upstream_reasoning_owner() -> None:+ request = InferenceRequest(+ model="model",+ items=(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("Hello"),),+ ),+ ),)- body = build_responses_provider_request(+ assert _body(request, reasoning=ReasoningPolicy.off())["reasoning"] == {+ "effort": "none"+ }+ assert _body(request,- reasoning=ReasoningPolicy.provider_default(),- )-- assert "context_management" not in body--- "context_management",- [- {"edits": [{"type": "clear_thinking_20251015"}]},- {- "edits": [- {- "type": "clear_thinking_20251015",- "keep": {"type": "thinking_turns", "value": 2},- }- ]- },- {"edits": [{"type": "clear_tool_uses_20250919"}]},- {"edits": [{"type": "unknown_edit", "keep": "all"}]},- {- "edits": [- {- **_KEEP_ALL_THINKING_EDIT,- "extra": True,- }- ]- },- {"edits": [], "extra": True},- {"edits": None},- {"edits": {}},- {"edits": "not-a-list"},- ],-)-def test_build_responses_provider_request_rejects_active_or_malformed_context(- context_management: dict[str, object],-) -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "context_management": context_management,- }- )-- with pytest.raises(ResponsesConversionError, match="context_management"):- build_responses_provider_request(- request,- reasoning=ReasoningPolicy.provider_default(),- )+ reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ )["reasoning"] == {"effort": "high", "summary": "auto"}@pytest.mark.parametrize(- ("effort", "reasoning", "expected"),+ ("canonical", "match"),[(- "high",- ReasoningPolicy.on(effort=ReasoningEffort.HIGH),- {"effort": "high", "summary": "auto"},+ InferenceRequest(+ model="model",+ items=(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("Hello"),),+ ),+ ),+ stop_sequences=("stop",),+ ),+ "stop_sequences",),- ("none", ReasoningPolicy.off(), {"effort": "none"}),- ("future", ReasoningPolicy.provider_default(), None),- ],-)-def test_build_responses_provider_request_accepts_application_owned_effort(- effort: str,- reasoning: ReasoningPolicy,- expected: dict[str, str] | None,-) -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "output_config": {"effort": effort},- }- )-- body = build_responses_provider_request(request, reasoning=reasoning)-- assert body.get("reasoning") == expected- assert "output_config" not in body--- ("output_config", "unsupported_path"),- [- ({"format": {"type": "json_schema"}}, "output_config.format"),(- {"effort": "high", "format": {"type": "json_schema"}},- "output_config.format",+ InferenceRequest(+ model="model",+ items=(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(DocumentContent(FileMediaSource("file_1")),),+ ),+ ),+ ),+ "document",+ ),+ (+ InferenceRequest(+ model="model",+ items=(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("Hello", CacheControl()),),+ ),+ ),+ ),+ "cache_control",+ ),+ (+ InferenceRequest(+ model="model",+ items=(+ MessageItem(+ turn_id="turn_0",+ role=MessageRole.USER,+ content=(TextContent("Hello"),),+ ),+ ),+ extensions=(OpenAIChatExtension({"extension": True}),),+ ),+ "extensions",),- ({"future_control": True}, "output_config.future_control"),- ],-)-def test_build_responses_provider_request_rejects_unconsumed_output_config(- output_config: dict[str, object],- unsupported_path: str,-) -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "output_config": output_config,- }- )-- with pytest.raises(ResponsesConversionError, match=unsupported_path):- build_responses_provider_request(- request,- reasoning=ReasoningPolicy.provider_default(),- )---def test_responses_provider_request_uses_one_portable_tool_alias() -> None:- original = "mcp__responses_provider__" + "x" * 70- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "call_1",- "name": original,- "input": {"q": "value"},- }- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_1",- "content": "done",- }- ],- },- ],- "tools": [- {- "name": original,- "description": "Long tool",- "input_schema": {"type": "object"},- },- {"name": "safe_tool", "input_schema": {"type": "object"}},- ],- "tool_choice": {"type": "tool", "name": original},- }- )- snapshot = request.model_dump()-- body = build_responses_provider_request(- request,- reasoning=ReasoningPolicy.provider_default(),- )-- alias = body["tools"][0]["name"]- assert alias != original- assert len(alias) <= 64- assert body["tools"][1]["name"] == "safe_tool"- assert body["tool_choice"] == {"type": "function", "name": alias}- function_call = next(- item for item in body["input"] if item["type"] == "function_call"- )- assert function_call["name"] == alias- assert function_call["call_id"] == "call_1"- assert function_call["arguments"] == '{"q":"value"}'- 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--- ("field", "value"),- [- ("stop_sequences", ["stop"]),- ("top_k", 4),- ("mcp_servers", [{"name": "server"}]),- ("extra_body", {"unknown": True}),],)-def test_build_responses_provider_request_rejects_lossy_fields(- field: str, value: object+def test_unrepresentable_canonical_semantics_are_rejected_before_io(+ canonical: InferenceRequest,+ match: str,) -> None:- payload = {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- field: value,- }-- with pytest.raises(ResponsesConversionError, match=field):- build_responses_provider_request(- MessagesRequest.model_validate(payload),- reasoning=ReasoningPolicy.provider_default(),- )---def test_build_responses_provider_request_rejects_provider_managed_tools() -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "tools": [- {- "name": "web_search",- "type": "web_search_20250305",- "input_schema": {"type": "object"},- }- ],- }- )-- with pytest.raises(ResponsesConversionError, match="web_search_20250305"):- build_responses_provider_request(- request,- reasoning=ReasoningPolicy.provider_default(),- )---def test_build_responses_provider_request_rejects_unknown_request_fields() -> None:- request = MessagesRequest.model_validate(- {- "model": "gpt-test",- "messages": [{"role": "user", "content": "hello"}],- "future_field": True,- }+ with pytest.raises(ResponsesRequestEncodingError, match=match):+ _body(canonical)+++def test_codec_requires_a_conversational_input_item() -> None:+ request = InferenceRequest(+ model="model",+ items=(+ InstructionItem(+ text="System only",+ origin=InstructionOrigin.SYSTEM,+ placement=InstructionPlacement.TOP_LEVEL,+ ),+ ),)- with pytest.raises(ResponsesConversionError, match="future_field"):- build_responses_provider_request(- request,- reasoning=ReasoningPolicy.provider_default(),- )+ with pytest.raises(ResponsesRequestEncodingError, match="conversational input"):+ _body(request)diff --git a/tests/core/openai_responses/test_provider_stream.py b/tests/core/openai_responses/test_provider_stream.pyindex 79c2a1cf..0fa35f8f 100644--- a/tests/core/openai_responses/test_provider_stream.py+++ b/tests/core/openai_responses/test_provider_stream.py@@ -1,23 +1,31 @@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,thinking_content,)-from free_claude_code.core.openai_responses.provider_events import (+from free_claude_code.core.inference import (+ ReplayAttachment,+ ReplayCompatibilityScope,+)+from free_claude_code.core.replay_envelope import decode_replay_envelope+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec+from free_claude_code.providers.openai_responses.events import (ResponsesEventDecoder,ResponsesStreamFailure,)from tests.inference_support import present_anthropic+_REPLAY_SCOPE = ReplayCompatibilityScope("openai_responses:test-model")+def test_responses_decoder_preserves_reasoning_tools_usage_and_ids() -> None:stream = ResponsesEventDecoder(response_id="response_test",model="openai/gpt-test",input_tokens=12,+ replay_scope=_REPLAY_SCOPE,)output = stream.start()output.extend(@@ -111,7 +119,15 @@ def test_responses_decoder_preserves_reasoning_tools_usage_and_ids() -> None:for event in eventsif event.event == "content_block_start"]- assert {"type": "redacted_thinking", "data": "opaque"} in starts+ redacted = next(block for block in starts if block["type"] == "redacted_thinking")+ assert isinstance(redacted["data"], str)+ artifacts = decode_replay_envelope(+ redacted["data"],+ attachment=ReplayAttachment.REASONING,+ )+ assert artifacts is not None+ assert [artifact.payload for artifact in artifacts] == ["opaque"]+ assert [artifact.scope for artifact in artifacts] == [_REPLAY_SCOPE]assert {"type": "tool_use","id": "call_1",@@ -150,6 +166,7 @@ def test_responses_decoder_ignores_invalid_cache_partitions(response_id="response_test",model="openai/gpt-test",input_tokens=12,+ replay_scope=_REPLAY_SCOPE,)output = stream.start()output.extend(@@ -183,6 +200,7 @@ def test_responses_decoder_surfaces_failed_event() -> None:response_id="response_test",model="gpt-test",input_tokens=0,+ replay_scope=_REPLAY_SCOPE,)with pytest.raises(ResponsesStreamFailure, match="capacity") as exc_info:@@ -212,6 +230,7 @@ def test_responses_decoder_restores_added_and_done_only_tool_names() -> None:model="gpt-test",input_tokens=0,tool_names=codec,+ replay_scope=_REPLAY_SCOPE,)output = stream.start()output.extend(diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.pyindex d4d0f082..6723cdbf 100644--- a/tests/core/openai_responses/test_sse.py+++ b/tests/core/openai_responses/test_sse.py@@ -17,11 +17,12 @@ from free_claude_code.core.inference import (ReplayAttachment,ResponseStarted,)-from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.openai_responses import ResponsesPresentationSnapshotfrom free_claude_code.core.openai_responses.presenter import (ResponsesEventPresenter,iter_responses_sse_from_events,)+from free_claude_code.core.replay_envelope import decode_replay_envelopefrom tests.inference_support import reported_usage, text_event_stream@@ -57,14 +58,15 @@ class _CloseTrackingEvents:raise self._close_error-def _request(**overrides: object) -> OpenAIResponsesRequest:- payload: dict[str, object] = {- "model": "nvidia_nim/test-model",- "input": "hello",- "stream": True,- }- payload.update(overrides)- return OpenAIResponsesRequest.model_validate(payload)+def _snapshot() -> ResponsesPresentationSnapshot:+ return ResponsesPresentationSnapshot(+ model="nvidia_nim/test-model",+ parallel_tool_calls=True,+ tool_choice="auto",+ temperature=None,+ top_p=None,+ max_output_tokens=None,+ )async def _aiter(events: list[InferenceEvent]) -> AsyncIterator[InferenceEvent]:@@ -77,7 +79,7 @@ async def _collect(events: list[InferenceEvent]) -> list[str]:chunkasync for chunk in iter_responses_sse_from_events(_aiter(events),- _request(),+ _snapshot(),)]@@ -149,7 +151,14 @@ async def test_reasoning_replay_and_tool_call_remain_semantic_until_presented()final = parsed[-1].data["response"]reasoning, tool = final["output"]assert reasoning["type"] == "reasoning"- assert reasoning["encrypted_content"] == "opaque"+ encrypted = reasoning["encrypted_content"]+ assert isinstance(encrypted, str)+ artifacts = decode_replay_envelope(+ encrypted,+ attachment=ReplayAttachment.REASONING,+ )+ assert artifacts is not None+ assert [artifact.payload for artifact in artifacts] == ["opaque"]assert tool == {"id": tool["id"],"type": "function_call",@@ -195,7 +204,7 @@ async def test_pre_start_failure_is_not_hidden_in_a_responses_envelope() -> Nonesource = _CloseTrackingEvents([], iteration_error=failure)with pytest.raises(ExecutionFailure) as exc_info:- [chunk async for chunk in iter_responses_sse_from_events(source, _request())]+ [chunk async for chunk in iter_responses_sse_from_events(source, _snapshot())]assert exc_info.value is failureassert source.close_calls == 1@@ -219,7 +228,7 @@ async def test_post_start_failure_becomes_one_terminal_response_event() -> None:chunkasync for chunk in iter_responses_sse_from_events(source,- _request(),+ _snapshot(),on_post_start_terminal_failure=observed.append,)]@@ -237,7 +246,7 @@ async def test_post_start_failure_becomes_one_terminal_response_event() -> None:@pytest.mark.asyncioasync def test_early_consumer_close_closes_canonical_source_once() -> None:source = _CloseTrackingEvents(text_event_stream("hello"))- stream = iter_responses_sse_from_events(source, _request())+ stream = iter_responses_sse_from_events(source, _snapshot())assert parse_sse_text(await anext(stream))[0].event == "response.created"assert isinstance(stream, AsyncCloseable)@@ -247,7 +256,7 @@ async def test_early_consumer_close_closes_canonical_source_once() -> None:def test_presenter_rejects_events_after_terminal_completion() -> None:- presenter = ResponsesEventPresenter(_request())+ presenter = ResponsesEventPresenter(_snapshot())for event in text_event_stream("done"):presenter.present(event)diff --git a/tests/core/test_protocol_model_ownership.py b/tests/core/test_protocol_model_ownership.pyindex 4b5921b6..08c61a40 100644--- a/tests/core/test_protocol_model_ownership.py+++ b/tests/core/test_protocol_model_ownership.py@@ -2,6 +2,9 @@import subprocessimport sys+from dataclasses import FrozenInstanceError++import pytestfrom free_claude_code.core.anthropic import (MessagesRequest as PublicMessagesRequest,@@ -11,6 +14,23 @@ from free_claude_code.core.anthropic import (TokenCountResponse,)from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import (+ FunctionTool,+ InferenceRequest,+ MessageItem,+ MessageRole,+ OpenAIChatExtension,+ ReasoningItem,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolResultItem,+ inference_request_snapshot,+)from free_claude_code.core.openai_responses import (OpenAIResponsesRequest as PublicOpenAIResponsesRequest,)@@ -53,6 +73,116 @@ def test_anthropic_response_models_are_protocol_owned() -> None:assert TokenCountResponse.__module__ == "free_claude_code.core.anthropic.models"+def test_wire_request_models_do_not_carry_internal_route_state() -> None:+ internal_fields = {+ "original_model",+ "provider_model",+ "resolved_provider_model",+ "resolved_reasoning",+ }++ assert internal_fields.isdisjoint(MessagesRequest.model_fields)+ assert internal_fields.isdisjoint(OpenAIResponsesRequest.model_fields)+++def test_canonical_request_owns_recursive_copies_and_is_frozen() -> None:+ arguments = {"nested": {"value": 1}}+ result = {"items": ["first"]}+ schema = {"type": "object", "properties": {"value": {"type": "integer"}}}+ metadata = {"trace": {"enabled": True}}+ extension = {"service": {"tier": "free"}}+ request = InferenceRequest(+ model="client-model",+ items=(+ MessageItem("turn_0", MessageRole.USER, (TextContent("Hello"),)),+ ToolCallItem(+ "turn_1",+ "call_1",+ ToolCallKind.FUNCTION,+ "lookup",+ arguments,+ ),+ ToolResultItem("turn_2", "call_1", result),+ ),+ tools=(FunctionTool("lookup", None, schema),),+ metadata=metadata,+ extensions=(OpenAIChatExtension(extension),),+ )++ arguments["nested"] = {"value": 2}+ result["items"] = ["changed"]+ schema["properties"] = {}+ metadata["trace"] = {"enabled": False}+ extension["service"] = {"tier": "paid"}++ call = request.items[1]+ tool_result = request.items[2]+ assert isinstance(call, ToolCallItem)+ assert call.input == {"nested": {"value": 1}}+ assert isinstance(tool_result, ToolResultItem)+ assert tool_result.content == {"items": ("first",)}+ tool = request.tools[0]+ assert isinstance(tool, FunctionTool)+ assert tool.input_schema["properties"] == {"value": {"type": "integer"}}+ assert request.metadata == {"trace": {"enabled": True}}+ assert request.openai_chat_extension is not None+ assert request.openai_chat_extension.extra_body == {"service": {"tier": "free"}}+ field_name = "model"+ with pytest.raises(FrozenInstanceError):+ setattr(request, field_name, "other-model")+++def test_canonical_request_snapshot_contains_structure_but_no_client_payloads() -> None:+ request = InferenceRequest(+ model="public-model",+ items=(+ MessageItem(+ "turn_0",+ MessageRole.USER,+ (TextContent("private-prompt"),),+ ),+ ReasoningItem(+ "turn_1",+ "private-reasoning",+ artifacts=(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload="private-replay",+ ),+ ),+ ),+ ToolCallItem(+ "turn_1",+ "call_1",+ ToolCallKind.FUNCTION,+ "lookup",+ {"secret": "private-tool-arguments"},+ ),+ ),+ tools=(FunctionTool("lookup", None, {"type": "object"}),),+ metadata={"secret": "private-metadata"},+ extensions=(OpenAIChatExtension({"secret": "private-extra-body"}),),+ )++ snapshot = inference_request_snapshot(request)+ rendered = repr(snapshot)++ assert snapshot["item_count"] == 3+ assert snapshot["message_count"] == 2+ assert snapshot["tool_count"] == 1+ for secret in (+ "private-prompt",+ "private-reasoning",+ "private-replay",+ "private-tool-arguments",+ "private-metadata",+ "private-extra-body",+ ):+ assert secret not in rendered++def test_protocol_facades_are_import_order_independent() -> None:import_orders = ((diff --git a/tests/core/test_replay_envelope.py b/tests/core/test_replay_envelope.pynew file mode 100644index 00000000..7c304cc2--- /dev/null+++ b/tests/core/test_replay_envelope.py@@ -0,0 +1,285 @@+import base64+import json+from collections.abc import Mapping++import pytest++from free_claude_code.core.inference import (+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ReplayCompatibilityScope,+)+from free_claude_code.core.replay_envelope import (+ REPLAY_ENVELOPE_PREFIX,+ ReplayEnvelopeError,+ decode_replay_envelope,+ encode_replay_envelope,+)+++def _carrier(payload: object) -> str:+ raw = json.dumps(payload, separators=(",", ":")).encode()+ token = base64.urlsafe_b64encode(raw).decode().rstrip("=")+ return f"{REPLAY_ENVELOPE_PREFIX}{token}"+++def _artifact_payload(+ *,+ origin: str = "openai",+ kind: str = "encrypted_reasoning",+ attachment: str = "reasoning",+ scope: object = "openai_responses:model",+ payload: object = "opaque",+) -> dict[str, object]:+ return {+ "origin": origin,+ "kind": kind,+ "attachment": attachment,+ "scope": scope,+ "payload": payload,+ }+++ ("kind", "attachment"),+ [+ (ReplayArtifactKind.THINKING_SIGNATURE, ReplayAttachment.REASONING),+ (ReplayArtifactKind.REDACTED_THINKING, ReplayAttachment.REASONING),+ (ReplayArtifactKind.ENCRYPTED_REASONING, ReplayAttachment.REASONING),+ (ReplayArtifactKind.REASONING_DETAILS, ReplayAttachment.REASONING),+ (ReplayArtifactKind.THOUGHT_SIGNATURE, ReplayAttachment.TOOL_CALL),+ (ReplayArtifactKind.TOOL_EXTRA_CONTENT, ReplayAttachment.TOOL_CALL),+ ],+)+def test_each_replay_artifact_kind_round_trips(+ kind: ReplayArtifactKind,+ attachment: ReplayAttachment,+) -> None:+ artifact = ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,+ kind=kind,+ attachment=attachment,+ scope=ReplayCompatibilityScope("provider:model"),+ payload={"opaque": [kind.value, 1, True, None]},+ )++ assert decode_replay_envelope(+ encode_replay_envelope((artifact,)), attachment=attachment+ ) == (artifact,)+++ "attachment",+ [ReplayAttachment.REASONING, ReplayAttachment.TOOL_CALL],+)+def test_multiple_artifacts_keep_order_and_encode_deterministically(+ attachment: ReplayAttachment,+) -> None:+ origins = tuple(ReplayArtifactOrigin)+ kinds = (+ (+ ReplayArtifactKind.THINKING_SIGNATURE,+ ReplayArtifactKind.REDACTED_THINKING,+ ReplayArtifactKind.ENCRYPTED_REASONING,+ ReplayArtifactKind.REASONING_DETAILS,+ )+ if attachment is ReplayAttachment.REASONING+ else (+ ReplayArtifactKind.THOUGHT_SIGNATURE,+ ReplayArtifactKind.TOOL_EXTRA_CONTENT,+ )+ )+ artifacts = tuple(+ ReplayArtifact(+ origin=origins[index % len(origins)],+ kind=kind,+ attachment=attachment,+ scope=(ReplayCompatibilityScope("provider:model") if index else None),+ payload={"index": index},+ )+ for index, kind in enumerate(kinds)+ )++ first = encode_replay_envelope(artifacts)+ second = encode_replay_envelope(artifacts)++ assert first == second+ assert decode_replay_envelope(first, attachment=attachment) == artifacts+++def test_legacy_raw_replay_value_is_not_claimed_by_the_envelope_codec() -> None:+ assert (+ decode_replay_envelope(+ "provider-owned-opaque-value",+ attachment=ReplayAttachment.REASONING,+ )+ is None+ )+++def test_empty_artifact_sequence_cannot_be_encoded() -> None:+ with pytest.raises(ValueError, match="at least one artifact"):+ encode_replay_envelope(())+++ ("value", "match"),+ [+ (REPLAY_ENVELOPE_PREFIX, "payload is empty"),+ (f"{REPLAY_ENVELOPE_PREFIX}*", "valid base64url"),+ (+ f"{REPLAY_ENVELOPE_PREFIX}"+ + base64.urlsafe_b64encode(b"\xff").decode().rstrip("="),+ "valid UTF-8 JSON",+ ),+ (+ f"{REPLAY_ENVELOPE_PREFIX}"+ + base64.urlsafe_b64encode(b"{").decode().rstrip("="),+ "valid UTF-8 JSON",+ ),+ (_carrier([]), "top-level schema"),+ (_carrier({"version": 1}), "top-level schema"),+ (_carrier({"version": 2, "artifacts": []}), "version is unsupported"),+ (+ _carrier({"version": 1, "artifacts": []}),+ "artifacts must be a non-empty list",+ ),+ (+ _carrier({"version": 1, "artifacts": ["opaque"]}),+ "artifacts\\[0\\] has an invalid schema",+ ),+ (+ _carrier(+ {+ "version": 1,+ "artifacts": [{**_artifact_payload(), "extra": True}],+ }+ ),+ "artifacts\\[0\\] has an invalid schema",+ ),+ (+ _carrier(+ {+ "version": 1,+ "artifacts": [_artifact_payload(origin="unknown")],+ }+ ),+ "unknown artifact value",+ ),+ (+ _carrier(+ {+ "version": 1,+ "artifacts": [_artifact_payload(kind="unknown")],+ }+ ),+ "unknown artifact value",+ ),+ (+ _carrier(+ {+ "version": 1,+ "artifacts": [_artifact_payload(attachment="unknown")],+ }+ ),+ "unknown artifact value",+ ),+ (+ _carrier(+ {+ "version": 1,+ "artifacts": [_artifact_payload(scope="")],+ }+ ),+ "scope must be null or a non-empty string",+ ),+ (+ _carrier(+ {+ "version": 1,+ "artifacts": [_artifact_payload(scope=42)],+ }+ ),+ "scope must be null or a non-empty string",+ ),+ (+ _carrier(+ {+ "version": 1,+ "artifacts": [_artifact_payload(payload=float("nan"))],+ }+ ),+ "payload is not valid JSON",+ ),+ ],+)+def test_malformed_envelopes_fail_with_stable_safe_errors(+ value: str,+ match: str,+) -> None:+ with pytest.raises(ReplayEnvelopeError, match=match):+ decode_replay_envelope(value, attachment=ReplayAttachment.REASONING)+++def test_carrier_attachment_must_match_every_artifact() -> None:+ value = _carrier(+ {+ "version": 1,+ "artifacts": [_artifact_payload(attachment="tool_call")],+ }+ )++ with pytest.raises(ReplayEnvelopeError, match="does not match its carrier"):+ decode_replay_envelope(value, attachment=ReplayAttachment.REASONING)+++def test_encode_rejects_non_finite_json_numbers() -> None:+ artifact = ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload=float("inf"),+ )++ with pytest.raises(ValueError, match="Out of range float values"):+ encode_replay_envelope((artifact,))+++def test_encoded_and_decoded_size_limits_are_enforced() -> None:+ artifact = ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload="x" * 1_048_576,+ )+ with pytest.raises(ValueError, match="size limit"):+ encode_replay_envelope((artifact,))++ oversized = base64.urlsafe_b64encode(b"x" * 1_048_577).decode().rstrip("=")+ with pytest.raises(ReplayEnvelopeError, match="size limit"):+ decode_replay_envelope(+ f"{REPLAY_ENVELOPE_PREFIX}{oversized}",+ attachment=ReplayAttachment.REASONING,+ )+++def test_errors_and_logs_do_not_expose_replay_payload(+ caplog: pytest.LogCaptureFixture,+) -> None:+ secret = "private-replay-material"+ raw_artifact = _artifact_payload(payload={"secret": secret})+ assert isinstance(raw_artifact, Mapping)+ value = _carrier(+ {+ "version": 1,+ "artifacts": [{**raw_artifact, "unexpected": True}],+ }+ )++ with pytest.raises(ReplayEnvelopeError) as captured:+ decode_replay_envelope(value, attachment=ReplayAttachment.REASONING)++ assert secret not in str(captured.value)+ assert secret not in caplog.textdiff --git a/tests/providers/request_factory.py b/tests/providers/request_factory.pyindex bce4cff2..9cb2af41 100644--- a/tests/providers/request_factory.py+++ b/tests/providers/request_factory.py@@ -1,15 +1,34 @@-"""Concrete Anthropic request factory for provider tests."""--from typing import Any+"""Canonical request factories for provider tests."""+from free_claude_code.core.anthropic import messages_to_inference_requestfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequest++type ProviderTestRequest = MessagesRequest | InferenceRequest+++def canonical_request(request: ProviderTestRequest) -> InferenceRequest:+ """Cross the production Messages ingress at a provider-test boundary."""++ if isinstance(request, InferenceRequest):+ return request+ return messages_to_inference_request(request)def make_messages_request(- model: str = "test-model", **overrides: Any+ model: str = "test-model", **overrides: object+) -> InferenceRequest:+ """Build canonical provider input through the real Messages ingress."""++ return messages_to_inference_request(make_messages_wire_request(model, **overrides))+++def make_messages_wire_request(+ model: str = "test-model", **overrides: object) -> MessagesRequest:- """Build a real Messages request with provider-test defaults."""- data: dict[str, Any] = {+ """Build a real Messages wire request with provider-test defaults."""++ data: dict[str, object] = {"model": model,"messages": [{"role": "user", "content": "Hello"}],"max_tokens": 100,diff --git a/tests/providers/support.py b/tests/providers/support.pyindex f6a7e372..d5a99a80 100644--- a/tests/providers/support.py+++ b/tests/providers/support.py@@ -7,6 +7,7 @@ from openai import AsyncOpenAIfrom free_claude_code.application.reasoning import client_reasoning_policyfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -14,6 +15,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProvider,create_openai_chat_provider,)+from tests.providers.request_factory import canonical_requestREASONING_DEFAULT = ReasoningPolicy.provider_default()REASONING_ON = ReasoningPolicy.on()@@ -112,7 +114,9 @@ def profiled_provider()-def reasoning_for(request: MessagesRequest) -> ReasoningPolicy:+def reasoning_for(+ request: MessagesRequest | InferenceRequest,+) -> ReasoningPolicy:"""Resolve provider-test input through the production client boundary."""- return client_reasoning_policy(request)+ return client_reasoning_policy(canonical_request(request).reasoning)diff --git a/tests/providers/test_agnes.py b/tests/providers/test_agnes.pyindex 53e62e26..2e0c7699 100644--- a/tests/providers/test_agnes.py+++ b/tests/providers/test_agnes.py@@ -14,6 +14,7 @@ from free_claude_code.config.provider_catalog import AGNES_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -89,8 +90,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images()body = agnes_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "agnes-2.0-flash"@@ -117,7 +119,9 @@ def test_build_request_body_encodes_documented_thinking_control() -> None:request = _request()- body = agnes_provider._build_request_body(request, reasoning=reasoning)+ body = agnes_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )assert body["extra_body"] == {"chat_template_kwargs": {"enable_thinking": enabled}}@@ -128,8 +132,9 @@ def test_build_request_body_omits_thinking_control_for_provider_default(request = _request()body = agnes_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(request).model,)assert "extra_body" not in body@@ -153,8 +158,9 @@ def test_build_request_body_replays_reasoning_in_content_not_undocumented_field()body = agnes_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assistant = body["messages"][1]@@ -172,7 +178,11 @@ def test_build_request_body_rejects_caller_reasoning_override(request = _request(extra_body={field: "caller-owned"})with pytest.raises(InvalidRequestError, match="must not override reasoning"):- agnes_provider._build_request_body(request, reasoning=REASONING_ON)+ agnes_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )@pytest.mark.asynciodiff --git a/tests/providers/test_azure_openai.py b/tests/providers/test_azure_openai.pyindex edbda2be..cbc565d7 100644--- a/tests/providers/test_azure_openai.py+++ b/tests/providers/test_azure_openai.py@@ -7,7 +7,7 @@ import pytestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.openai_chat import OpenAIChatProvider-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -63,8 +63,9 @@ def test_request_uses_deployment_name_modern_token_field_tools_and_reasoning() -)body = _provider()._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(request).model,)assert body["model"] == AZURE_OPENAI_DEPLOYMENT@@ -89,12 +90,21 @@ def test_reasoning_uses_azure_supported_provider_vocabulary(expected: str,) -> None:body = _provider()._build_request_body(- make_messages_request(- AZURE_OPENAI_DEPLOYMENT,- temperature=None,- top_p=None,+ canonical_request(+ make_messages_request(+ AZURE_OPENAI_DEPLOYMENT,+ temperature=None,+ top_p=None,+ )),reasoning=policy,+ provider_model=(+ make_messages_request(+ AZURE_OPENAI_DEPLOYMENT,+ temperature=None,+ top_p=None,+ )+ ).model,)assert body["reasoning_effort"] == expected@@ -117,7 +127,9 @@ def test_reasoning_history_replays_as_portable_think_tags() -> None:],)- body = _provider()._build_request_body(request)+ body = _provider()._build_request_body(+ canonical_request(request), provider_model=(request).model+ )assistant = next(message for message in body["messages"] if message["role"] == "assistant")diff --git a/tests/providers/test_bedrock.py b/tests/providers/test_bedrock.pyindex d7562ce2..d629d7db 100644--- a/tests/providers/test_bedrock.py+++ b/tests/providers/test_bedrock.py@@ -8,7 +8,7 @@ import pytestfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import BEDROCK_DEFAULT_BASEfrom free_claude_code.providers.openai_chat import OpenAIChatProvider-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -75,7 +75,9 @@ def test_request_uses_portable_chat_fields_without_invented_reasoning() -> None:],)- body = _provider()._build_request_body(request)+ body = _provider()._build_request_body(+ canonical_request(request), provider_model=(request).model+ )assert body["model"] == BEDROCK_MODELassert body["messages"][0] == {"role": "system", "content": "System prompt"}@@ -116,7 +118,9 @@ def test_reasoning_history_replays_as_portable_think_tags() -> None:],)- body = _provider()._build_request_body(request)+ body = _provider()._build_request_body(+ canonical_request(request), provider_model=(request).model+ )assistant = next(message for message in body["messages"] if message["role"] == "assistant")diff --git a/tests/providers/test_cerebras.py b/tests/providers/test_cerebras.pyindex dd5ed871..6e988ae8 100644--- a/tests/providers/test_cerebras.py+++ b/tests/providers/test_cerebras.py@@ -6,7 +6,7 @@ import pytestfrom free_claude_code.config.provider_catalog import CEREBRAS_DEFAULT_BASEfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -89,7 +89,9 @@ def test_default_base_url_constant():def test_build_request_body_basic(cerebras_provider):"""Basic request body conversion attaches system message from Claude request."""req = make_request()- body = cerebras_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = cerebras_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert body["model"] == "llama3.1-8b"assert body["messages"][0]["role"] == "system"@@ -97,7 +99,10 @@ def test_build_request_body_basic(cerebras_provider):def test_build_request_body_replays_reasoning_as_tagged_content(cerebras_provider):- body = cerebras_provider._build_request_body(make_reasoning_tool_history_request())+ body = cerebras_provider._build_request_body(+ canonical_request(make_reasoning_tool_history_request()),+ provider_model=(make_reasoning_tool_history_request()).model,+ )assistant = next(message for message in body["messages"] if message["role"] == "assistant"@@ -129,7 +134,9 @@ def test_replay_is_independent_of_current_turn_reasoning_control():admission=immediate_admission(),)body = provider._build_request_body(- make_reasoning_tool_history_request(), reasoning=REASONING_OFF+ canonical_request(make_reasoning_tool_history_request()),+ reasoning=REASONING_OFF,+ provider_model=(make_reasoning_tool_history_request()).model,)assistant = next(@@ -153,7 +160,11 @@ def test_build_request_body_remaps_max_tokens_preserves_message_name(cerebras_pr"max_tokens": 42,}req = make_request()- body = cerebras_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = cerebras_provider._build_request_body(+ canonical_request(req),+ reasoning=reasoning_for(req),+ provider_model=(req).model,+ )assert body["messages"][0].get("name") == "alice"assert body.get("max_tokens") is None@@ -170,7 +181,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(cerebras_prov"max_completion_tokens": 77,"max_tokens": 999,}- body = cerebras_provider._build_request_body(make_request())+ body = cerebras_provider._build_request_body(+ canonical_request(make_request()), provider_model=(make_request()).model+ )assert body["max_completion_tokens"] == 77assert "max_tokens" not in body@@ -179,7 +192,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(cerebras_provdef test_build_request_body_preserves_caller_extra_body(cerebras_provider):req = make_request(extra_body={"clear_thinking": False})- body = cerebras_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = cerebras_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )eb = body.get("extra_body")assert isinstance(eb, dict)@@ -212,7 +227,11 @@ async def test_stream_response_text(cerebras_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(cerebras_provider.stream_response(req))+ events = await collect_anthropic(+ cerebras_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -245,7 +264,11 @@ async def test_stream_response_reasoning(cerebras_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(cerebras_provider.stream_response(req))+ events = await collect_anthropic(+ cerebras_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_chutes.py b/tests/providers/test_chutes.pyindex 9d89497c..68e027f1 100644--- a/tests/providers/test_chutes.py+++ b/tests/providers/test_chutes.py@@ -12,6 +12,7 @@ from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -65,7 +66,9 @@ def test_preserves_upstream_reasoning_default(})- body = chutes_provider._build_request_body(request, reasoning=reasoning)+ body = chutes_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )assert "reasoning_effort" not in bodyassert "reasoning" not in body@@ -108,8 +111,9 @@ def test_does_not_replay_reasoning_but_preserves_tool_history()body = chutes_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assistant = body["messages"][1]diff --git a/tests/providers/test_cline_pass.py b/tests/providers/test_cline_pass.pyindex d07e9e90..1cb43dad 100644--- a/tests/providers/test_cline_pass.py+++ b/tests/providers/test_cline_pass.py@@ -9,6 +9,7 @@ import httpx2import pytestfrom openai import AsyncOpenAI+from free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import CLINE_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequest@@ -17,11 +18,14 @@ from free_claude_code.core.anthropic.stream_contracts import (text_content,thinking_content,)+from free_claude_code.core.inference import ReplayAttachmentfrom free_claude_code.core.json_types import JsonObject, JsonValuefrom free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.core.replay_envelope import decode_replay_envelopefrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_DEFAULT,REASONING_OFF,@@ -178,12 +182,12 @@ def test_build_request_body_preserves_nested_model_images_tools_and_results(}],tool_choice={"type": "tool", "name": "inspect_image"},- extra_body={"provider_option": "must-not-pass-through"},)body = cline_pass_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.on(),+ provider_model=(request).model,)assert body["model"] == "cline-pass/kimi-k3"@@ -203,7 +207,7 @@ def test_build_request_body_preserves_nested_model_images_tools_and_results("type": "function","function": {"name": "inspect_image",- "arguments": '{"detail": "high"}',+ "arguments": '{"detail":"high"}',},}]@@ -220,6 +224,19 @@ def test_build_request_body_preserves_nested_model_images_tools_and_results(assert "extra_body" not in body+def test_build_request_body_rejects_caller_extra_body(+ cline_pass_provider: OpenAIChatProvider,+) -> None:+ request = _request(extra_body={"provider_option": "must-not-pass-through"})++ with pytest.raises(InvalidRequestError, match="does not support caller extra_body"):+ cline_pass_provider._build_request_body(+ canonical_request(request),+ reasoning=ReasoningPolicy.provider_default(),+ provider_model=request.model,+ )++@pytest.mark.parametrize("reasoning",[REASONING_DEFAULT, REASONING_OFF, REASONING_ON],@@ -229,8 +246,9 @@ def test_build_request_body_adds_no_undocumented_reasoning_control_or_default_careasoning: ReasoningPolicy,) -> None:body = cline_pass_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=reasoning,+ provider_model=(_request()).model,)assert "max_tokens" not in body@@ -246,7 +264,7 @@ def test_build_request_body_adds_no_undocumented_reasoning_control_or_default_caassert field not in body-def test_build_request_body_replays_only_opaque_reasoning_details(+def test_build_request_body_omits_legacy_unscoped_reasoning_details(cline_pass_provider: OpenAIChatProvider,) -> None:detail: JsonObject = {@@ -272,15 +290,16 @@ def test_build_request_body_replays_only_opaque_reasoning_details()body = cline_pass_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.on(),+ provider_model=(request).model,)assistant = next(message for message in body["messages"] if message["role"] == "assistant")assert assistant["content"] == "I will inspect it."- assert assistant["reasoning_details"] == [detail]+ assert "reasoning_details" not in assistantassert "reasoning" not in assistantassert "reasoning_content" not in assistantassert (@@ -317,8 +336,9 @@ async def test_stream_uses_upstream_sse_and_preserves_reasoning_details(event_text = "".join(await collect_anthropic(cline_pass_provider.stream_response(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(),+ provider_model=(_request()).model,)))@@ -337,7 +357,15 @@ async def test_stream_uses_upstream_sse_and_preserves_reasoning_details(and event.data.get("content_block", {}).get("type") == "redacted_thinking"]assert len(redacted_blocks) == 1- assert json.loads(redacted_blocks[0]["data"]) == detail+ artifacts = decode_replay_envelope(+ redacted_blocks[0]["data"],+ attachment=ReplayAttachment.REASONING,+ )+ assert artifacts is not None+ assert len(artifacts) == 1+ assert isinstance(artifacts[0].payload, str)+ assert json.loads(artifacts[0].payload) == detail+ assert all(artifact.scope is not None for artifact in artifacts)assert stream.closeddiff --git a/tests/providers/test_cloudflare.py b/tests/providers/test_cloudflare.pyindex be2e5cf8..4734e52a 100644--- a/tests/providers/test_cloudflare.py+++ b/tests/providers/test_cloudflare.py@@ -18,6 +18,7 @@ from free_claude_code.providers.cloudflare import (cloudflare_ai_base_url,)from tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -128,7 +129,9 @@ def test_build_request_body_preserves_literal_cf_model_id_and_controls_thinking()body = cloudflare_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "@cf/moonshotai/kimi-k2.6"@@ -149,7 +152,9 @@ def test_build_request_body_disabled_thinking_sets_cloudflare_template_flag()body = cloudflare_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["chat_template_kwargs"]["thinking"] is False@@ -167,7 +172,9 @@ def test_build_request_body_preserves_user_extra_body_without_overriding_thinkin)body = cloudflare_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["chat_template_kwargs"]["thinking"] is False@@ -226,7 +233,9 @@ async def test_stream_uses_openai_chat_completions(return_value=_stream(_chunk(delta)),) as mock_create:events = await collect_anthropic(- cloudflare_provider.stream_response(_request())+ cloudflare_provider.stream_response(+ canonical_request(_request()), provider_model=(_request()).model+ ))parsed = parse_sse_text("".join(events))@@ -257,7 +266,9 @@ async def test_stream_maps_cloudflare_reasoning_delta_to_thinking(return_value=_stream(_chunk(delta)),):events = await collect_anthropic(- cloudflare_provider.stream_response(_request())+ cloudflare_provider.stream_response(+ canonical_request(_request()), provider_model=(_request()).model+ ))parsed = parse_sse_text("".join(events))@@ -307,7 +318,11 @@ async def test_stream_maps_openai_tool_calls_to_tool_use(new_callable=AsyncMock,return_value=_stream(_chunk(delta, finish_reason="tool_calls")),):- events = await collect_anthropic(cloudflare_provider.stream_response(request))+ events = await collect_anthropic(+ cloudflare_provider.stream_response(+ canonical_request(request), provider_model=(request).model+ )+ )parsed = parse_sse_text("".join(events))assert any(diff --git a/tests/providers/test_codestral.py b/tests/providers/test_codestral.pyindex f3fbe398..dc48a4da 100644--- a/tests/providers/test_codestral.py+++ b/tests/providers/test_codestral.py@@ -6,7 +6,7 @@ import pytestfrom free_claude_code.config.provider_catalog import CODESTRAL_DEFAULT_BASEfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -57,7 +57,9 @@ def test_default_base_url():def test_build_request_body_basic(codestral_provider):"""Basic request body conversion works for Codestral."""req = make_request()- body = codestral_provider._build_request_body(req)+ body = codestral_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )assert body["model"] == "devstral-small-latest"assert body["messages"][0]["role"] == "system"@@ -76,7 +78,9 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():admission=immediate_admission(),)req = make_request()- body = provider._build_request_body(req)+ body = provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )roles = [m.get("role") for m in body.get("messages", [])]assert "assistant_reasoning_content" not in roles@@ -108,7 +112,11 @@ async def test_stream_response_text(codestral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(codestral_provider.stream_response(req))+ events = await collect_anthropic(+ codestral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -141,7 +149,11 @@ async def test_stream_response_reasoning_content(codestral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(codestral_provider.stream_response(req))+ events = await collect_anthropic(+ codestral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )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 978a46b3..80e553e6 100644--- a/tests/providers/test_cohere.py+++ b/tests/providers/test_cohere.py@@ -8,7 +8,7 @@ import pytestfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.provider_catalog import COHERE_DEFAULT_BASEfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -82,7 +82,9 @@ def test_build_request_body_sanitizes_documented_unsupported_fields(cohere_provi"parallel_tool_calls": True,}- body = cohere_provider._build_request_body(make_request())+ body = cohere_provider._build_request_body(+ canonical_request(make_request()), provider_model=(make_request()).model+ )assert body["messages"][0].get("name") is Noneassert body["max_tokens"] == 42@@ -105,7 +107,9 @@ def test_build_request_body_sanitizes_documented_unsupported_fields(cohere_providef test_build_request_body_maps_reasoning_on_to_high(cohere_provider):request = make_request()body = cohere_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["reasoning_effort"] == "high"@@ -128,7 +132,9 @@ def test_build_request_body_preserves_replayed_reasoning_content(cohere_providerrequest = make_request()body = cohere_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"] == [@@ -154,7 +160,11 @@ def test_build_request_body_maps_reasoning_off_to_none():)request = make_request(thinking={"type": "disabled"})- body = provider._build_request_body(request, reasoning=reasoning_for(request))+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["reasoning_effort"] == "none"@@ -169,7 +179,9 @@ def test_build_request_body_promotes_allowed_extra_body(cohere_provider):})- body = cohere_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = cohere_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert body["frequency_penalty"] == 0.1assert body["presence_penalty"] == 0.2@@ -182,7 +194,11 @@ def test_build_request_body_rejects_unsupported_extra_body(cohere_provider):req = make_request(extra_body={"documents": [{"text": "x"}]})with pytest.raises(InvalidRequestError, match="Unsupported"):- cohere_provider._build_request_body(req, reasoning=reasoning_for(req))+ cohere_provider._build_request_body(+ canonical_request(req),+ reasoning=reasoning_for(req),+ provider_model=(req).model,+ )@pytest.mark.asyncio@@ -209,7 +225,9 @@ async def test_stream_response_text(cohere_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- cohere_provider.stream_response(make_request())+ cohere_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(@@ -244,7 +262,9 @@ async def test_stream_response_tool_call(cohere_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- cohere_provider.stream_response(make_request())+ cohere_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(@@ -279,7 +299,9 @@ async def test_stream_response_reasoning_content(cohere_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- cohere_provider.stream_response(make_request())+ cohere_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(diff --git a/tests/providers/test_converter.py b/tests/providers/test_converter.pyindex b24f2c6f..10935045 100644--- a/tests/providers/test_converter.py+++ b/tests/providers/test_converter.py@@ -1,270 +1,220 @@-import json+"""Contracts for canonical-to-OpenAI Chat request encoding."""import pytest-from free_claude_code.core.anthropic import (- AnthropicToOpenAIConverter,+from free_claude_code.application.errors import InvalidRequestError+from free_claude_code.core.anthropic import messages_to_inference_request+from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import (+ CacheControl,+ CustomTool,+ CustomToolFormat,+ CustomToolFormatType,+ DocumentContent,+ FunctionTool,+ InferenceRequest,+ InstructionItem,+ InstructionOrigin,+ InstructionPlacement,+ MessageItem,+ MessageRole,+ ReasoningItem,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ReplayCompatibilityScope,+ TextContent,+ ToolCallItem,+ ToolCallKind,+ ToolChoice,+ ToolChoiceMode,+ ToolResultItem,+ UrlMediaSource,+)+from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.providers.openai_chat import (+ OpenAIChatRequestPolicy,+ build_openai_chat_request_body,+)+from free_claude_code.providers.openai_chat.request_codec import (OpenAIConversionError,ReasoningReplayMode,build_base_request_body,is_synthetic_openai_tool_turn_boundary,+ serialize_tool_result_content,)-from free_claude_code.core.anthropic.models import MessagesRequest--# --- Mock Classes ------class MockMessage:- def __init__(self, role, content, reasoning_content=None):- self.role = role- self.content = content- self.reasoning_content = reasoning_content-+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec-class MockBlock:- def __init__(self, **kwargs):- for k, v in kwargs.items():- setattr(self, k, v)- self._data = kwargs- def get(self, key, default=None):- return self._data.get(key, default)---class MockTool:- def __init__(self, name, description, input_schema=None):- self.name = name- self.description = description- self.input_schema = input_schema---# --- System Prompt Tests ------def test_convert_system_prompt_str():- system = "You are a helpful assistant."- result = AnthropicToOpenAIConverter.convert_system_prompt(system)- assert result == {"role": "system", "content": system}+def _canonical(**overrides: object) -> InferenceRequest:+ payload: dict[str, object] = {+ "model": "client-model",+ "messages": [{"role": "user", "content": "Hello"}],+ }+ payload.update(overrides)+ return messages_to_inference_request(MessagesRequest.model_validate(payload))+++def _body(+ request: InferenceRequest,+ *,+ provider_model: str = "upstream-model",+ replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,+ replay_scope: ReplayCompatibilityScope | None = None,+ default_max_tokens: int | None = None,+) -> dict[str, object]:+ body: dict[str, object] = {}+ body.update(+ build_base_request_body(+ request,+ provider_model=provider_model,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=replay_scope,+ default_max_tokens=default_max_tokens,+ reasoning_replay=replay,+ )+ )+ return body-def test_convert_system_prompt_list_text():- system = [- MockBlock(type="text", text="Part 1"),- MockBlock(type="text", text="Part 2"),- ]- result = AnthropicToOpenAIConverter.convert_system_prompt(system)- assert result == {"role": "system", "content": "Part 1\n\nPart 2"}+def _object(value: object) -> dict[str, object]:+ assert isinstance(value, dict)+ return value-def test_convert_system_prompt_none():- assert AnthropicToOpenAIConverter.convert_system_prompt(None) is None+def _objects(value: object) -> list[dict[str, object]]:+ assert isinstance(value, list)+ assert all(isinstance(item, dict) for item in value)+ return value-def test_openai_build_uses_only_top_level_system_role() -> None:- request = MessagesRequest.model_validate(- {- "model": "model",- "system": "Conversation-wide instructions",- "messages": [- {"role": "user", "content": "First question"},- {"role": "system", "content": "Instructions from this point"},- {"role": "system", "content": "A second reminder"},- {"role": "assistant", "content": "First answer"},- {"role": "user", "content": "Second question"},- {"role": "system", "content": "A final reminder"},- ],- }+def test_top_level_and_inline_instructions_preserve_order() -> None:+ request = _canonical(+ system="Conversation-wide instructions",+ messages=[+ {"role": "user", "content": "First question"},+ {"role": "system", "content": "Instructions from this point"},+ {"role": "assistant", "content": "First answer"},+ {"role": "user", "content": "Second question"},+ ],)- body = build_base_request_body(request)-- assert body["messages"] == [+ assert _body(request)["messages"] == [{"role": "system", "content": "Conversation-wide instructions"},{"role": "user",- "content": (- "First question\n\nInstructions from this point\n\nA second reminder"- ),+ "content": "First question\n\nInstructions from this point",},{"role": "assistant", "content": "First answer"},- {"role": "user", "content": "Second question\n\nA final reminder"},+ {"role": "user", "content": "Second question"},]-def test_openai_build_demotes_inline_system_text_blocks_without_repositioning() -> None:- request = MessagesRequest.model_validate(- {- "model": "model",- "messages": [- {"role": "user", "content": "Before"},- {- "role": "system",- "content": [- {"type": "text", "text": "First instruction"},- {"type": "text", "text": "Second instruction"},- ],- },- ],- }- )+def test_provider_model_is_explicit_and_request_is_immutable() -> None:+ request = _canonical(max_tokens=321, temperature=0.4, top_p=0.8)- body = build_base_request_body(request)+ body = _body(request, provider_model="provider/selected")- assert body["messages"] == [- {- "role": "user",- "content": "Before\n\nFirst instruction\n\nSecond instruction",- }- ]+ assert body["model"] == "provider/selected"+ assert body["max_tokens"] == 321+ assert body["temperature"] == 0.4+ assert body["top_p"] == 0.8+ assert request.model == "client-model"-def test_inline_system_message_preserves_existing_openai_cache_prefix() -> None:- prefix_request = MessagesRequest.model_validate(- {- "model": "model",- "system": "Conversation-wide instructions",- "messages": [- {"role": "user", "content": "First question"},- {"role": "assistant", "content": "First answer"},- ],- }+def test_default_output_cap_only_applies_when_client_omits_it() -> None:+ assert (+ _body(_canonical(max_tokens=None), default_max_tokens=777)["max_tokens"] == 777)- continued_request = MessagesRequest.model_validate(- {- "model": "model",- "system": "Conversation-wide instructions",- "messages": [- {"role": "user", "content": "First question"},- {"role": "assistant", "content": "First answer"},- {"role": "user", "content": "Second question"},- {- "role": "system",- "content": (- "<system-reminder>Instructions from this point"- "</system-reminder>"- ),- },- ],- }+ assert (+ _body(_canonical(max_tokens=123), default_max_tokens=777)["max_tokens"] == 123)- prefix = build_base_request_body(prefix_request)["messages"]- continued = build_base_request_body(continued_request)["messages"]- assert continued[: len(prefix)] == prefix- assert continued[len(prefix) :] == [- {- "role": "user",- "content": (- "Second question\n\n<system-reminder>Instructions from this point"- "</system-reminder>"- ),- }- ]+def test_chat_policy_must_explicitly_consume_or_reject_caller_extra_body() -> None:+ request = _canonical(extra_body={"provider_option": True})+ policy = OpenAIChatRequestPolicy(+ provider_name="TEST",+ reasoning_replay=ReasoningReplayMode.THINK_TAGS,+ )+ with pytest.raises(InvalidRequestError, match="does not support caller extra_body"):+ build_openai_chat_request_body(+ request,+ provider_model="upstream-model",+ reasoning=ReasoningPolicy.provider_default(),+ policy=policy,+ tool_names=OpenAIToolNameCodec.from_request(request),+ replay_scope=None,+ )-def test_inline_system_message_coalesces_with_multimodal_user_content() -> None:- request = MessagesRequest.model_validate(- {- "model": "model",- "messages": [- {"role": "user", "content": "Existing context."},- {- "role": "user",- "content": [- {- "type": "image",- "source": {- "type": "url",- "url": "https://example.com/image.png",- },++def test_user_text_and_image_parts_are_encoded_without_reordering() -> None:+ request = _canonical(+ messages=[+ {+ "role": "user",+ "content": [+ {"type": "text", "text": "Inspect"},+ {+ "type": "image",+ "source": {+ "type": "url",+ "url": "https://example.invalid/image.png",},- {"type": "text", "text": "Inspect this image."},- ],- },- {"role": "system", "content": "Focus on correctness."},- ],- }+ },+ {"type": "text", "text": "carefully"},+ ],+ }+ ])- body = build_base_request_body(request)-- assert body["messages"] == [+ assert _body(request)["messages"] == [{"role": "user","content": [- {"type": "text", "text": "Existing context."},+ {"type": "text", "text": "Inspect"},{"type": "image_url",- "image_url": {"url": "https://example.com/image.png"},- },- {- "type": "text",- "text": "Inspect this image.\n\nFocus on correctness.",+ "image_url": {"url": "https://example.invalid/image.png"},},+ {"type": "text", "text": "carefully"},],}]-def test_inline_system_message_follows_completed_tool_result() -> None:- request = MessagesRequest.model_validate(- {- "model": "model",- "messages": [- {"role": "user", "content": "Use the tool"},- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "call_1",- "name": "Read",- "input": {},- }- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "call_1",- "content": "done",- }- ],- },- {"role": "system", "content": "New instructions"},- ],- }+def test_document_content_is_rejected_instead_of_dropped() -> None:+ request = InferenceRequest(+ model="client-model",+ items=(+ MessageItem(+ "turn_0",+ MessageRole.USER,+ (DocumentContent(UrlMediaSource("https://example.invalid/a.pdf")),),+ ),+ ),)- body = build_base_request_body(request)-- assert [message["role"] for message in body["messages"]] == [- "user",- "assistant",- "tool",- "assistant",- "user",- ]- assert body["messages"][3] == {"role": "assistant", "content": " "}- assert body["messages"][-1]["content"] == "New instructions"+ with pytest.raises(OpenAIConversionError, match="document content"):+ _body(request)-def test_openai_build_rejects_non_text_inline_system_blocks() -> None:- request = MessagesRequest.model_validate(+def test_assistant_media_is_rejected_at_ingress() -> None:+ wire = MessagesRequest.model_validate({- "model": "model",+ "model": "client-model","messages": [{- "role": "system",+ "role": "assistant","content": [{"type": "image","source": {"type": "url",- "url": "https://example.com/a.png",+ "url": "https://example.invalid/image.png",},}],@@ -273,1475 +223,373 @@ def test_openai_build_rejects_non_text_inline_system_blocks() -> None:})- with pytest.raises(- OpenAIConversionError,- match="inline Anthropic system message content block 'image' without data loss",- ):- build_base_request_body(request)+ with pytest.raises(ValueError, match="assistant images"):+ messages_to_inference_request(wire)-def test_openai_build_rejects_empty_inline_system_content() -> None:- request = MessagesRequest.model_validate(- {- "model": "model",- "messages": [{"role": "system", "content": []}],- }+ ("mode", "reasoning_field", "visible"),+ [+ (ReasoningReplayMode.THINK_TAGS, None, "<think>\nWork\n</think>\n\nDone"),+ (ReasoningReplayMode.REASONING_CONTENT, "reasoning_content", "Done"),+ (ReasoningReplayMode.REASONING, "reasoning", "Done"),+ (ReasoningReplayMode.DISABLED, None, "Done"),+ ],+)+def test_reasoning_replay_modes(+ mode: ReasoningReplayMode,+ reasoning_field: str | None,+ visible: str,+) -> None:+ request = _canonical(+ messages=[+ {"role": "user", "content": "Solve"},+ {+ "role": "assistant",+ "content": [+ {"type": "thinking", "thinking": "Work"},+ {"type": "text", "text": "Done"},+ ],+ },+ ])- with pytest.raises(OpenAIConversionError, match="contain text"):- build_base_request_body(request)---# --- Tool Conversion Tests ---+ assistant = _objects(_body(request, replay=mode)["messages"])[1]++ assert assistant["content"] == visible+ if reasoning_field is None:+ assert "reasoning_content" not in assistant+ assert "reasoning" not in assistant+ else:+ assert assistant[reasoning_field] == "Work"+++def test_reasoning_replay_artifacts_require_an_exact_route_scope() -> None:+ matching = ReplayCompatibilityScope("route-a")+ request = InferenceRequest(+ model="client-model",+ items=(+ ReasoningItem(+ turn_id="turn_0",+ reasoning="Work",+ artifacts=(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,+ kind=ReplayArtifactKind.REASONING_DETAILS,+ attachment=ReplayAttachment.REASONING,+ payload=[{"type": "reasoning.text", "text": "opaque"}],+ scope=matching,+ ),+ ),+ ),+ MessageItem("turn_0", MessageRole.ASSISTANT, (TextContent("Done"),)),+ ),+ )+ matched = _objects(_body(request, replay_scope=matching)["messages"])[0]+ mismatched = _objects(+ _body(+ request,+ replay_scope=ReplayCompatibilityScope("route-b"),+ )["messages"]+ )[0]-def test_convert_tools():- tools = [- MockTool(- "get_weather",- "Get weather",- {"type": "object", "properties": {"loc": {"type": "string"}}},- ),- MockTool("calculator", None, {"type": "object"}),+ assert matched["reasoning_details"] == [+ {"type": "reasoning.text", "text": "opaque"}]- result = AnthropicToOpenAIConverter.convert_tools(tools)- assert len(result) == 2-- assert result[0]["type"] == "function"- assert result[0]["function"]["name"] == "get_weather"- assert result[0]["function"]["description"] == "Get weather"- assert result[0]["function"]["parameters"] == {- "type": "object",- "properties": {"loc": {"type": "string"}},- }+ assert "reasoning_details" not in mismatched- assert result[1]["function"]["name"] == "calculator"- assert result[1]["function"]["description"] == "" # Check default empty string+def test_function_tools_preserve_schema_strictness_and_choice() -> None:+ request = _canonical(+ tools=[+ {+ "name": "lookup",+ "description": "Look up a value",+ "input_schema": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ },+ "strict": True,+ }+ ],+ tool_choice={"type": "tool", "name": "lookup"},+ )-def test_convert_tool_without_input_schema_uses_empty_object_schema():- tools = [MockTool("web_search", None)]-- result = AnthropicToOpenAIConverter.convert_tools(tools)+ body = _body(request)- assert result == [+ assert body["tools"] == [{"type": "function","function": {- "name": "web_search",- "description": "",- "parameters": {"type": "object", "properties": {}},+ "name": "lookup",+ "description": "Look up a value",+ "parameters": {+ "type": "object",+ "properties": {"value": {"type": "string"}},+ },+ "strict": True,},}]+ assert body["tool_choice"] == {+ "type": "function",+ "function": {"name": "lookup"},+ }@pytest.mark.parametrize(- "tool_choice,expected",+ ("mode", "expected"),[- (- {"type": "tool", "name": "echo_smoke"},- {"type": "function", "function": {"name": "echo_smoke"}},- ),- ({"type": "any"}, "required"),- ({"type": "auto"}, "auto"),- ({"type": "none"}, "none"),- (- {"type": "function", "function": {"name": "already_openai"}},- {"type": "function", "function": {"name": "already_openai"}},- ),+ (ToolChoiceMode.AUTO, "auto"),+ (ToolChoiceMode.NONE, "none"),+ (ToolChoiceMode.REQUIRED, "required"),],)-def test_convert_tool_choice(tool_choice, expected):- result = AnthropicToOpenAIConverter.convert_tool_choice(tool_choice)- assert result == expected---def test_openai_build_materializes_auto_tool_choice_when_tools_are_declared():- request = MessagesRequest.model_validate(- {- "model": "model",- "messages": [{"role": "user", "content": "Use the echo tool."}],- "tools": [- {- "name": "echo",- "description": "Echo a value.",- "input_schema": {- "type": "object",- "properties": {"value": {"type": "string"}},- "required": ["value"],- },- }- ],- }- )-- body = build_base_request_body(request)-- assert body["tool_choice"] == "auto"---def test_openai_build_omits_tool_choice_when_tools_are_absent():- request = MessagesRequest.model_validate(- {- "model": "model",- "messages": [{"role": "user", "content": "Hello"}],- }+def test_nonspecific_tool_choice_modes(+ mode: ToolChoiceMode,+ expected: str,+) -> None:+ request = InferenceRequest(+ model="client-model",+ items=(MessageItem("turn_0", MessageRole.USER, (TextContent("Hi"),)),),+ tools=(FunctionTool("lookup", None, {"type": "object"}),),+ tool_choice=ToolChoice(mode),+ )++ assert _body(request)["tool_choice"] == expected+++def test_custom_and_namespaced_tools_share_a_reversible_name_map() -> None:+ request = InferenceRequest(+ model="client-model",+ items=(MessageItem("turn_0", MessageRole.USER, (TextContent("Run"),)),),+ tools=(+ CustomTool(+ name="shell",+ description="Execute text",+ format=CustomToolFormat(CustomToolFormatType.TEXT),+ namespace="workspace",+ ),+ ),+ tool_choice=ToolChoice(+ ToolChoiceMode.SPECIFIC,+ kind=ToolCallKind.CUSTOM,+ name="shell",+ namespace="workspace",+ ),+ )++ codec = OpenAIToolNameCodec.from_request(request)+ body = build_base_request_body(+ request,+ provider_model="upstream-model",+ tool_names=codec,+ replay_scope=None,+ )+ wire_tool = _objects(body["tools"])[0]+ wire_function = _object(wire_tool["function"])+ wire_name = wire_function["name"]+ assert isinstance(wire_name, str)++ choice = _object(body["tool_choice"])+ assert _object(choice["function"])["name"] == wire_name+ identity = codec.decode_identity(wire_name)+ assert identity.kind is ToolCallKind.CUSTOM+ assert identity.name == "shell"+ assert identity.namespace == "workspace"+++def test_tool_history_keeps_calls_before_results_and_preserves_error_content() -> None:+ request = InferenceRequest(+ model="client-model",+ items=(+ MessageItem("turn_0", MessageRole.USER, (TextContent("Use it"),)),+ ToolCallItem(+ turn_id="turn_1",+ call_id="call_1",+ kind=ToolCallKind.FUNCTION,+ name="lookup",+ input={"value": "x"},+ ),+ ToolResultItem(+ turn_id="turn_2",+ call_id="call_1",+ content={"error": "not found"},+ is_error=True,+ ),+ MessageItem("turn_3", MessageRole.USER, (TextContent("Continue"),)),+ ),+ tools=(FunctionTool("lookup", None, {"type": "object"}),),)- body = build_base_request_body(request)-- assert "tools" not in body- assert "tool_choice" not in body---# --- Message Conversion Tests: User ------def test_convert_user_message_str():- messages = [MockMessage("user", "Hello world")]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 1- assert result[0] == {"role": "user", "content": "Hello world"}+ messages = _objects(_body(request)["messages"])--def test_convert_user_message_list_text():- content = [- MockBlock(type="text", text="Hello"),- MockBlock(type="text", text="World"),- ]- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 1- assert result[0] == {"role": "user", "content": "Hello\nWorld"}---def test_convert_user_message_tool_result_str():- content = [- MockBlock(type="tool_result", tool_use_id="tool_123", content="Result data")+ assert [message["role"] for message in messages] == [+ "user",+ "assistant",+ "tool",+ "assistant",+ "user",]- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 1- assert result[0] == {+ assert _objects(messages[1]["tool_calls"])[0]["id"] == "call_1"+ assert messages[2] == {"role": "tool",- "tool_call_id": "tool_123",- "content": "Result data",+ "tool_call_id": "call_1",+ "content": '{"error": "not found"}',}---def test_convert_user_message_tool_result_list():- # Tool result content as a list of text blocks- tool_content = [- {"type": "text", "text": "Line 1"},- {"type": "text", "text": "Line 2"},- ]- content = [- MockBlock(type="tool_result", tool_use_id="tool_456", content=tool_content)- ]- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 1- assert result[0]["role"] == "tool"- assert result[0]["tool_call_id"] == "tool_456"- assert result[0]["content"] == "Line 1\nLine 2"---def test_convert_user_message_mixed_text_and_tool_result():- # Note: Anthropic/OpenAI mapping usually separates these, but the converter handles lists- # User text usually comes before tool results in a turn, or after.- # The converter splits them into separate messages if they are different roles?- # Let's check logic: _convert_user_message returns a list of dicts.- content = [- MockBlock(type="text", text="Here is the result:"),- MockBlock(type="tool_result", tool_use_id="tool_789", content="42"),- ]- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- # Order is preserved: user text first, then tool result.- assert len(result) == 2- assert result[0] == {"role": "user", "content": "Here is the result:"}- assert result[1] == {"role": "tool", "tool_call_id": "tool_789", "content": "42"}---# --- Message Conversion Tests: Assistant ------def test_convert_assistant_message_text_only():- messages = [MockMessage("assistant", "I am ready.")]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 1- assert result[0] == {"role": "assistant", "content": "I am ready."}---def test_convert_assistant_message_blocks_text():- content = [MockBlock(type="text", text="Part A")]- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert result[0] == {"role": "assistant", "content": "Part A"}---def test_convert_assistant_message_thinking():- content = [- MockBlock(type="thinking", thinking="I need to calculate this."),- MockBlock(type="text", text="The answer is 4."),- ]- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert len(result) == 1- # Expecting <think> tags- expected_content = (- "<think>\nI need to calculate this.\n</think>\n\nThe answer is 4."- )- assert result[0]["content"] == expected_content- assert "reasoning_content" not in result[0]---def test_convert_assistant_message_thinking_replays_reasoning_content():- """Top-level reasoning replay avoids duplicating thinking into content."""- content = [- MockBlock(type="thinking", thinking="I need to calculate this."),- MockBlock(type="text", text="The answer is 4."),- ]- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT- )-- assert len(result) == 1- assert result[0]["reasoning_content"] == "I need to calculate this."- assert result[0]["content"] == "The answer is 4."- assert "<think>" not in result[0]["content"]---def test_convert_assistant_message_thinking_replays_reasoning():- content = [- MockBlock(type="thinking", thinking="I need to calculate this."),- MockBlock(type="text", text="The answer is 4."),- ]- messages = [MockMessage("assistant", content)]-- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING- )-- assert result == [- {- "role": "assistant",- "content": "The answer is 4.",- "reasoning": "I need to calculate this.",- }- ]---def test_convert_assistant_top_level_reasoning_content_is_preserved():- messages = [- MockMessage(- "assistant",- "The answer is 4.",- reasoning_content="I need to calculate this.",- )- ]- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT- )-- assert result == [- {- "role": "assistant",- "content": "The answer is 4.",- "reasoning_content": "I need to calculate this.",- }- ]---def test_convert_assistant_empty_top_level_reasoning_content_is_preserved():- messages = [MockMessage("assistant", "The answer is 4.", reasoning_content="")]-- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT- )-- assert result == [- {- "role": "assistant",- "content": "The answer is 4.",- "reasoning_content": "",- }- ]---def test_convert_assistant_thinking_tool_use_replays_top_level_reasoning():- content = [- MockBlock(type="thinking", thinking="I should call the tool."),- MockBlock(- type="tool_use",- id="call_reasoning",- name="search",- input={"query": "python"},- ),- ]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [- MockBlock(- type="tool_result",- tool_use_id="call_reasoning",- content="result",- )- ],+ assert is_synthetic_openai_tool_turn_boundary(messages[3])+++def test_incomplete_tool_history_is_rejected() -> None:+ request = InferenceRequest(+ model="client-model",+ items=(+ ToolCallItem(+ turn_id="turn_0",+ call_id="missing",+ kind=ToolCallKind.FUNCTION,+ name="lookup",+ input={},+ ),),- ]- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT- )-- assert len(result) == 2- assert result[0]["content"] == ""- assert result[0]["reasoning_content"] == "I should call the tool."- assert "<think>" not in result[0]["content"]- assert result[0]["tool_calls"][0]["id"] == "call_reasoning"---def test_convert_assistant_tool_use_replays_ollama_reasoning_field():- messages = [- MockMessage(- "assistant",- [- MockBlock(type="thinking", thinking="Call the tool."),- MockBlock(type="tool_use", id="call_1", name="Read", input={}),- ],+ tools=(FunctionTool("lookup", None, {"type": "object"}),),+ )++ with pytest.raises(OpenAIConversionError, match="missing tool results"):+ _body(request)+++def test_tool_replay_artifacts_require_an_exact_route_scope() -> None:+ matching = ReplayCompatibilityScope("route-a")+ request = InferenceRequest(+ model="client-model",+ items=(+ ToolCallItem(+ turn_id="turn_0",+ call_id="call_1",+ kind=ToolCallKind.FUNCTION,+ name="lookup",+ input={},+ artifacts=(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.GOOGLE,+ kind=ReplayArtifactKind.THOUGHT_SIGNATURE,+ attachment=ReplayAttachment.TOOL_CALL,+ payload="signature",+ scope=matching,+ ),+ ),+ ),+ ToolResultItem("turn_1", "call_1", "done"),+ ),+ tools=(FunctionTool("lookup", None, {"type": "object"}),),+ )++ matched_message = _objects(_body(request, replay_scope=matching)["messages"])[0]+ matched = _objects(matched_message["tool_calls"])[0]+ mismatched_message = _objects(+ _body(+ request,+ replay_scope=ReplayCompatibilityScope("route-b"),+ )["messages"]+ )[0]+ mismatched = _objects(mismatched_message["tool_calls"])[0]++ assert matched["extra_content"] == {"google": {"thought_signature": "signature"}}+ assert "extra_content" not in mismatched+++def test_cache_control_is_preserved_only_at_supported_locations() -> None:+ request = InferenceRequest(+ model="client-model",+ items=(+ InstructionItem(+ "System",+ InstructionOrigin.SYSTEM,+ InstructionPlacement.TOP_LEVEL,+ cache_control=CacheControl(),+ ),+ MessageItem(+ "turn_0",+ MessageRole.USER,+ (TextContent("Hello", cache_control=CacheControl()),),+ ),),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_1", content="done")],+ tools=(+ FunctionTool(+ "lookup",+ None,+ {"type": "object"},+ cache_control=CacheControl(),+ ),),- ]-- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING)- assert result[0]["reasoning"] == "Call the tool."- assert "reasoning_content" not in result[0]- assert result[0]["tool_calls"][0]["id"] == "call_1"+ body = _body(request)+ messages = _objects(body["messages"])+ first_content = _objects(messages[0]["content"])+ second_content = _objects(messages[1]["content"])+ tools = _objects(body["tools"])+ assert first_content[0]["cache_control"] == {"type": "ephemeral"}+ assert second_content[0]["cache_control"] == {"type": "ephemeral"}+ assert tools[0]["cache_control"] == {"type": "ephemeral"}-def test_convert_assistant_empty_thinking_replays_empty_reasoning_content():- content = [- MockBlock(type="thinking", thinking=""),- MockBlock(type="text", text="The answer is 4."),- ]- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT+def test_inline_instruction_after_tool_result_gets_a_synthetic_boundary() -> None:+ request = _canonical(+ messages=[+ {"role": "user", "content": "Use it"},+ {+ "role": "assistant",+ "content": [+ {+ "type": "tool_use",+ "id": "call_1",+ "name": "lookup",+ "input": {},+ }+ ],+ },+ {+ "role": "user",+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": "call_1",+ "content": "done",+ }+ ],+ },+ {"role": "system", "content": "New instructions"},+ ],+ tools=[{"name": "lookup", "input_schema": {"type": "object"}}],)- assert result == [- {- "role": "assistant",- "content": "The answer is 4.",- "reasoning_content": "",- }- ]-+ messages = _objects(_body(request)["messages"])-def test_convert_assistant_tool_use_replays_empty_reasoning_content():- content = [- MockBlock(type="thinking", thinking=""),- MockBlock(type="tool_use", id="call_empty", name="Read", input={}),- ]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [- MockBlock(- type="tool_result",- tool_use_id="call_empty",- content="result",- )- ],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT- )-- assert result[0]["content"] == ""- assert result[0]["reasoning_content"] == ""- assert result[0]["tool_calls"][0]["id"] == "call_empty"---def _convert_tool_turn(- assistant_content: list[MockBlock],- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.REASONING_CONTENT,-) -> list[dict]:- tool_ids = [- block.get("id")- for block in assistant_content- if block.get("type") == "tool_use"- ]- return AnthropicToOpenAIConverter.convert_messages(- [- MockMessage("assistant", assistant_content),- MockMessage(- "user",- [- MockBlock(- type="tool_result",- tool_use_id=tool_id,- content="result",- )- for tool_id in tool_ids- ],- ),- ],- reasoning_replay=reasoning_replay,- )---def test_convert_assistant_tool_use_without_thinking_replays_empty_reasoning_content():- result = _convert_tool_turn(- [MockBlock(type="tool_use", id="call_missing", name="Read", input={})]- )-- assert result[0]["content"] == ""- assert result[0]["reasoning_content"] == ""- assert result[0]["tool_calls"][0]["id"] == "call_missing"---def test_convert_parallel_tool_use_without_thinking_replays_one_empty_reasoning_field():- result = _convert_tool_turn(- [- MockBlock(type="tool_use", id="call_1", name="Read", input={}),- MockBlock(type="tool_use", id="call_2", name="Glob", input={}),- ]- )-- assert result[0]["reasoning_content"] == ""- assert [tool_call["id"] for tool_call in result[0]["tool_calls"]] == [- "call_1",- "call_2",- ]---def test_convert_redacted_thinking_tool_use_replays_empty_reasoning_without_data():- result = _convert_tool_turn(- [- MockBlock(type="redacted_thinking", data="opaque-secret"),- MockBlock(type="tool_use", id="call_redacted", name="Read", input={}),- ]- )-- assert result[0]["reasoning_content"] == ""- assert "opaque-secret" not in json.dumps(result)---def test_convert_text_only_assistant_without_thinking_omits_reasoning_content():- result = AnthropicToOpenAIConverter.convert_messages(- [MockMessage("assistant", "Visible answer")],- reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,- )-- assert result == [{"role": "assistant", "content": "Visible answer"}]--- "reasoning_replay",- [- ReasoningReplayMode.THINK_TAGS,- ReasoningReplayMode.REASONING,- ReasoningReplayMode.DISABLED,- ],-)-def test_convert_tool_use_without_thinking_does_not_change_other_replay_modes(- reasoning_replay: ReasoningReplayMode,-) -> None:- result = _convert_tool_turn(- [MockBlock(type="tool_use", id="call_other", name="Read", input={})],- reasoning_replay,- )-- assert "reasoning_content" not in result[0]---def test_convert_assistant_message_thinking_removed_when_disabled():- content = [- MockBlock(type="thinking", thinking="I need to calculate this."),- MockBlock(type="text", text="The answer is 4."),- ]- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(- messages,- reasoning_replay=ReasoningReplayMode.DISABLED,- )-- assert len(result) == 1- assert "reasoning_content" not in result[0]- assert "<think>" not in result[0]["content"]- assert result[0]["content"] == "The answer is 4."---def test_convert_assistant_top_level_reasoning_stripped_when_disabled():- messages = [- MockMessage(- "assistant",- "The answer is 4.",- reasoning_content="I need to calculate this.",- )- ]- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.DISABLED- )-- assert result == [{"role": "assistant", "content": "The answer is 4."}]---def test_convert_assistant_message_tool_use():- content = [- MockBlock(type="text", text="I will call the tool."),- MockBlock(- type="tool_use", id="call_1", name="search", input={"query": "python"}- ),- ]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_1", content="result")],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert len(result) == 2- msg = result[0]- assert msg["role"] == "assistant"- assert "I will call the tool." in msg["content"]- assert "tool_calls" in msg- assert len(msg["tool_calls"]) == 1- tc = msg["tool_calls"][0]- assert tc["id"] == "call_1"- assert tc["function"]["name"] == "search"- assert json.loads(tc["function"]["arguments"]) == {"query": "python"}---def test_convert_assistant_tool_use_preserves_extra_content():- content = [- MockBlock(- type="tool_use",- id="call_1",- name="search",- input={"query": "python"},- extra_content={"google": {"thought_signature": "sig"}},- ),- ]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_1", content="result")],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert result[0]["tool_calls"][0]["extra_content"] == {- "google": {"thought_signature": "sig"}- }---def test_convert_assistant_message_empty_content():- # Verify that empty content becomes a single space (NIM requirement)- # if no tool calls are present.- content = []- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert result[0]["content"] == " "---def test_convert_assistant_message_tool_use_no_text():- # If tool usage exists, content can be empty string?- # Logic: if not content_str and not tool_calls: content_str = " "- # So if tool_calls exist, content_str can be empty string?- # Actually code says: if not content_str and not tool_calls.- # So if tool_calls is present, content_str remains "" (empty).-- content = [MockBlock(type="tool_use", id="call_2", name="test", input={})]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_2", content="result")],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert (- result[0]["content"] == ""- ) # Should be empty string, not space, because tools exist- assert len(result[0]["tool_calls"]) == 1---def test_convert_mixed_blocks_and_types_and_roles():- # comprehensive flow- messages = [- MockMessage("user", "Start"),- MockMessage(- "assistant",- [- MockBlock(type="thinking", thinking="Thinking..."),- MockBlock(type="text", text="Here is a tool."),- ],- ),- MockMessage(- "assistant", [MockBlock(type="tool_use", id="t1", name="f", input={})]- ),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="t1", content="result")],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert len(result) == 4- assert result[0]["role"] == "user"- assert "<think>" in result[1]["content"]- assert result[2]["tool_calls"][0]["id"] == "t1"---# --- Edge Cases ------def test_get_block_attr_defaults():- # Test helper directly- from free_claude_code.core.anthropic import get_block_attr-- assert get_block_attr({}, "missing", "default") == "default"- assert get_block_attr(object(), "missing", "default") == "default"---def test_input_not_dict():- # Tool input might not be a dict (e.g. malformed or string)- content = [MockBlock(type="tool_use", id="call_x", name="f", input="some_string")]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_x", content="result")],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)- # The converter calls json.dumps(tool_input) if dict, else str(tool_input)- # So it should be "some_string"- assert result[0]["tool_calls"][0]["function"]["arguments"] == "some_string"---# --- Parametrized Edge Case Tests ------ "system_input,expected",- [- ("You are helpful.", {"role": "system", "content": "You are helpful."}),- (- [MockBlock(type="text", text="A"), MockBlock(type="text", text="B")],- {"role": "system", "content": "A\n\nB"},- ),- (None, None),- ("", {"role": "system", "content": ""}),- ([], None),- ],- ids=["string", "list_text", "none", "empty_string", "empty_list"],-)-def test_convert_system_prompt_parametrized(system_input, expected):- """Parametrized system prompt conversion covering edge cases."""- result = AnthropicToOpenAIConverter.convert_system_prompt(system_input)- assert result == expected--- "content,expected_content",- [- ("Hello world", "Hello world"),- ("", ""),- ([MockBlock(type="text", text="A"), MockBlock(type="text", text="B")], "A\nB"),- ([MockBlock(type="text", text="")], ""),- ],- ids=["simple_string", "empty_string", "list_blocks", "empty_text_block"],-)-def test_convert_user_message_parametrized(content, expected_content):- """Parametrized user message conversion."""- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) >= 1- assert result[0]["content"] == expected_content---def test_convert_assistant_message_unknown_block_type():- """Unknown block types should be silently skipped."""- content = [- MockBlock(type="unknown_type", data="something"),- MockBlock(type="text", text="visible"),- ]- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 1- assert "visible" in result[0]["content"]---def test_convert_tool_use_none_input():- """Tool use with None input should not crash."""- content = [MockBlock(type="tool_use", id="call_n", name="test", input=None)]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_n", content="result")],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 2- assert "tool_calls" in result[0]---def test_convert_assistant_interleaved_order_preserved():- """Interleaved thinking, text, tool_use should preserve thinking+text order in content.-- Bug: Current implementation collects all thinking, then all text, then tool_calls.- Original order [thinking, text, thinking, tool_use] becomes [all thinking, all text, tool_calls],- losing the interleaving. Content string should reflect original block order for thinking+text.- Tool calls stay at end (API constraint).- """- content = [- MockBlock(type="thinking", thinking="First thought."),- MockBlock(type="text", text="Here is the answer."),- MockBlock(type="thinking", thinking="Second thought."),- MockBlock(type="tool_use", id="call_1", name="search", input={"q": "x"}),- ]- messages = [- MockMessage("assistant", content),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_1", content="result")],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert len(result) == 2- msg = result[0]- # Expected: thinking1, text, thinking2 in that order within content; tool_calls at end- expected_content = "<think>\nFirst thought.\n</think>\n\nHere is the answer.\n\n<think>\nSecond thought.\n</think>"- assert msg["content"] == expected_content, (- f"Interleaved order lost. Got: {msg['content']!r}"- )- assert len(msg["tool_calls"]) == 1---def test_convert_user_message_text_before_tool_result_order():- """User message with text then tool_result should preserve order: user text first, then tool.-- Bug: Current implementation emits tool_result immediately, then user text at end.- Anthropic order is typically: user says something, then provides tool results.- """- content = [- MockBlock(type="text", text="Please use this result:"),- MockBlock(type="tool_result", tool_use_id="t1", content="42"),- ]- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert len(result) == 2- # Expected: user text first, then tool result- assert result[0]["role"] == "user"- assert result[0]["content"] == "Please use this result:"- assert result[1]["role"] == "tool"- assert result[1]["tool_call_id"] == "t1"---def test_convert_multiple_tool_results():- """Multiple tool results in a single user message."""- content = [- MockBlock(type="tool_result", tool_use_id="t1", content="Result 1"),- MockBlock(type="tool_result", tool_use_id="t2", content="Result 2"),- ]- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert len(result) == 2- assert result[0]["tool_call_id"] == "t1"- assert result[1]["tool_call_id"] == "t2"---def test_convert_user_message_tool_result_dict_as_json():- content = [- MockBlock(- type="tool_result",- tool_use_id="t_dict",- content={"ok": True, "count": 2},- ),- ]- messages = [MockMessage("user", content)]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert result[0]["role"] == "tool"- assert result[0]["content"] == '{"ok": true, "count": 2}'---def test_assistant_redacted_thinking_omitted_from_openai_chat():- """Opaque redacted_thinking is not materialized as content or reasoning_content."""- content = [- MockBlock(type="redacted_thinking", data="secret-opaque"),- MockBlock(type="text", text="Visible."),- ]- messages = [MockMessage("assistant", content)]- result = AnthropicToOpenAIConverter.convert_messages(- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT- )- assert result[0]["content"] == "Visible."- assert "secret-opaque" not in result[0]["content"]- assert "reasoning_content" not in result[0]--- "source,expected_url",- [- (- {"type": "base64", "media_type": "image/png", "data": "AAAA"},- "data:image/png;base64,AAAA",- ),- (- {"type": "url", "url": "https://example.com/image.png"},- "https://example.com/image.png",- ),- ],-)-def test_convert_user_message_image_sources(source, expected_url):- messages = [MockMessage("user", [MockBlock(type="image", source=source)])]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert result == [- {- "role": "user",- "content": [{"type": "image_url", "image_url": {"url": expected_url}}],- }- ]---def test_convert_user_message_preserves_interleaved_image_text_order():- messages = [- MockMessage(- "user",- [- MockBlock(- type="image",- source={- "type": "base64",- "media_type": "image/jpeg",- "data": "FIRST",- },- ),- MockBlock(type="text", text="Compare the first image with this one."),- MockBlock(- type="image",- source={"type": "url", "url": "https://example.com/second.jpg"},- ),- MockBlock(type="text", text="Describe the differences."),- ],- )- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert result == [- {- "role": "user",- "content": [- {- "type": "image_url",- "image_url": {"url": "data:image/jpeg;base64,FIRST"},- },- {- "type": "text",- "text": "Compare the first image with this one.",- },- {- "type": "image_url",- "image_url": {"url": "https://example.com/second.jpg"},- },- {"type": "text", "text": "Describe the differences."},- ],- }- ]---def test_convert_user_image_before_tool_result_preserves_message_order():- messages = [- MockMessage(- "user",- [- MockBlock(type="text", text="Inspect this."),- MockBlock(- type="image",- source={"type": "url", "url": "https://example.com/image.png"},- ),- MockBlock(type="tool_result", tool_use_id="tool_1", content="done"),- ],- )- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert result == [- {- "role": "user",- "content": [- {"type": "text", "text": "Inspect this."},- {- "type": "image_url",- "image_url": {"url": "https://example.com/image.png"},- },- ],- },- {"role": "tool", "tool_call_id": "tool_1", "content": "done"},+ assert [message["role"] for message in messages] == [+ "user",+ "assistant",+ "tool",+ "assistant",+ "user",]+ assert is_synthetic_openai_tool_turn_boundary(messages[3])@pytest.mark.parametrize(- "source,error",+ ("content", "expected"),[+ (None, ""),+ ("plain", "plain"),+ ({"value": 1}, '{"value": 1}'),(- {"type": "base64", "media_type": "", "data": "AAAA"},- "non-empty media_type",- ),- (- {"type": "base64", "media_type": "image/png", "data": ""},- "non-empty data",- ),- ({"type": "url", "url": ""}, "non-empty url"),- ({"type": "file", "file_id": "file_1"}, "Unsupported image source type"),- ({}, "Unsupported image source type"),- ],-)-def test_convert_user_message_rejects_unconvertible_image_sources(source, error):- messages = [MockMessage("user", [MockBlock(type="image", source=source)])]-- with pytest.raises(OpenAIConversionError, match=error):- AnthropicToOpenAIConverter.convert_messages(messages)---def test_convert_assistant_text_after_tool_use_requires_matching_tool_result():- """Dangling post-tool assistant text cannot be replayed as valid OpenAI chat."""- content = [- MockBlock(type="tool_use", id="call_z", name="Read", input={}),- MockBlock(type="text", text="After tool"),- ]- messages = [MockMessage("assistant", content)]- with pytest.raises(OpenAIConversionError, match="missing tool_result"):- AnthropicToOpenAIConverter.convert_messages(messages)---def test_convert_assistant_text_after_tool_use_inserts_after_tool_results():- messages = [- MockMessage(- "assistant",- [- MockBlock(type="tool_use", id="call_z", name="Read", input={}),- MockBlock(type="text", text="Post-tool commentary"),- ],- ),- MockMessage(- "user",- [- MockBlock(- type="tool_result",- tool_use_id="call_z",- content="file contents",- )- ],- ),- ]- result = AnthropicToOpenAIConverter.convert_messages(messages)- assert result[0]["role"] == "assistant" and "tool_calls" in result[0]- assert result[1]["role"] == "tool" and result[1]["tool_call_id"] == "call_z"- assert result[2] == {"role": "assistant", "content": "Post-tool commentary"}---def _completed_single_tool_turn(*, user_text=None):- result_blocks = [- MockBlock(- type="tool_result",- tool_use_id="call_z",- content="file contents",- )- ]- if user_text is not None:- result_blocks.append(MockBlock(type="text", text=user_text))- return [- MockMessage(- "assistant",- [MockBlock(type="tool_use", id="call_z", name="Read", input={})],- ),- MockMessage("user", result_blocks),- ]---def test_unrelated_user_text_before_tool_result_is_buffered_after_closed_tool_turn():- messages = [- MockMessage(- "assistant",- [MockBlock(type="tool_use", id="call_z", name="Read", input={})],+ [{"type": "text", "text": "a"}, {"type": "text", "text": "b"}],+ "a\nb",),- MockMessage("user", "Please also summarize it."),- MockMessage(- "user",- [- MockBlock(- type="tool_result",- tool_use_id="call_z",- content="file contents",- )- ],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- "user",- ]- assert result[0]["tool_calls"][0]["id"] == "call_z"- assert result[1]["tool_call_id"] == "call_z"- assert result[2] == {"role": "assistant", "content": " "}- assert result[3]["content"] == "Please also summarize it."---def test_user_after_completed_tool_result_gets_neutral_assistant_boundary():- messages = [- MockMessage("user", "Read the file."),- *_completed_single_tool_turn(),- MockMessage("user", "Please summarize it."),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "user",- "assistant",- "tool",- "assistant",- "user",- ]- assert result[3] == {"role": "assistant", "content": " "}- assert is_synthetic_openai_tool_turn_boundary(result[3])- assert json.loads(json.dumps(result[3])) == {- "role": "assistant",- "content": " ",- }- assert result[4]["content"] == "Please summarize it."---def test_user_text_beside_tool_result_follows_neutral_assistant_boundary():- messages = _completed_single_tool_turn(user_text="Please summarize it.")-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- "user",- ]- assert result[2] == {"role": "assistant", "content": " "}- assert result[3]["content"] == "Please summarize it."---def test_multiple_tool_results_get_one_assistant_boundary_before_user():- messages = [- MockMessage(- "assistant",- [- MockBlock(type="tool_use", id="call_a", name="ReadA", input={}),- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),- ],- ),- MockMessage(- "user",- [- MockBlock(- type="tool_result",- tool_use_id="call_b",- content="result b",- ),- MockBlock(- type="tool_result",- tool_use_id="call_a",- content="result a",- ),- ],- ),- MockMessage("user", "Compare both results."),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "tool",- "assistant",- "user",- ]- assert [message["tool_call_id"] for message in result[1:3]] == [- "call_a",- "call_b",- ]- assert result[3] == {"role": "assistant", "content": " "}- assert result[4]["content"] == "Compare both results."---def test_terminal_tool_result_does_not_get_assistant_boundary():- messages = _completed_single_tool_turn()-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == ["assistant", "tool"]---def test_existing_assistant_completion_prevents_extra_tool_turn_boundary():- messages = [- *_completed_single_tool_turn(),- MockMessage("assistant", "The file contains useful information."),- MockMessage("user", "Please summarize it."),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- "user",- ]- assert result[2]["content"] == "The file contains useful information."---def test_unrelated_assistant_text_before_tool_result_is_buffered_until_after_tool_result():- messages = [- MockMessage(- "assistant",- [MockBlock(type="tool_use", id="call_z", name="Read", input={})],- ),- MockMessage("assistant", "Waiting for the result."),- MockMessage(- "user",- [- MockBlock(- type="tool_result",- tool_use_id="call_z",- content="file contents",- )- ],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- ]- assert result[0]["tool_calls"][0]["id"] == "call_z"- assert result[1]["tool_call_id"] == "call_z"- assert result[2]["content"] == "Waiting for the result."---def test_user_text_in_tool_result_message_is_replayed_after_tool_sequence():- messages = [- MockMessage(- "assistant",- [- MockBlock(type="tool_use", id="call_z", name="Read", input={}),- MockBlock(type="text", text="Post-tool commentary"),- ],- ),- MockMessage(- "user",- [- MockBlock(type="text", text="Use this result too."),- MockBlock(- type="tool_result",- tool_use_id="call_z",- content="file contents",- ),- ],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- "user",- ]- assert result[1]["tool_call_id"] == "call_z"- assert result[2]["content"] == "Post-tool commentary"- assert result[3]["content"] == "Use this result too."---def test_nested_pending_tool_use_waits_for_its_own_tool_result_before_deferred_text():- messages = [- MockMessage(- "assistant",- [MockBlock(type="tool_use", id="call_a", name="ReadA", input={})],- ),- MockMessage(- "assistant",- [- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),- MockBlock(type="text", text="Post-call-b commentary"),- ],- ),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_a", content="result a")],- ),- MockMessage(- "user",- [MockBlock(type="tool_result", tool_use_id="call_b", content="result b")],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- "tool",- "assistant",- ]- assert result[0]["tool_calls"][0]["id"] == "call_a"- assert result[1]["tool_call_id"] == "call_a"- assert result[2]["tool_calls"][0]["id"] == "call_b"- assert result[3]["tool_call_id"] == "call_b"- assert result[4]["content"] == "Post-call-b commentary"---def test_nested_pending_uses_early_nested_tool_result_after_outer_result():- messages = [- MockMessage(- "assistant",- [MockBlock(type="tool_use", id="call_a", name="ReadA", input={})],- ),- MockMessage(- "assistant",- [- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),- MockBlock(type="text", text="Post-call-b commentary"),- ],- ),- MockMessage(- "user",- [- MockBlock(type="tool_result", tool_use_id="call_b", content="result b"),- MockBlock(type="tool_result", tool_use_id="call_a", content="result a"),- ],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- "tool",- "assistant",- ]- assert result[0]["tool_calls"][0]["id"] == "call_a"- assert result[1]["tool_call_id"] == "call_a"- assert result[2]["tool_calls"][0]["id"] == "call_b"- assert result[3]["tool_call_id"] == "call_b"- assert result[4]["content"] == "Post-call-b commentary"---def test_multi_tool_turn_waits_for_all_results_before_deferred_text():- messages = [- MockMessage(- "assistant",- [- MockBlock(type="tool_use", id="call_a", name="ReadA", input={}),- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),- MockBlock(type="text", text="Both tools are done."),- ],- ),- MockMessage(- "user",- [- MockBlock(type="tool_result", tool_use_id="call_b", content="result b"),- MockBlock(type="tool_result", tool_use_id="call_a", content="result a"),- ],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "tool",- "assistant",- ]- assert [message["tool_call_id"] for message in result[1:3]] == [- "call_a",- "call_b",- ]- assert result[3]["content"] == "Both tools are done."---def test_nested_pending_buffers_user_text_until_all_prior_tool_sequences_complete():- messages = [- MockMessage(- "assistant",- [MockBlock(type="tool_use", id="call_a", name="ReadA", input={})],- ),- MockMessage(- "assistant",- [- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),- MockBlock(type="text", text="Post-call-b commentary"),- ],- ),- MockMessage(- "user",- [- MockBlock(type="text", text="Use both results."),- MockBlock(- type="tool_result",- tool_use_id="call_a",- content="result a",- ),- MockBlock(- type="tool_result",- tool_use_id="call_b",- content="result b",- ),- ],- ),- ]-- result = AnthropicToOpenAIConverter.convert_messages(messages)-- assert [message["role"] for message in result] == [- "assistant",- "tool",- "assistant",- "tool",- "assistant",- "user",- ]- assert result[1]["tool_call_id"] == "call_a"- assert result[3]["tool_call_id"] == "call_b"- assert result[4]["content"] == "Post-call-b commentary"- assert result[5]["content"] == "Use both results."---def test_openai_build_accepts_declared_native_top_level_hints() -> None:- """OpenAI conversion ignores known non-OpenAI hints (e.g. context_management) without 400."""- req = MessagesRequest.model_validate(- {- "model": "m",- "messages": [{"role": "user", "content": "h"}],- "context_management": {"edits": []},- "output_config": {"foo": 1},- "mcp_servers": [{"type": "url", "url": "https://x.com"}],- }- )- body = build_base_request_body(req, default_max_tokens=100)- assert "context_management" not in body- assert "output_config" not in body- assert "mcp_servers" not in body- assert body["model"] == "m"---def test_openai_build_converts_validated_anthropic_image_block() -> None:- request = MessagesRequest.model_validate(- {- "model": "vision-model",- "messages": [- {- "role": "user",- "content": [- {- "type": "image",- "source": {- "type": "base64",- "media_type": "image/webp",- "data": "AAAA",- },- },- {"type": "text", "text": "What is shown?"},- ],- }- ],- }- )-- body = build_base_request_body(request)-- assert body["messages"] == [- {- "role": "user",- "content": [- {- "type": "image_url",- "image_url": {"url": "data:image/webp;base64,AAAA"},- },- {"type": "text", "text": "What is shown?"},- ],- }- ]---def test_openai_build_rejects_unknown_top_level_extras() -> None:- """Truly unknown keys must still be rejected (not dropped silently)."""- req = MessagesRequest.model_validate(- {- "model": "m",- "messages": [{"role": "user", "content": "h"}],- "experimental_client_only_passthrough": True,- }- )- with pytest.raises(OpenAIConversionError, match="top-level request fields"):- build_base_request_body(req)--- "content",- [- [MockBlock(type="server_tool_use", id="1", name="web_search", input={})],- [MockBlock(type="web_search_tool_result", tool_use_id="1", content=[])],- [- MockBlock(- type="web_fetch_tool_result",- tool_use_id="1",- content={"type": "web_fetch_result", "url": "https://a.com/x"},- )- ],],)-def test_convert_assistant_server_tool_blocks_raise(content) -> None:- messages = [MockMessage("assistant", content)]- with pytest.raises(OpenAIConversionError, match="server tool"):- AnthropicToOpenAIConverter.convert_messages(messages)+def test_tool_result_serialization(content: JsonValue, expected: str) -> None:+ assert serialize_tool_result_content(content) == expecteddiff --git a/tests/providers/test_deepinfra.py b/tests/providers/test_deepinfra.pyindex b844e987..70ec0d3e 100644--- a/tests/providers/test_deepinfra.py+++ b/tests/providers/test_deepinfra.py@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -119,8 +120,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images()body = deepinfra_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "deepseek-ai/DeepSeek-V4-Flash"@@ -154,7 +156,9 @@ def test_build_request_body_encodes_documented_reasoning_effort() -> None:request = _request()- body = deepinfra_provider._build_request_body(request, reasoning=reasoning)+ body = deepinfra_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )assert body["extra_body"] == {"reasoning_effort": expected}@@ -164,7 +168,11 @@ def test_build_request_body_preserves_extra_body_without_reasoning_override() -> None:request = _request(extra_body={"service_tier": "priority"})- body = deepinfra_provider._build_request_body(request, reasoning=REASONING_ON)+ body = deepinfra_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )assert body["extra_body"] == {"service_tier": "priority",@@ -180,7 +188,11 @@ def test_build_request_body_rejects_caller_reasoning_override(request = _request(extra_body={field: "caller-owned"})with pytest.raises(InvalidRequestError, match="must not override reasoning"):- deepinfra_provider._build_request_body(request, reasoning=REASONING_ON)+ deepinfra_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )def test_build_request_body_replays_documented_reasoning_content(@@ -204,8 +216,9 @@ def test_build_request_body_replays_documented_reasoning_content()body = deepinfra_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {diff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.pyindex 05f7e154..0e9b04e6 100644--- a/tests/providers/test_deepseek.py+++ b/tests/providers/test_deepseek.py@@ -1,6 +1,6 @@"""Tests for DeepSeek OpenAI-compatible Chat Completions provider."""-import logging+import jsonfrom types import SimpleNamespacefrom unittest.mock import AsyncMock, patch@@ -9,6 +9,7 @@ import pytestfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENSfrom free_claude_code.config.provider_catalog import DEEPSEEK_DEFAULT_BASE+from free_claude_code.core.anthropic.ingress import AnthropicIngressErrorfrom free_claude_code.core.anthropic.models import (ContentBlockDocument,ContentBlockImage,@@ -19,6 +20,7 @@ from free_claude_code.core.anthropic.models import (from free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.providers.deepseek import DeepSeekProviderfrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -153,7 +155,9 @@ def test_build_request_body_openai_chat_shape(deepseek_provider):system="S",)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "deepseek-v4-pro"assert "stream" not in body@@ -170,7 +174,9 @@ def test_build_request_body_default_max_tokens(deepseek_provider):messages=[Message(role="user", content="x")],)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -184,7 +190,9 @@ def test_build_request_body_thinking_enabled(deepseek_provider):})body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "enabled"}@@ -206,7 +214,9 @@ def test_build_request_body_tool_list_keeps_thinking(deepseek_provider):)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "enabled"}@@ -224,7 +234,9 @@ def test_build_request_body_tool_choice_keeps_thinking(deepseek_provider):)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "enabled"}@@ -251,7 +263,9 @@ def test_build_request_body_forced_tool_choice_downgrades_to_auto()body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "enabled"}@@ -275,7 +289,11 @@ def test_build_request_body_encodes_reasoning_off():"thinking": {"type": "enabled", "budget_tokens": 1},})- body = provider._build_request_body(request, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["extra_body"]["thinking"] == {"type": "disabled"}assert "stream_options" not in body@@ -300,7 +318,9 @@ def test_non_tool_thinking_is_omitted_from_first_replay(deepseek_provider):})body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][0] == {"role": "assistant", "content": "out"}@@ -321,7 +341,9 @@ def test_strip_redacted_thinking_when_thinking_on(deepseek_provider):})body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][0] == {"role": "assistant", "content": "out"}@@ -368,7 +390,9 @@ def test_tool_history_with_replayable_thinking_preserves_thinking(deepseek_provi)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["reasoning_effort"] == "high"@@ -378,7 +402,7 @@ def test_tool_history_with_replayable_thinking_preserves_thinking(deepseek_proviassert assistant["content"] == ""assert assistant["reasoning_content"] == "hidden"assert assistant["tool_calls"][0]["function"]["name"] == "Read"- assert assistant["tool_calls"][0]["function"]["arguments"] == '{"file_path": "x"}'+ assert assistant["tool_calls"][0]["function"]["arguments"] == '{"file_path":"x"}'assert body["messages"][1] == {"role": "tool","tool_call_id": "t1",@@ -419,7 +443,9 @@ def test_tool_history_with_unsigned_thinking_preserves_thinking(deepseek_provide)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "enabled"}@@ -465,16 +491,16 @@ def test_tool_history_without_thinking_disables_thinking_and_hints(deepseek_prov"context_management": {"edits": [{"type": "clear_thinking_20251015", "keep": "all"},- {"type": "other_edit", "keep": "all"},],- "other": True,},- "output_config": {"effort": "high", "format": "text"},+ "output_config": {"effort": "high"},})body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "disabled"}@@ -519,7 +545,9 @@ def test_tool_history_with_empty_thinking_preserves_reasoning_state(deepseek_pro)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "enabled"}@@ -562,7 +590,9 @@ def test_tool_history_with_empty_top_level_reasoning_preserves_reasoning_state()body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["thinking"] == {"type": "enabled"}@@ -594,7 +624,11 @@ def test_thinking_off_strips_thinking_history():],})- body = provider._build_request_body(request, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert "reasoning_content" not in body["messages"][0]assert "sec" not in str(body["messages"])@@ -639,7 +673,11 @@ def test_thinking_off_still_replays_required_tool_reasoning():})- body = provider._build_request_body(request, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["extra_body"]["thinking"] == {"type": "disabled"}assert body["messages"][0]["reasoning_content"] == "required"@@ -675,14 +713,16 @@ def test_passthrough_tool_use_and_result(deepseek_provider):})body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][0]["tool_calls"][0]["function"]["name"] == "n"assert body["messages"][1]["role"] == "tool"-def test_preflight_strips_user_image():- """Image blocks are silently stripped (DeepSeek lacks vision); request must not fail."""+def test_preflight_rejects_user_image_for_non_vision_model():+ """Unsupported image input is rejected instead of being silently discarded."""request = MessagesRequest(model="m",messages=[@@ -710,12 +750,12 @@ def test_preflight_strips_user_image():),admission=immediate_admission(),)- # Should not raise; image is stripped.- provider.preflight_stream(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()- assert "image or document inputs" in content.lower()+ with pytest.raises(InvalidRequestError, match="does not support image content"):+ provider.preflight_stream(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=request.model,+ )def test_vision_model_forwards_user_image():@@ -749,8 +789,16 @@ 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)- body = provider._build_request_body(request, reasoning=reasoning_for(request))+ provider.preflight_stream(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )content = body["messages"][0]["content"]assert isinstance(content, list)image_parts = [@@ -768,8 +816,8 @@ def test_vision_model_forwards_user_image():assert text_parts[0]["text"] == "Describe this image"-def test_vision_model_strips_user_document():- """Vision models still omit documents; conversion has no document parts."""+def test_vision_model_rejects_user_document():+ """Unsupported document input is rejected instead of being silently discarded."""request = MessagesRequest(model="deepseek-v4-flash-vision-exp",messages=[@@ -797,66 +845,35 @@ def test_vision_model_strips_user_document():),admission=immediate_admission(),)- provider.preflight_stream(request, reasoning=REASONING_ON)- body = provider._build_request_body(request, reasoning=reasoning_for(request))- content = body["messages"][0]["content"]- assert content- if isinstance(content, str):- lowered = content.lower()- else:- texts = [- part.get("text", "")- for part in content- if isinstance(part, dict) and part.get("type") == "text"- ]- lowered = "\n".join(texts).lower()- assert not any(- isinstance(part, dict) and part.get("type") == "image_url"- for part in content+ with pytest.raises(InvalidRequestError, match="does not support document content"):+ provider.preflight_stream(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=request.model,)- assert "attachment omitted" in lowered- assert "image or document inputs" in lowered-def test_preflight_rejects_mcp_servers():+def test_ingress_rejects_mcp_servers_before_provider_preflight():request = MessagesRequest(model="m",messages=[Message(role="user", content="x")],mcp_servers=[{"type": "url", "url": "https://x"}],)- provider = DeepSeekProvider(- make_provider_config(- api_key="k",- base_url=DEEPSEEK_DEFAULT_BASE,- rate_limit=1,- rate_window=1,- ),- admission=immediate_admission(),- )- with pytest.raises(InvalidRequestError, match="mcp_servers"):- provider.preflight_stream(request)+ with pytest.raises(AnthropicIngressError, match="mcp_servers"):+ canonical_request(request)-def test_preflight_rejects_listed_server_tools_in_tools_list():+def test_ingress_rejects_server_tools_before_provider_preflight():request = MessagesRequest(model="m",messages=[Message(role="user", content="x")],tools=[Tool(name="web_search", type="web_search_20250305", input_schema={})],)- provider = DeepSeekProvider(- make_provider_config(- api_key="k",- base_url=DEEPSEEK_DEFAULT_BASE,- rate_limit=1,- rate_window=1,- ),- admission=immediate_admission(),- )- with pytest.raises(InvalidRequestError, match="web_search"):- provider.preflight_stream(request)+ with pytest.raises(AnthropicIngressError, match="web_search"):+ canonical_request(request)-def test_preflight_rejects_server_tool_result_blocks():+def test_ingress_rejects_server_tool_history_before_provider_preflight():request = MessagesRequest.model_validate({"model": "m",@@ -880,17 +897,8 @@ def test_preflight_rejects_server_tool_result_blocks():],})- provider = DeepSeekProvider(- make_provider_config(- api_key="k",- base_url=DEEPSEEK_DEFAULT_BASE,- rate_limit=1,- rate_window=1,- ),- admission=immediate_admission(),- )- with pytest.raises(InvalidRequestError, match=r"web_search_tool_result|server"):- provider.preflight_stream(request)+ with pytest.raises(AnthropicIngressError, match=r"web_search_tool_result|server"):+ canonical_request(request)def test_non_tool_top_level_reasoning_is_not_replayed(deepseek_provider):@@ -905,7 +913,9 @@ def test_non_tool_top_level_reasoning_is_not_replayed(deepseek_provider):],)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][0] == {"role": "assistant", "content": "hi"}@@ -942,7 +952,9 @@ def test_tool_call_top_level_reasoning_is_replayed(deepseek_provider):)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][0]["reasoning_content"] == "required"@@ -1020,7 +1032,9 @@ async def test_wire_messages_keep_prefix_across_tool_thinking_fallback(})return deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)first_wire = await capture_openai_chat_wire_body(build(prefix_messages))@@ -1081,7 +1095,12 @@ async def test_stream_uses_chat_completions_and_maps_cache_usage(deepseek_providcreate = AsyncMock(return_value=fake_stream())with patch.object(deepseek_provider._client.chat.completions, "create", create):chunks = await collect_anthropic(- deepseek_provider.stream_response(request, input_tokens=7, request_id="r1")+ deepseek_provider.stream_response(+ canonical_request(request),+ input_tokens=7,+ request_id="r1",+ provider_model=(request).model,+ ))create.assert_awaited_once()@@ -1110,7 +1129,9 @@ def test_preserves_extra_body_for_openai_chat_request(deepseek_provider):"extra_body": {"note": 1},}r = MessagesRequest.model_validate(raw)- body = deepseek_provider._build_request_body(r, reasoning=reasoning_for(r))+ body = deepseek_provider._build_request_body(+ canonical_request(r), reasoning=reasoning_for(r), provider_model=(r).model+ )assert body["extra_body"] == {"note": 1}@@ -1149,7 +1170,9 @@ def test_normalizes_tool_result_content_array_to_string(deepseek_provider):)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)tool_result = body["messages"][1]@@ -1159,8 +1182,8 @@ def test_normalizes_tool_result_content_array_to_string(deepseek_provider):assert "file2.txt" in tool_result["content"]-def test_strips_document_blocks_for_deepseek(deepseek_provider):- """Document blocks (e.g. PDFs from Claude Code) are stripped since DeepSeek can't process them."""+def test_rejects_document_blocks_for_deepseek(deepseek_provider):+ """DeepSeek rejects documents instead of forwarding a partial request."""request = MessagesRequest.model_validate({"model": "m",@@ -1184,19 +1207,16 @@ def test_strips_document_blocks_for_deepseek(deepseek_provider):})- body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)- )-- assert body["messages"][0] == {- "role": "tool",- "tool_call_id": "t1",- "content": "PDF text extracted",- }+ with pytest.raises(InvalidRequestError, match="does not support document content"):+ deepseek_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=request.model,+ )-def test_strips_image_blocks_for_deepseek(deepseek_provider):- """Image blocks are stripped for DeepSeek since it doesn't support vision."""+def test_rejects_image_blocks_for_deepseek(deepseek_provider):+ """DeepSeek rejects unsupported images instead of forwarding a partial request."""request = MessagesRequest.model_validate({"model": "m",@@ -1219,11 +1239,12 @@ def test_strips_image_blocks_for_deepseek(deepseek_provider):})- body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)- )-- assert body["messages"][0] == {"role": "user", "content": "describe this"}+ with pytest.raises(InvalidRequestError, match="does not support image content"):+ deepseek_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=request.model,+ )def test_normalizes_tool_result_content_dict_to_string(deepseek_provider):@@ -1258,7 +1279,9 @@ def test_normalizes_tool_result_content_dict_to_string(deepseek_provider):)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)tool_result = body["messages"][1]@@ -1268,8 +1291,8 @@ def test_normalizes_tool_result_content_dict_to_string(deepseek_provider):assert "success" in tool_result["content"]-def test_strips_image_block_inside_tool_result(deepseek_provider):- """Image blocks nested inside tool_result.content are stripped, not rejected."""+def test_preserves_image_descriptor_inside_tool_result(deepseek_provider):+ """Opaque tool output stays lossless even when it describes an image."""request = MessagesRequest.model_validate({"model": "m",@@ -1310,20 +1333,21 @@ def test_strips_image_block_inside_tool_result(deepseek_provider):)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)tool_result = body["messages"][1]assert tool_result["role"] == "tool"- # After stripping + string-normalization, no base64/image marker survives.assert isinstance(tool_result["content"], str)assert "screenshot saved" in tool_result["content"]- assert "base64" not in tool_result["content"]- assert "abc" not in tool_result["content"]+ assert "base64" in tool_result["content"]+ assert "abc" in tool_result["content"]-def test_image_only_tool_result_replaced_with_placeholder(deepseek_provider):- """A tool_result whose only inner block is an image becomes a placeholder string."""+def test_image_only_tool_result_is_serialized_losslessly(deepseek_provider):+ """An image descriptor returned by a tool remains opaque JSON output."""request = MessagesRequest.model_validate({"model": "m",@@ -1363,21 +1387,28 @@ def test_image_only_tool_result_replaced_with_placeholder(deepseek_provider):)body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)tool_result = body["messages"][1]assert tool_result["role"] == "tool"assert isinstance(tool_result["content"], str)- assert tool_result["content"] != ""- assert "attachment omitted" in tool_result["content"].lower()- assert "image or document inputs" in tool_result["content"].lower()+ assert json.loads(tool_result["content"]) == {+ "type": "image",+ "source": {+ "type": "base64",+ "media_type": "image/png",+ "data": "abc",+ },+ }-def test_document_only_tool_result_replaced_with_generic_placeholder(+def test_document_only_tool_result_is_serialized_losslessly(deepseek_provider,):- """A document-only tool_result uses the generic attachment placeholder."""+ """A document descriptor returned by a tool remains opaque JSON output."""request = MessagesRequest.model_validate({"model": "m",@@ -1416,19 +1447,22 @@ def test_document_only_tool_result_replaced_with_generic_placeholder()body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)tool_result = body["messages"][1]assert tool_result["role"] == "tool"assert isinstance(tool_result["content"], str)- assert "attachment omitted" in tool_result["content"].lower()- assert "document inputs" in tool_result["content"].lower()- assert "image omitted" not in tool_result["content"].lower()+ assert json.loads(tool_result["content"]) == {+ "type": "document",+ "source": {"type": "file", "file_id": "file_pdf"},+ }-def test_image_only_message_replaced_with_placeholder(deepseek_provider):- """A top-level image-only message remains non-empty after stripping."""+def test_image_only_message_is_rejected(deepseek_provider):+ """A top-level unsupported image cannot be silently discarded."""request = MessagesRequest.model_validate({"model": "m",@@ -1450,17 +1484,16 @@ def test_image_only_message_replaced_with_placeholder(deepseek_provider):})- body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)- )-- content = body["messages"][0]["content"]- assert "attachment omitted" in content.lower()- assert "image or document inputs" in content.lower()+ with pytest.raises(InvalidRequestError, match="does not support image content"):+ deepseek_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=request.model,+ )-def test_document_only_message_replaced_with_placeholder(deepseek_provider):- """A top-level document-only message remains non-empty after stripping."""+def test_document_only_message_is_rejected(deepseek_provider):+ """A top-level unsupported document cannot be silently discarded."""request = MessagesRequest.model_validate({"model": "m",@@ -1478,90 +1511,9 @@ def test_document_only_message_replaced_with_placeholder(deepseek_provider):})- body = deepseek_provider._build_request_body(- request, reasoning=reasoning_for(request)- )-- content = body["messages"][0]["content"]- assert "attachment omitted" in content.lower()- assert "document inputs" in content.lower()---def test_warns_when_stripping_attachment_blocks(deepseek_provider, caplog):- """A warning is emitted when image/document blocks are dropped so users notice."""- request = MessagesRequest.model_validate(- {- "model": "m",- "messages": [- {- "role": "user",- "content": [- {"type": "text", "text": "look"},- {- "type": "image",- "source": {- "type": "base64",- "media_type": "image/png",- "data": "abc",- },- },- ],- },- {- "role": "assistant",- "content": [- {- "type": "tool_use",- "id": "t1",- "name": "Screenshot",- "input": {},- }- ],- },- {- "role": "user",- "content": [- {- "type": "tool_result",- "tool_use_id": "t1",- "content": [- {- "type": "image",- "source": {- "type": "base64",- "media_type": "image/png",- "data": "abc",- },- },- ],- }- ],- },- ],- }- )-- with caplog.at_level(logging.WARNING):- deepseek_provider._build_request_body(request, reasoning=reasoning_for(request))-- warnings = [r for r in caplog.records if r.levelno == logging.WARNING]- assert any("stripped unsupported attachment blocks" in r.message for r in warnings)---def test_no_warning_when_no_attachments(deepseek_provider, caplog):- """No warning is emitted on plain text-only requests."""- request = MessagesRequest.model_validate(- {- "model": "m",- "messages": [{"role": "user", "content": "hello"}],- }- )-- with caplog.at_level(logging.WARNING):- deepseek_provider._build_request_body(request, reasoning=reasoning_for(request))-- assert not any(- "stripped unsupported attachment blocks" in r.message- for r in caplog.records- if r.levelno == logging.WARNING- )+ with pytest.raises(InvalidRequestError, match="does not support document content"):+ deepseek_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=request.model,+ )diff --git a/tests/providers/test_execution_failure_boundary.py b/tests/providers/test_execution_failure_boundary.pyindex 6b14170d..b3f3ae76 100644--- a/tests/providers/test_execution_failure_boundary.py+++ b/tests/providers/test_execution_failure_boundary.py@@ -19,7 +19,7 @@ from free_claude_code.providers.http import ()from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -102,8 +102,9 @@ async def test_committed_provider_failure_closes_block_then_raises_canonical_valpytest.raises(ExecutionFailure) as exc_info,):async for event in provider.stream_response(- request,+ canonical_request(request),request_id="req_committed_failure",+ provider_model=(request).model,):emitted.extend(presenter.present(event))@@ -143,8 +144,9 @@ async def test_openai_stream_close_failure_cannot_mask_execution_failure() -> No):await collect_anthropic(provider.stream_response(- request,+ canonical_request(request),request_id="req_close_failure",+ provider_model=(request).model,))@@ -280,8 +282,9 @@ async def test_completed_stream_close_failure_preserves_success_lifecycle():emitted = await collect_anthropic(provider.stream_response(- request,+ canonical_request(request),request_id="req_successful_close_failure",+ provider_model=(request).model,))@@ -355,7 +358,11 @@ 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_response(+ canonical_request(request),+ request_id="req_early_close",+ provider_model=(request).model,+ )await anext(stream)assert isinstance(stream, AsyncCloseable)await stream.aclose()diff --git a/tests/providers/test_featherless.py b/tests/providers/test_featherless.pyindex 3cf21f6d..b9b1bfc1 100644--- a/tests/providers/test_featherless.py+++ b/tests/providers/test_featherless.py@@ -15,6 +15,7 @@ from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -116,8 +117,9 @@ def test_build_request_body_preserves_shared_chat_contract()body = featherless_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == _MODEL@@ -143,8 +145,9 @@ def test_build_request_body_encodes_documented_thinking_control(enabled: bool,) -> None:body = featherless_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=reasoning,+ provider_model=(_request()).model,)assert body["extra_body"] == {"chat_template_kwargs": {"enable_thinking": enabled}}@@ -154,8 +157,9 @@ def test_build_request_body_omits_thinking_control_for_provider_default(featherless_provider: OpenAIChatProvider,) -> None:body = featherless_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(_request()).model,)assert "extra_body" not in body@@ -172,7 +176,11 @@ def test_build_request_body_rejects_caller_reasoning_override(request = _request(extra_body={field: "caller-owned"})with pytest.raises(InvalidRequestError, match="must not override reasoning"):- featherless_provider._build_request_body(request, reasoning=REASONING_ON)+ featherless_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )def test_build_request_body_replays_reasoning_and_tool_history(@@ -208,8 +216,9 @@ def test_build_request_body_replays_reasoning_and_tool_history()body = featherless_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {@@ -222,7 +231,7 @@ def test_build_request_body_replays_reasoning_and_tool_history("type": "function","function": {"name": "read_file",- "arguments": '{"path": "example.py"}',+ "arguments": '{"path":"example.py"}',},}],diff --git a/tests/providers/test_fireworks.py b/tests/providers/test_fireworks.pyindex 1229e8db..25730fc2 100644--- a/tests/providers/test_fireworks.py+++ b/tests/providers/test_fireworks.py@@ -9,6 +9,7 @@ from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENfrom free_claude_code.config.provider_catalog import FIREWORKS_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import Message, MessagesRequestfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -51,7 +52,9 @@ def test_build_request_body_openai_chat_shape(fireworks_provider):)body = fireworks_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "accounts/fireworks/models/glm-5p1"@@ -69,7 +72,9 @@ def test_build_request_body_default_max_tokens(fireworks_provider):)body = fireworks_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -98,7 +103,11 @@ def test_replay_is_independent_of_current_turn_reasoning_control():})- body = provider._build_request_body(request, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["messages"][0]["reasoning_content"] == "hidden"assert body["reasoning_effort"] == "none"@@ -114,7 +123,9 @@ def test_build_request_body_preserves_validated_extra_body(fireworks_provider):)body = fireworks_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"] == {"custom_param": "value"}@@ -131,7 +142,9 @@ def test_build_request_body_rejects_reserved_extra_body_keys(fireworks_provider)with pytest.raises(InvalidRequestError, match="extra_body must not override"):fireworks_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)diff --git a/tests/providers/test_gemini.py b/tests/providers/test_gemini.pyindex 0612cddf..42a1bc17 100644--- a/tests/providers/test_gemini.py+++ b/tests/providers/test_gemini.py@@ -6,13 +6,16 @@ import pytestfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.provider_catalog import GEMINI_DEFAULT_BASE+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.inference import ReplayArtifactKind, ReplayAttachmentfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.core.replay_envelope import decode_replay_envelopefrom free_claude_code.providers.gemini import GeminiProviderfrom free_claude_code.providers.google_openai import (GOOGLE_SKIP_THOUGHT_SIGNATURE_VALIDATOR,)from tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -81,7 +84,9 @@ def test_default_base_url_constant():def test_build_request_body_basic(gemini_provider):"""Basic body conversion attaches Gemini thinking fields when thinking is on."""req = make_request()- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = gemini_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert body["model"] == "models/gemini-3.1-flash-lite"assert body["messages"][0]["role"] == "system"@@ -102,7 +107,9 @@ def test_build_request_body_sdk_wire_json_has_literal_extra_body(gemini_provider"""Regression for issue #542: SDK merge must not send top-level google."""req = make_request()- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = gemini_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )wire_json = _simulate_openai_sdk_wire_json(body)assert "reasoning_effort" not in wire_json@@ -128,7 +135,9 @@ def test_build_request_body_reasoning_off_sets_reasoning_none():admission=immediate_admission(),)req = make_request(thinking={"type": "disabled"})- body = provider._build_request_body(req, reasoning=reasoning_for(req))+ body = provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert body["reasoning_effort"] == "none"roles = [m.get("role") for m in body.get("messages", [])]@@ -168,8 +177,9 @@ def test_gemini_reasoning_uses_exactly_one_wire_channel(expected_thinking_config: dict | None,) -> None:body = gemini_provider._build_request_body(- make_request(thinking=None),+ canonical_request(make_request(thinking=None)),reasoning=reasoning,+ provider_model=(make_request(thinking=None)).model,)wire = _simulate_openai_sdk_wire_json(body)@@ -190,8 +200,9 @@ def test_gemini_adaptive_thinking_with_effort_does_not_emit_custom_config()body = gemini_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)wire = _simulate_openai_sdk_wire_json(body)@@ -202,7 +213,9 @@ def test_gemini_adaptive_thinking_with_effort_does_not_emit_custom_config(def test_build_request_body_preserves_caller_extra_body(gemini_provider):req = make_request(extra_body={"metadata": {"user": "u1"}})- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = gemini_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert "reasoning_effort" not in bodyeb = body.get("extra_body")@@ -231,7 +244,9 @@ def test_build_request_body_merges_caller_nested_google(gemini_provider):},)- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = gemini_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert "reasoning_effort" not in bodyeb = body.get("extra_body")@@ -262,8 +277,9 @@ def test_gemini_rejects_caller_thinking_config_with_fcc_reasoning_control(with pytest.raises(InvalidRequestError, match="thinking_config"):gemini_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(request).model,)@@ -277,12 +293,15 @@ def test_gemini_rejects_malformed_google_extension_container(with pytest.raises(InvalidRequestError, match="thinking_config must be an object"):gemini_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(request).model,)-def test_build_request_body_preserves_tool_call_extra_content(gemini_provider):+def test_build_request_body_does_not_replay_unscoped_tool_extra_content(+ gemini_provider,+):req = make_request(system=None,messages=[@@ -314,11 +333,15 @@ def test_build_request_body_preserves_tool_call_extra_content(gemini_provider):],)- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = gemini_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )tool_call = body["messages"][1]["tool_calls"][0]assert tool_call["extra_content"] == {- "google": {"thought_signature": "sig-from-client"}+ "google": {+ "thought_signature": GOOGLE_SKIP_THOUGHT_SIGNATURE_VALIDATOR,+ }}@@ -354,7 +377,9 @@ def test_build_request_body_uses_cached_tool_call_signature(gemini_provider):],)- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = gemini_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )tool_call = body["messages"][1]["tool_calls"][0]assert tool_call["extra_content"] == {@@ -404,7 +429,9 @@ def test_build_request_body_adds_current_turn_fallback_signature(],)- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = gemini_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )tool_calls = body["messages"][1]["tool_calls"]assert tool_calls[0]["extra_content"] == {@@ -439,7 +466,11 @@ async def test_stream_response_text(gemini_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- gemini_provider.stream_response(req, reasoning=reasoning_for(req))+ gemini_provider.stream_response(+ canonical_request(req),+ reasoning=reasoning_for(req),+ provider_model=(req).model,+ ))assert any(@@ -491,16 +522,32 @@ async def test_stream_response_preserves_tool_call_extra_content(gemini_provider) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(gemini_provider.stream_response(req))+ events = await collect_anthropic(+ gemini_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )tool_starts = [event- for event in events- if '"content_block_start"' in event and '"tool_use"' in event+ for event in parse_sse_text("".join(events))+ if event.event == "content_block_start"+ and event.data.get("content_block", {}).get("type") == "tool_use"]- assert any(- '"extra_content"' in event and "sig-stream" in event for event in tool_starts+ assert len(tool_starts) == 1+ extra_content = tool_starts[0].data["content_block"]["extra_content"]+ assert isinstance(extra_content, dict)+ carrier = extra_content.get("fcc_replay")+ assert isinstance(carrier, str)+ artifacts = decode_replay_envelope(+ carrier,+ attachment=ReplayAttachment.TOOL_CALL,)+ assert artifacts is not None+ assert len(artifacts) == 1+ assert artifacts[0].kind is ReplayArtifactKind.THOUGHT_SIGNATURE+ assert artifacts[0].payload == "sig-stream"+ assert artifacts[0].scope is not Noneassert gemini_provider._tool_call_extra_content_by_id["function-call-1"] == {"google": {"thought_signature": "sig-stream"}}@@ -531,7 +578,11 @@ async def test_stream_response_reasoning_content(gemini_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(gemini_provider.stream_response(req))+ events = await collect_anthropic(+ gemini_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )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 a1a6ec29..f7b5a55c 100644--- a/tests/providers/test_github_models.py+++ b/tests/providers/test_github_models.py@@ -17,6 +17,7 @@ from free_claude_code.providers.github_models import GitHubModelsProviderfrom free_claude_code.providers.github_models.client import GITHUB_MODELS_CATALOG_URLfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_ON,immediate_admission,@@ -121,7 +122,11 @@ def test_build_request_body_uses_shared_openai_chat_policy() -> None:request = _request()- body = github_models_provider._build_request_body(request, reasoning=REASONING_ON)+ body = github_models_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )assert body["model"] == "openai/gpt-4.1"assert body["max_tokens"] == 100@@ -218,7 +223,9 @@ async def test_stream_response_text(return_value=_stream(_chunk(delta)),) as mock_create:events = await collect_anthropic(- github_models_provider.stream_response(_request())+ github_models_provider.stream_response(+ canonical_request(_request()), provider_model=(_request()).model+ ))parsed = parse_sse_text("".join(events))@@ -268,7 +275,9 @@ async def test_stream_response_tool_call(return_value=_stream(_chunk(delta, finish_reason="tool_calls")),):events = await collect_anthropic(- github_models_provider.stream_response(request)+ github_models_provider.stream_response(+ canonical_request(request), provider_model=(request).model+ ))parsed = parse_sse_text("".join(events))@@ -302,7 +311,9 @@ async def test_stream_response_reasoning_content(return_value=_stream(_chunk(delta)),):events = await collect_anthropic(- github_models_provider.stream_response(_request())+ github_models_provider.stream_response(+ canonical_request(_request()), provider_model=(_request()).model+ ))parsed = parse_sse_text("".join(events))diff --git a/tests/providers/test_groq.py b/tests/providers/test_groq.pyindex 984a9e6d..cf99cee9 100644--- a/tests/providers/test_groq.py+++ b/tests/providers/test_groq.py@@ -7,7 +7,7 @@ import pytestfrom free_claude_code.config.provider_catalog import GROQ_DEFAULT_BASEfrom free_claude_code.providers.groq import GroqProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -51,7 +51,9 @@ def test_default_base_url_constant():def test_build_request_body_basic(groq_provider):"""Basic request body conversion attaches system message from Claude request."""req = make_request()- body = groq_provider._build_request_body(req)+ body = groq_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )assert body["model"] == "llama-3.3-70b-versatile"assert body["messages"][0]["role"] == "system"@@ -88,7 +90,9 @@ def test_build_request_body_replays_reasoning_as_tagged_content(groq_provider):])- body = groq_provider._build_request_body(request)+ body = groq_provider._build_request_body(+ canonical_request(request), provider_model=(request).model+ )assistant = next(message for message in body["messages"] if message["role"] == "assistant"@@ -119,7 +123,9 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():admission=immediate_admission(),)req = make_request()- body = provider._build_request_body(req)+ body = provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )roles = [m.get("role") for m in body.get("messages", [])]assert "assistant_reasoning_content" not in roles@@ -147,7 +153,9 @@ def test_build_request_body_sanitizes_and_remaps_via_mock_converter(groq_provide"n": 4,}req = make_request()- body = groq_provider._build_request_body(req)+ body = groq_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )msgs = body["messages"]assert msgs[0].get("name") is None and msgs[1].get("name") is None@@ -168,7 +176,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(groq_provider"max_completion_tokens": 77,"max_tokens": 999,}- body = groq_provider._build_request_body(make_request())+ body = groq_provider._build_request_body(+ canonical_request(make_request()), provider_model=(make_request()).model+ )assert body["max_completion_tokens"] == 77assert "max_tokens" not in body@@ -177,7 +187,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(groq_providerdef test_build_request_body_preserves_caller_extra_body(groq_provider):req = make_request(extra_body={"metadata": {"user": "u1"}})- body = groq_provider._build_request_body(req)+ body = groq_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )eb = body.get("extra_body")assert isinstance(eb, dict)@@ -210,7 +222,11 @@ async def test_stream_response_text(groq_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(groq_provider.stream_response(req))+ events = await collect_anthropic(+ groq_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -243,7 +259,11 @@ async def test_stream_response_reasoning_content(groq_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(groq_provider.stream_response(req))+ events = await collect_anthropic(+ groq_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )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 f369dbf3..87eff033 100644--- a/tests/providers/test_groq_reasoning.py+++ b/tests/providers/test_groq_reasoning.py@@ -18,7 +18,7 @@ from free_claude_code.providers.groq.client import (_rewrite_reasoning_effort,)from tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (capture_openai_chat_wire_body,immediate_admission,@@ -332,7 +332,11 @@ async def test_initial_reasoning_policy_reaches_sdk_wire(policy: ReasoningPolicy,expected: str | None,) -> None:- body = _provider()._build_request_body(_request(), reasoning=policy)+ body = _provider()._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ )wire = await capture_openai_chat_wire_body(body)@@ -343,7 +347,11 @@ async def test_initial_reasoning_policy_reaches_sdk_wire(async def test_exact_issue_retries_with_default_and_learns_model() -> None:provider = _provider()policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)- body = provider._build_request_body(_request(), reasoning=policy)+ body = provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ )create = AsyncMock(side_effect=[_vocabulary_error(), object()])with patch.object(provider._client.chat.completions, "create", create):@@ -362,7 +370,11 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:_MODEL: frozenset({"none", "default"})}- next_body = provider._build_request_body(_request(), reasoning=policy)+ next_body = provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ )assert next_body["reasoning_effort"] == "default"next_create = AsyncMock(return_value=object())with patch.object(provider._client.chat.completions, "create", next_create):@@ -380,7 +392,11 @@ def test_cached_none_default_preserves_off() -> None:provider = _provider()provider._model_reasoning_vocabularies[_MODEL] = frozenset({"none", "default"})- body = provider._build_request_body(_request(), reasoning=ReasoningPolicy.off())+ body = provider._build_request_body(+ canonical_request(_request()),+ reasoning=ReasoningPolicy.off(),+ provider_model=(_request()).model,+ )assert body["reasoning_effort"] == "none"@@ -403,8 +419,9 @@ def test_cached_named_vocabulary_preserves_enabled_efforts()body = provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(effort=effort),+ provider_model=(_request()).model,)assert body["reasoning_effort"] == expected@@ -416,7 +433,11 @@ def test_cached_named_vocabulary_omits_unrepresentable_off() -> None:{"low", "medium", "high"})- body = provider._build_request_body(_request(), reasoning=ReasoningPolicy.off())+ body = provider._build_request_body(+ canonical_request(_request()),+ reasoning=ReasoningPolicy.off(),+ provider_model=(_request()).model,+ )assert "reasoning_effort" not in body@@ -425,8 +446,9 @@ def test_cached_named_vocabulary_omits_unrepresentable_off() -> None:async def test_unknown_vocabulary_retries_without_effort_and_negative_caches() -> None:provider = _provider()body = provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(_request()).model,)create = AsyncMock(side_effect=[@@ -447,8 +469,9 @@ async def test_unknown_vocabulary_retries_without_effort_and_negative_caches() -assert "reasoning_effort" not in used_bodyassert provider._model_reasoning_vocabularies[_MODEL] == frozenset()assert "reasoning_effort" not in provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(_request()).model,)@@ -457,9 +480,15 @@ def test_reasoning_cache_isolated_by_opaque_model_id() -> None:policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)provider._model_reasoning_vocabularies[_MODEL] = frozenset({"none", "default"})- learned = provider._build_request_body(_request(_MODEL), reasoning=policy)+ learned = provider._build_request_body(+ canonical_request(_request(_MODEL)),+ reasoning=policy,+ provider_model=(_request(_MODEL)).model,+ )unlearned = provider._build_request_body(- _request("opaque-model-b"), reasoning=policy+ canonical_request(_request("opaque-model-b")),+ reasoning=policy,+ provider_model=(_request("opaque-model-b")).model,)assert learned["reasoning_effort"] == "default"@@ -471,8 +500,16 @@ async def test_concurrent_first_requests_can_learn_without_state_corruption() ->provider = _provider()policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)bodies = [- provider._build_request_body(_request(), reasoning=policy),- provider._build_request_body(_request(), reasoning=policy),+ provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ ),+ provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ ),]initial_calls = 0release_initial_errors = asyncio.Event()@@ -517,7 +554,11 @@ async def test_stale_cache_self_heals_without_guessing_original_effort() -> Noneprovider = _provider()policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)provider._model_reasoning_vocabularies[_MODEL] = frozenset({"none", "default"})- cached_body = provider._build_request_body(_request(), reasoning=policy)+ cached_body = provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ )assert cached_body["reasoning_effort"] == "default"create = AsyncMock(side_effect=[@@ -538,7 +579,11 @@ async def test_stale_cache_self_heals_without_guessing_original_effort() -> Noneassert provider._model_reasoning_vocabularies[_MODEL] == frozenset({"low", "medium", "high"})- rebuilt = provider._build_request_body(_request(), reasoning=policy)+ rebuilt = provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ )assert rebuilt["reasoning_effort"] == "high"@@ -546,8 +591,9 @@ async def test_stale_cache_self_heals_without_guessing_original_effort() -> Noneasync def test_unrelated_400_propagates_without_cache_poisoning() -> None:provider = _provider()body = provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(_request()).model,)create = AsyncMock(side_effect=_BadRequest("messages: invalid role 'wizard'"))@@ -569,8 +615,9 @@ async def test_unrelated_400_propagates_without_cache_poisoning() -> None:async def test_nested_unrelated_allow_list_cannot_retry_or_poison_cache() -> None:provider = _provider()body = provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.off(),+ provider_model=(_request()).model,)error = _BadRequest("invalid request",@@ -600,8 +647,9 @@ async def test_nested_unrelated_allow_list_cannot_retry_or_poison_cache() -> Nonasync def test_advertised_current_value_does_not_retry_or_cache() -> None:provider = _provider()body = provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(_request()).model,)create = AsyncMock(side_effect=_vocabulary_error("`low`, `medium`, or `high`"))@@ -623,7 +671,11 @@ async def test_advertised_current_value_does_not_retry_or_cache() -> None:async def test_last_attempt_learns_but_does_not_exceed_budget() -> None:provider = _provider(max_attempts=1)policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)- body = provider._build_request_body(_request(), reasoning=policy)+ body = provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ )create = AsyncMock(side_effect=_vocabulary_error())with (@@ -641,7 +693,11 @@ async def test_last_attempt_learns_but_does_not_exceed_budget() -> None:{"none", "default"})assert (- provider._build_request_body(_request(), reasoning=policy)["reasoning_effort"]+ provider._build_request_body(+ canonical_request(_request()),+ reasoning=policy,+ provider_model=(_request()).model,+ )["reasoning_effort"]== "default")@@ -650,8 +706,9 @@ async def test_last_attempt_learns_but_does_not_exceed_budget() -> None:async def test_output_cap_and_reasoning_corrections_share_one_session() -> None:provider = _provider()body = provider._build_request_body(- make_messages_request(_MODEL, max_tokens=64_000),+ canonical_request(make_messages_request(_MODEL, max_tokens=64_000)),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(make_messages_request(_MODEL, max_tokens=64_000)).model,)cap_error = _BadRequest("max_completion_tokens must be less than or equal to 40960")create = AsyncMock(side_effect=[cap_error, _vocabulary_error(), object()])@@ -679,8 +736,9 @@ async def test_output_cap_and_reasoning_corrections_share_one_session() -> None:async def test_corrected_request_cannot_enter_vocabulary_retry_loop() -> None:provider = _provider()body = provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(_request()).model,)create = AsyncMock(side_effect=[_vocabulary_error(), _vocabulary_error()])@@ -708,8 +766,9 @@ async def test_reasoning_correction_emits_one_downstream_lifecycle() -> None:raw = "".join(await collect_anthropic(provider.stream_response(- request,+ canonical_request(request),reasoning=policy,+ provider_model=(request).model,)))diff --git a/tests/providers/test_huggingface.py b/tests/providers/test_huggingface.pyindex ba484fae..4561ec54 100644--- a/tests/providers/test_huggingface.py+++ b/tests/providers/test_huggingface.py@@ -6,10 +6,10 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom free_claude_code.config.provider_catalog import HUGGINGFACE_DEFAULT_BASE-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.providers.openai_chat import ReasoningReplayModefrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -76,7 +76,9 @@ def test_build_request_body_keeps_max_tokens(huggingface_provider):"max_tokens": 42,}- body = huggingface_provider._build_request_body(make_request())+ body = huggingface_provider._build_request_body(+ canonical_request(make_request()), provider_model=(make_request()).model+ )mock_convert.assert_called_once()assert (@@ -92,7 +94,9 @@ def test_build_request_body_preserves_caller_extra_body(huggingface_provider):extra_body = {"provider": "auto", "routing": {"bill_to": "my-org"}}req = make_request(extra_body=extra_body)- body = huggingface_provider._build_request_body(req)+ body = huggingface_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )assert body["extra_body"] == extra_bodyassert body["extra_body"] is not extra_body@@ -111,8 +115,9 @@ def test_build_request_body_leaves_reasoning_control_to_selected_upstream(huggingface_provider, reasoning):body = huggingface_provider._build_request_body(- make_request(),+ canonical_request(make_request()),reasoning=reasoning,+ provider_model=(make_request()).model,)assert "reasoning_effort" not in body@@ -137,7 +142,9 @@ def test_build_request_body_does_not_replay_prior_thinking_blocks(],)- body = huggingface_provider._build_request_body(req)+ body = huggingface_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )assert body["messages"] == [{"role": "assistant", "content": "visible answer"}]assert "reasoning_content" not in body["messages"][0]@@ -158,7 +165,9 @@ def test_build_request_body_does_not_replay_top_level_reasoning_content(],)- body = huggingface_provider._build_request_body(req)+ body = huggingface_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )assert body["messages"] == [{"role": "assistant", "content": "visible answer"}]assert "hidden prior reasoning" not in str(body)@@ -188,7 +197,9 @@ async def test_stream_response_text(huggingface_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- huggingface_provider.stream_response(make_request())+ huggingface_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(@@ -221,7 +232,9 @@ async def test_stream_response_reasoning_content(huggingface_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- huggingface_provider.stream_response(make_request())+ huggingface_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(diff --git a/tests/providers/test_kilo.py b/tests/providers/test_kilo.pyindex 807500f2..f163977a 100644--- a/tests/providers/test_kilo.py+++ b/tests/providers/test_kilo.py@@ -15,11 +15,23 @@ from free_claude_code.core.anthropic.stream_contracts import (text_content,thinking_content,)+from free_claude_code.core.inference import (+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+)from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.core.replay_envelope import (+ decode_replay_envelope,+ encode_replay_envelope,+)from free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from free_claude_code.providers.openai_compat import openai_replay_scopefrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -100,7 +112,11 @@ def test_build_request_body_openai_shape(kilo_provider):})- body = kilo_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = kilo_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["model"] == "anthropic/claude-sonnet-4.5"assert body["messages"][0] == {"role": "user", "content": "Hello"}@@ -116,7 +132,11 @@ def test_build_request_body_forwards_caller_extra_body(kilo_provider):})- body = kilo_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = kilo_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body.get("extra_body", {}).get("custom_field") == "value"@@ -142,7 +162,11 @@ def test_extra_body_cannot_override_canonical_request_fields(kilo_provider, fiel)with pytest.raises(InvalidRequestError, match=field):- kilo_provider._build_request_body(request, reasoning=reasoning_for(request))+ kilo_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )def test_build_request_body_sends_reasoning_object(kilo_provider):@@ -154,7 +178,11 @@ def test_build_request_body_sends_reasoning_object(kilo_provider):})- body = kilo_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = kilo_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body.get("extra_body", {}).get("reasoning") is not None@@ -168,8 +196,9 @@ def test_build_request_body_sends_reasoning_disabled(kilo_provider):)body = kilo_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.off(),+ provider_model=(request).model,)assert body["extra_body"]["reasoning"] == {"enabled": False}@@ -182,6 +211,21 @@ def test_build_request_body_replays_opaque_reasoning_details_on_tool_turn("type": "reasoning.opaque","data": {"signature": "opaque-value"},}+ carrier = encode_replay_envelope(+ (+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,+ kind=ReplayArtifactKind.REASONING_DETAILS,+ attachment=ReplayAttachment.REASONING,+ scope=openai_replay_scope(+ "KILO",+ "m",+ replay_format="chat-completions",+ ),+ payload=detail,+ ),+ )+ )request = MessagesRequest.model_validate({"model": "m",@@ -191,7 +235,7 @@ def test_build_request_body_replays_opaque_reasoning_details_on_tool_turn("content": [{"type": "redacted_thinking",- "data": json.dumps(detail),+ "data": carrier,},{"type": "tool_use",@@ -216,8 +260,9 @@ def test_build_request_body_replays_opaque_reasoning_details_on_tool_turn()body = kilo_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assistant = next(msg for msg in body["messages"] if msg["role"] == "assistant")@@ -266,7 +311,11 @@ async def test_stream_uses_reasoning_field_without_duplicating_plain_details(return_value=stream,):event_text = "".join(- await collect_anthropic(kilo_provider.stream_response(request))+ await collect_anthropic(+ kilo_provider.stream_response(+ canonical_request(request), provider_model=(request).model+ )+ ))events = parse_sse_text(event_text)@@ -279,7 +328,16 @@ async def test_stream_uses_reasoning_field_without_duplicating_plain_details(and event.data.get("content_block", {}).get("type") == "redacted_thinking"]assert len(redacted_blocks) == 1- assert json.loads(redacted_blocks[0]["data"]) == encrypted+ artifacts = decode_replay_envelope(+ redacted_blocks[0]["data"],+ attachment=ReplayAttachment.REASONING,+ )+ assert artifacts is not None+ assert len(artifacts) == 1+ assert artifacts[0].kind is ReplayArtifactKind.REASONING_DETAILS+ assert isinstance(artifacts[0].payload, str)+ assert json.loads(artifacts[0].payload) == encrypted+ assert artifacts[0].scope is not Noneassert stream.closed@@ -307,7 +365,11 @@ async def test_stream_restarts_reasoning_reconciliation_after_early_retry(side_effect=[abandoned, recovered],) as create:event_text = "".join(- await collect_anthropic(kilo_provider.stream_response(request))+ await collect_anthropic(+ kilo_provider.stream_response(+ canonical_request(request), provider_model=(request).model+ )+ ))events = parse_sse_text(event_text)@@ -349,8 +411,9 @@ async def test_stream_omits_all_reasoning_representations_when_disabled(event_text = "".join(await collect_anthropic(kilo_provider.stream_response(- request,+ canonical_request(request),reasoning=ReasoningPolicy.off(),+ provider_model=(request).model,)))diff --git a/tests/providers/test_kimi.py b/tests/providers/test_kimi.pyindex 878c3443..c79ad8d4 100644--- a/tests/providers/test_kimi.py+++ b/tests/providers/test_kimi.py@@ -11,6 +11,7 @@ from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENfrom free_claude_code.config.provider_catalog import KIMI_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import Message, MessagesRequestfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -46,7 +47,11 @@ def test_build_request_body_openai_chat(kimi_provider):messages=[Message(role="user", content="hi")],)- body = kimi_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = kimi_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["model"] == "kimi-k2.5"assert body["max_tokens"] == 50@@ -60,7 +65,11 @@ def test_build_request_body_default_max_tokens(kimi_provider):messages=[Message(role="user", content="x")],)- body = kimi_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = kimi_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -75,7 +84,11 @@ def test_build_request_body_rejects_caller_extra_body(kimi_provider):)with pytest.raises(InvalidRequestError, match="Kimi Chat Completions"):- kimi_provider._build_request_body(request, reasoning=reasoning_for(request))+ kimi_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )def test_build_request_body_disables_kimi_thinking(kimi_provider):@@ -87,7 +100,11 @@ def test_build_request_body_disables_kimi_thinking(kimi_provider):})- body = kimi_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = kimi_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["extra_body"]["thinking"] == {"type": "disabled"}diff --git a/tests/providers/test_kimi_code.py b/tests/providers/test_kimi_code.pyindex fd881961..94d05518 100644--- a/tests/providers/test_kimi_code.py+++ b/tests/providers/test_kimi_code.py@@ -10,6 +10,7 @@ from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import KIMI_CODE_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -54,7 +55,9 @@ def test_explicit_output_limit_uses_max_completion_tokens(kimi_code_provider):request = _request(max_tokens=32_768)body = kimi_code_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["max_completion_tokens"] == 32_768@@ -65,7 +68,9 @@ def test_omitted_output_limit_preserves_kimi_default(kimi_code_provider):request = _request()body = kimi_code_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert "max_tokens" not in body@@ -92,7 +97,9 @@ def test_named_reasoning_effort_uses_kimi_vocabulary(request = _request(output_config={"effort": client_effort})body = kimi_code_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["reasoning_effort"] == upstream_effort@@ -102,7 +109,9 @@ def test_enabled_reasoning_without_named_effort_uses_max(kimi_code_provider):request = _request(thinking={"type": "enabled", "budget_tokens": 4_096})body = kimi_code_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["reasoning_effort"] == "max"@@ -112,7 +121,9 @@ def test_disabled_reasoning_uses_none(kimi_code_provider):request = _request(thinking={"type": "disabled"})body = kimi_code_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["reasoning_effort"] == "none"@@ -133,7 +144,9 @@ def test_reasoning_history_uses_reasoning_content(kimi_code_provider):)body = kimi_code_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assistant = body["messages"][0]@@ -146,7 +159,9 @@ def test_caller_extra_body_is_rejected(kimi_code_provider):with pytest.raises(InvalidRequestError, match="Kimi Code Chat Completions"):kimi_code_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.pyindex 58f3ee71..bc1caa8b 100644--- a/tests/providers/test_llamacpp.py+++ b/tests/providers/test_llamacpp.py@@ -8,7 +8,7 @@ from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -79,7 +79,11 @@ def test_build_request_body_uses_openai_chat_shape() -> None:request = make_messages_request(LLAMACPP_MODEL, max_tokens=None)- body = provider._build_request_body(request, reasoning=reasoning_for(request))+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["model"] == LLAMACPP_MODELassert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -105,7 +109,11 @@ def test_replay_is_independent_of_current_turn_reasoning_control(],)- body = provider._build_request_body(request, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["messages"][1]["content"] == ("<think>\nprivate\n</think>\n\nvisible")assert body["extra_body"]["thinking_budget_tokens"] == 0@@ -139,7 +147,10 @@ async def test_stream_response_uses_shared_openai_chat_provider() as create:output = "".join(await collect_anthropic(- provider.stream_response(make_messages_request(LLAMACPP_MODEL))+ provider.stream_response(+ canonical_request(make_messages_request(LLAMACPP_MODEL)),+ provider_model=(make_messages_request(LLAMACPP_MODEL)).model,+ )))diff --git a/tests/providers/test_llm7.py b/tests/providers/test_llm7.pyindex 6ba3a3a7..c3771a94 100644--- a/tests/providers/test_llm7.py+++ b/tests/providers/test_llm7.py@@ -14,6 +14,7 @@ from free_claude_code.core.json_types import JsonObject, JsonValuefrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_DEFAULT,REASONING_OFF,@@ -98,7 +99,11 @@ def test_preserves_provider_reasoning_default_and_standard_request_fields(llm7_provider: OpenAIChatProvider,reasoning: ReasoningPolicy,) -> None:- body = llm7_provider._build_request_body(_request(), reasoning=reasoning)+ body = llm7_provider._build_request_body(+ canonical_request(_request()),+ reasoning=reasoning,+ provider_model=(_request()).model,+ )assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENSassert body["model"] == _MODEL@@ -142,8 +147,9 @@ def test_replays_reasoning_content_with_tool_history()body = llm7_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {@@ -156,7 +162,7 @@ def test_replays_reasoning_content_with_tool_history("type": "function","function": {"name": "read_file",- "arguments": '{"path": "example.py"}',+ "arguments": '{"path":"example.py"}',},}],diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex 16d78b13..0e53c37b 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -11,7 +11,7 @@ from free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.lmstudio import LMStudioProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -57,7 +57,9 @@ def test_default_base_url_constant():def test_build_request_body_basic(lmstudio_provider):req = make_request()- body = lmstudio_provider._build_request_body(req)+ body = lmstudio_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )assert body["model"] == "lmstudio-community/qwen2.5-7b-instruct"assert body["messages"][0]["role"] == "system"@@ -66,7 +68,9 @@ def test_build_request_body_basic(lmstudio_provider):def test_adaptive_client_reasoning_uses_documented_named_effort(lmstudio_provider):req = make_request()- body = lmstudio_provider._build_request_body(req, reasoning=REASONING_ON)+ body = lmstudio_provider._build_request_body(+ canonical_request(req), reasoning=REASONING_ON, provider_model=(req).model+ )assert body["extra_body"]["reasoning_effort"] == "high"assert "reasoning_effort" not in body@@ -76,11 +80,12 @@ def test_exact_client_budget_is_not_derived_from_output_tokens(lmstudio_providerreq = make_request(max_tokens=8192)body = lmstudio_provider._build_request_body(- req,+ canonical_request(req),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH,budget_tokens=1024,),+ provider_model=(req).model,)assert body["extra_body"]["reasoning_tokens"] == 1024@@ -106,7 +111,9 @@ def test_build_request_body_never_replays_prior_thinking(lmstudio_provider):},])- body = lmstudio_provider._build_request_body(req)+ body = lmstudio_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )roles = [m.get("role") for m in body.get("messages", [])]assert "assistant_reasoning_content" not in roles@@ -117,15 +124,17 @@ def test_preflight_builds_before_context_budget_and_preserves_policy(lmstudio_provider,):request = make_request()+ canonical = canonical_request(request)calls: list[tuple[str, object]] = []- def build(request_arg, *, reasoning):- assert request_arg is request+ def build(request_arg, *, provider_model, reasoning):+ assert request_arg is canonical+ assert provider_model == request.modelcalls.append(("build", reasoning))return {}def check_context(request_arg):- assert request_arg is request+ assert request_arg is canonicalcalls.append(("context", request_arg))with (@@ -136,9 +145,13 @@ 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_stream(+ canonical,+ reasoning=REASONING_OFF,+ provider_model=request.model,+ )- assert calls == [("build", REASONING_OFF), ("context", request)]+ assert calls == [("build", REASONING_OFF), ("context", canonical)]def test_preflight_conversion_failure_skips_context_budget(lmstudio_provider):@@ -154,7 +167,11 @@ 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_stream(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )context.assert_not_called()@@ -183,7 +200,11 @@ async def test_stream_response_text(lmstudio_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(lmstudio_provider.stream_response(req))+ events = await collect_anthropic(+ lmstudio_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -219,8 +240,7 @@ async def test_stream_response_passes_exact_reasoning_budget_via_extra_body(events = await collect_anthropic(lmstudio_provider.stream_response(- req,- reasoning=policy,+ canonical_request(req), reasoning=policy, provider_model=(req).model))@@ -262,7 +282,7 @@ def test_preflight_context_budget_rejects_request_over_90_percent(lmstudio_proviwith (patch.object(lmstudio_provider, "_loaded_context_length", return_value=1000),patch(- "free_claude_code.providers.lmstudio.client.get_token_count",+ "free_claude_code.providers.lmstudio.client.get_inference_token_count",return_value=901,),pytest.raises(ExecutionFailure) as exc_info,diff --git a/tests/providers/test_minimax.py b/tests/providers/test_minimax.pyindex 176fef4c..d4e9257d 100644--- a/tests/providers/test_minimax.py+++ b/tests/providers/test_minimax.py@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -102,7 +103,9 @@ def test_build_request_body_requests_split_output_and_max_completion_tokens()body = minimax_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "MiniMax-M3"@@ -120,7 +123,11 @@ def test_build_request_body_does_not_invent_unsupported_compute_control(messages=[Message(role="user", content="Hello")],)- body = minimax_provider._build_request_body(request, reasoning=REASONING_OFF)+ body = minimax_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["extra_body"] == {"reasoning_split": True}@@ -157,7 +164,11 @@ async def test_stream_preserves_reasoning_content(minimax_provider):new_callable=AsyncMock,return_value=stream,) as create:- events = await collect_anthropic(minimax_provider.stream_response(request))+ events = await collect_anthropic(+ minimax_provider.stream_response(+ canonical_request(request), provider_model=(request).model+ )+ )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 4ba6be3f..cdfcee09 100644--- a/tests/providers/test_mistral.py+++ b/tests/providers/test_mistral.py@@ -11,7 +11,7 @@ from free_claude_code.config.provider_catalog import MISTRAL_DEFAULT_BASEfrom free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.mistral import MistralProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -57,7 +57,9 @@ def test_default_base_url():def test_build_request_body_basic(mistral_provider):"""Basic request body conversion works for Mistral."""req = make_request()- body = mistral_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = mistral_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert body["model"] == "devstral-small-latest"assert body["messages"][0]["role"] == "system"@@ -96,7 +98,9 @@ def test_build_request_body_replays_prior_thinking_as_mistral_chunks(],)- body = mistral_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = mistral_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assistant = body["messages"][0]assert "reasoning_content" not in assistant@@ -127,7 +131,9 @@ def test_build_request_body_preserves_tools_tool_choice_and_params(mistral_provistop_sequences=["STOP"],)- body = mistral_provider._build_request_body(req, reasoning=reasoning_for(req))+ body = mistral_provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert body["max_tokens"] == 100assert body["temperature"] == 0.5@@ -148,7 +154,9 @@ def test_build_request_body_reasoning_off_uses_native_none():admission=immediate_admission(),)req = make_request()- body = provider._build_request_body(req, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model+ )assert body["reasoning_effort"] == "none"assert all("reasoning_content" not in m for m in body.get("messages", []))@@ -177,7 +185,9 @@ def test_reasoning_off_keeps_replay_separate_from_new_turn_compute():],)- body = provider._build_request_body(req, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model+ )assert body["reasoning_effort"] == "none"assert body["messages"][0]["content"] == [@@ -215,7 +225,11 @@ async def test_stream_response_text(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -248,7 +262,11 @@ async def test_stream_response_reasoning_content(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"thinking_delta"' in event and "Thinking..." in event for event in events@@ -285,7 +303,11 @@ async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"thinking_delta"' in event and "Native thought." in event for event in events@@ -317,7 +339,11 @@ async def test_stream_response_native_mistral_text_chunk(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert any('"text_delta"' in event and "Native text." in event for event in events)@@ -351,7 +377,11 @@ async def test_stream_response_preserves_native_thinking_and_string_text() as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )event_text = "\n".join(events)assert '"thinking_delta"' in event_text@@ -389,7 +419,11 @@ async def test_stream_response_preserves_native_reasoning_and_string_text() as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )event_text = "\n".join(events)assert "Native reasoning." in event_text@@ -429,7 +463,11 @@ async def test_stream_response_preserves_mixed_native_content_array() as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )event_text = "\n".join(events)assert "Native thought." in event_text@@ -468,7 +506,11 @@ async def test_stream_response_ignores_unknown_native_content_chunks() as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )event_text = "\n".join(events)assert "reference_ids" not in event_text@@ -509,7 +551,11 @@ async def test_stream_response_suppresses_native_mistral_thinking_when_disabled(mock_create.return_value = mock_stream()events = await collect_anthropic(- mistral_provider.stream_response(req, reasoning=REASONING_OFF)+ mistral_provider.stream_response(+ canonical_request(req),+ reasoning=REASONING_OFF,+ provider_model=(req).model,+ ))event_text = "\n".join(events)@@ -571,7 +617,11 @@ async def test_stream_response_retries_without_mistral_reasoning_on_rejection(mock_create.side_effect = [error, mock_stream()]events = await collect_anthropic(- mistral_provider.stream_response(req, reasoning=reasoning_for(req))+ mistral_provider.stream_response(+ canonical_request(req),+ reasoning=reasoning_for(req),+ provider_model=(req).model,+ ))assert mock_create.await_count == 2@@ -639,7 +689,11 @@ async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools(mock_create.side_effect = [error, mock_stream()]events = await collect_anthropic(- mistral_provider.stream_response(req, reasoning=reasoning_for(req))+ mistral_provider.stream_response(+ canonical_request(req),+ reasoning=reasoning_for(req),+ provider_model=(req).model,+ ))second_call = mock_create.await_args_list[1].kwargs@@ -678,7 +732,11 @@ async def test_stream_response_retries_on_mistral_422_reasoning_rejection(mock_create.side_effect = [error, mock_stream()]events = await collect_anthropic(- mistral_provider.stream_response(req, reasoning=reasoning_for(req))+ mistral_provider.stream_response(+ canonical_request(req),+ reasoning=reasoning_for(req),+ provider_model=(req).model,+ ))assert mock_create.await_count == 2@@ -731,7 +789,11 @@ async def test_stream_response_retries_when_model_disables_reasoning_input() as mock_create:mock_create.side_effect = [error, mock_stream()]- events = await collect_anthropic(mistral_provider.stream_response(req))+ events = await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == 2second_call = mock_create.await_args_list[1].kwargs@@ -751,7 +813,11 @@ async def test_stream_response_unrelated_bad_request_does_not_retry(mistral_provmock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- await collect_anthropic(mistral_provider.stream_response(req))+ await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@@ -770,7 +836,11 @@ async def test_stream_response_generic_thinking_error_does_not_retry(mock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- await collect_anthropic(mistral_provider.stream_response(req))+ await collect_anthropic(+ mistral_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )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 888add5e..16f4e548 100644--- a/tests/providers/test_model_discovery.py+++ b/tests/providers/test_model_discovery.py@@ -14,8 +14,11 @@ from free_claude_code.config.provider_catalog import (WAFER_DEFAULT_BASE,)from free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ InferenceStreamLedger,+)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.base import BaseProviderfrom free_claude_code.providers.deepseek import DeepSeekProvider@@ -357,8 +360,9 @@ class FakeProvider(BaseProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:return None@@ -381,9 +385,10 @@ class FakeProvider(BaseProvider):async def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,diff --git a/tests/providers/test_nebius.py b/tests/providers/test_nebius.pyindex 8e446e2e..c94d6dcd 100644--- a/tests/providers/test_nebius.py+++ b/tests/providers/test_nebius.py@@ -13,6 +13,7 @@ from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -64,7 +65,9 @@ def test_encodes_documented_reasoning_effort(})- body = nebius_provider._build_request_body(request, reasoning=reasoning)+ body = nebius_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )assert body["reasoning_effort"] == expectedassert "extra_body" not in body@@ -89,8 +92,9 @@ def test_replays_reasoning_content(nebius_provider: OpenAIChatProvider) -> None:)body = nebius_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {diff --git a/tests/providers/test_novita.py b/tests/providers/test_novita.pyindex 3909fc32..67f731bc 100644--- a/tests/providers/test_novita.py+++ b/tests/providers/test_novita.py@@ -10,6 +10,7 @@ from free_claude_code.config.provider_catalog import NOVITA_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import Message, MessagesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -53,7 +54,9 @@ def test_build_request_body_openai_chat_shape(novita_provider):)body = novita_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "deepseek/deepseek-v4-flash-0731"@@ -71,7 +74,9 @@ def test_build_request_body_default_max_tokens(novita_provider):)body = novita_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -87,7 +92,9 @@ def test_build_request_body_preserves_validated_extra_body(novita_provider):)body = novita_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["custom_param"] == "value"@@ -105,7 +112,11 @@ def test_build_request_body_rejects_reserved_reasoning_extra_body_keys()with pytest.raises(InvalidRequestError, match="extra_body must not override"):- novita_provider._build_request_body(request, reasoning=reasoning_for(request))+ novita_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )def test_build_request_body_disables_thinking_when_reasoning_off(novita_provider):@@ -114,7 +125,11 @@ def test_build_request_body_disables_thinking_when_reasoning_off(novita_providermessages=[Message(role="user", content="x")],)- body = novita_provider._build_request_body(request, reasoning=REASONING_OFF)+ body = novita_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["extra_body"]["enable_thinking"] is False@@ -125,7 +140,11 @@ def test_build_request_body_enables_thinking_when_reasoning_on(novita_provider):messages=[Message(role="user", content="x")],)- body = novita_provider._build_request_body(request, reasoning=REASONING_ON)+ body = novita_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )assert body["extra_body"]["enable_thinking"] is True@@ -137,7 +156,9 @@ def test_build_request_body_omits_thinking_field_by_default(novita_provider):)body = novita_provider._build_request_body(- request, reasoning=ReasoningPolicy.provider_default()+ canonical_request(request),+ reasoning=ReasoningPolicy.provider_default(),+ provider_model=(request).model,)assert "enable_thinking" not in body.get("extra_body", {})diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.pyindex 73aab9f7..cd3fc44e 100644--- a/tests/providers/test_nvidia_nim.py+++ b/tests/providers/test_nvidia_nim.py@@ -16,7 +16,7 @@ from free_claude_code.providers.nvidia_nim.tool_schema import ()from free_claude_code.providers.stream_recovery import RecoveryHoldbackBufferfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -178,7 +178,9 @@ async def test_build_request_body(provider_config):admission=immediate_admission(),)req = make_request()- body = provider._build_request_body(req, reasoning=reasoning_for(req))+ body = provider._build_request_body(+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model+ )assert body["model"] == "test-model"assert body["temperature"] == 0.5@@ -204,7 +206,9 @@ async def test_build_request_body_encodes_explicit_reasoning_off(admission=immediate_admission(),)req = make_request()- body = provider._build_request_body(req, reasoning=REASONING_OFF)+ body = provider._build_request_body(+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model+ )extra = body.get("extra_body", {})assert extra["chat_template_kwargs"] == {@@ -215,7 +219,7 @@ async def test_build_request_body_encodes_explicit_reasoning_off(@pytest.mark.asyncio-async def test_build_request_body_omits_reasoning_when_request_disables_thinking(+async def test_build_request_body_does_not_reresolve_client_reasoning(provider_config,):provider = NvidiaNimProvider(@@ -223,9 +227,10 @@ async def test_build_request_body_omits_reasoning_when_request_disables_thinkingnim_settings=NimSettings(),admission=immediate_admission(),)- req = make_request()- req.thinking.enabled = False- body = provider._build_request_body(req)+ req = make_request(thinking={"enabled": False})+ body = provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )extra = body.get("extra_body", {})assert "chat_template_kwargs" not in extra@@ -262,8 +267,12 @@ def test_preflight_and_build_request_issue_206_post_tool_text(nim_provider):),],)- nim_provider.preflight_stream(req, reasoning=REASONING_OFF)- body = nim_provider._build_request_body(req, reasoning=REASONING_OFF)+ nim_provider.preflight_stream(+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model+ )+ body = nim_provider._build_request_body(+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model+ )assert "messages" in bodyassert any(m.get("role") == "tool" for m in body["messages"])@@ -300,7 +309,11 @@ async def test_stream_response_text(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert len(events) > 0assert "event: message_start" in events[0]@@ -348,7 +361,11 @@ async def test_stream_response_thinking_reasoning_content(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )# Check for thinking_deltafound_thinking = False@@ -391,7 +408,11 @@ async def test_stream_response_suppresses_thinking_when_disabled(provider_configmock_create.return_value = mock_stream()events = await collect_anthropic(- provider.stream_response(req, reasoning=REASONING_OFF)+ provider.stream_response(+ canonical_request(req),+ reasoning=REASONING_OFF,+ provider_model=(req).model,+ ))event_text = "".join(events)@@ -438,7 +459,11 @@ async def test_stream_response_retries_without_chat_template(provider_config):mock_create.side_effect = [first_error, mock_stream()]events = await collect_anthropic(- provider.stream_response(req, reasoning=REASONING_ON)+ provider.stream_response(+ canonical_request(req),+ reasoning=REASONING_ON,+ provider_model=(req).model,+ ))assert mock_create.await_count == 2@@ -495,7 +520,11 @@ async def test_stream_response_retries_without_chat_template_kwargs_issue_993(mock_create.side_effect = [first_error, mock_stream()]events = await collect_anthropic(- provider.stream_response(req, reasoning=REASONING_ON)+ provider.stream_response(+ canonical_request(req),+ reasoning=REASONING_ON,+ provider_model=(req).model,+ ))assert mock_create.await_count == 2@@ -532,7 +561,11 @@ 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:- await collect_anthropic(provider.stream_response(req))+ await collect_anthropic(+ provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@@ -567,7 +600,11 @@ async def test_tool_call_stream(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )starts = [e for e in events if "event: content_block_start" in e and '"tool_use"' in e@@ -609,7 +646,11 @@ async def test_native_minimax_tool_markup_becomes_anthropic_tool_use(nim_provide) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )event_text = "".join(events)assert namespace not in event_text@@ -657,7 +698,11 @@ async def test_native_minimax_reasoning_markup_becomes_anthropic_tool_use() as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )event_text = "".join(events)assert namespace not in event_text@@ -693,7 +738,11 @@ async def test_native_minimax_markup_without_tools_retries_without_leaking() as mock_create:mock_create.side_effect = attempts- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )event_text = "".join(events)assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS@@ -738,7 +787,11 @@ async def test_native_minimax_tool_markup_restores_nim_argument_aliases(nim_prov) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert json.loads(_input_json_deltas(events)[0]) == {"pattern": "needle",@@ -789,7 +842,11 @@ async def test_malformed_native_minimax_tool_call_retries_without_leaking() as mock_create:mock_create.side_effect = [malformed_stream(), recovered_stream()]- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == 2event_text = "".join(events)@@ -855,7 +912,11 @@ async def test_midstream_native_tool_suffix_failure_recovers_without_duplication):mock_create.side_effect = [malformed_stream(), recovered_stream()]- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == 2event_text = "".join(events)@@ -899,7 +960,11 @@ async def test_stream_response_restores_aliased_tool_arguments(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )await_args = mock_create.await_argsassert await_args is not None@@ -956,7 +1021,11 @@ async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provid) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1002,7 +1071,11 @@ async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provid) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1048,7 +1121,11 @@ async def test_stream_response_task_tool_still_forces_background_false(nim_provi) as mock_create:mock_create.return_value = mock_stream()- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1080,8 +1157,9 @@ async def test_stream_response_retries_without_reasoning_budget(nim_provider):events = await collect_anthropic(nim_provider.stream_response(- req,+ canonical_request(req),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),+ provider_model=(req).model,))@@ -1126,7 +1204,9 @@ async def test_stream_response_retries_without_budget_for_thinking_token_error(events = await collect_anthropic(nim_provider.stream_response(- req, reasoning=ReasoningPolicy.on(budget_tokens=77)+ canonical_request(req),+ reasoning=ReasoningPolicy.on(budget_tokens=77),+ provider_model=(req).model,))@@ -1191,7 +1271,11 @@ async def test_stream_response_retries_without_reasoning_content(nim_provider):) as mock_create:mock_create.side_effect = [error, mock_stream()]- events = await collect_anthropic(nim_provider.stream_response(req))+ events = await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == 2first_call = mock_create.await_args_list[0].kwargs@@ -1216,7 +1300,11 @@ async def test_stream_response_bad_request_without_reasoning_budget_does_not_retmock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- await collect_anthropic(nim_provider.stream_response(req))+ await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@@ -1235,7 +1323,11 @@ async def test_stream_response_unrelated_internal_error_does_not_downgrade(mock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- await collect_anthropic(nim_provider.stream_response(req))+ await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTSassert all(@@ -1260,7 +1352,11 @@ async def test_stream_response_internal_reasoning_content_error_does_not_downgramock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- await collect_anthropic(nim_provider.stream_response(req))+ await collect_anthropic(+ nim_provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )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 83558cb2..a2dfaebb 100644--- a/tests/providers/test_nvidia_nim_degraded_retry.py+++ b/tests/providers/test_nvidia_nim_degraded_retry.py@@ -21,7 +21,7 @@ from free_claude_code.providers.failure_policy import (from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.open_router import OpenRouterProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import make_provider_config_FUNCTION_ID = "87ea0ddc-cff1-4bca-bf8b-3bd98a35ddd0"@@ -139,7 +139,9 @@ async def test_degraded_function_retries_unchanged_request_then_succeeds() -> No):events = await collect_anthropic(provider.stream_response(- make_messages_request(), request_id="req_recovered"+ canonical_request(make_messages_request()),+ request_id="req_recovered",+ provider_model=(make_messages_request()).model,))@@ -173,7 +175,11 @@ async def test_degraded_function_exhaustion_is_detailed_redacted_overload() -> Npytest.raises(ExecutionFailure) as exc_info,):await collect_anthropic(- provider.stream_response(make_messages_request(), request_id="req_degraded")+ provider.stream_response(+ canonical_request(make_messages_request()),+ request_id="req_degraded",+ provider_model=(make_messages_request()).model,+ ))assert create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS@@ -217,7 +223,11 @@ async def test_negative_derived_max_tokens_is_context_window_failure(pytest.raises(ExecutionFailure) as exc_info,):await collect_anthropic(- provider.stream_response(make_messages_request(), request_id="req_context")+ provider.stream_response(+ canonical_request(make_messages_request()),+ request_id="req_context",+ provider_model=(make_messages_request()).model,+ ))assert create.await_count == 1@@ -251,7 +261,9 @@ async def test_negative_derived_max_tokens_is_context_window_failure_on_500():await collect_anthropic(provider.stream_response(- make_messages_request(), request_id="req_context_500"+ canonical_request(make_messages_request()),+ request_id="req_context_500",+ provider_model=(make_messages_request()).model,))@@ -292,7 +304,12 @@ async def test_other_nim_max_token_errors_remain_invalid_requests() as create,pytest.raises(ExecutionFailure) as exc_info,):- await collect_anthropic(provider.stream_response(make_messages_request()))+ await collect_anthropic(+ provider.stream_response(+ canonical_request(make_messages_request()),+ provider_model=(make_messages_request()).model,+ )+ )assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUEST@@ -323,7 +340,12 @@ async def test_unrelated_nim_bad_request_is_not_retried(detail: str) -> None:) as create,pytest.raises(ExecutionFailure) as exc_info,):- await collect_anthropic(provider.stream_response(make_messages_request()))+ await collect_anthropic(+ provider.stream_response(+ canonical_request(make_messages_request()),+ provider_model=(make_messages_request()).model,+ )+ )assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUEST@@ -350,7 +372,12 @@ async def test_degraded_wording_remains_non_retryable_for_other_providers() -> N) as create,pytest.raises(ExecutionFailure) as exc_info,):- await collect_anthropic(provider.stream_response(make_messages_request()))+ await collect_anthropic(+ provider.stream_response(+ canonical_request(make_messages_request()),+ provider_model=(make_messages_request()).model,+ )+ )assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUESTdiff --git a/tests/providers/test_nvidia_nim_request.py b/tests/providers/test_nvidia_nim_request.pyindex 84b22b87..dfc58e06 100644--- a/tests/providers/test_nvidia_nim_request.py+++ b/tests/providers/test_nvidia_nim_request.py@@ -8,13 +8,12 @@ import pytestfrom free_claude_code.config.nim import NimSettingsfrom free_claude_code.core.anthropic import set_if_not_none-from free_claude_code.core.anthropic.models import MessagesRequest, Tool+from free_claude_code.core.anthropic.models import Tool+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.nvidia_nim.request_options import (_set_extra,-)-from free_claude_code.providers.nvidia_nim.request_options import (- build_nim_request_body as build_request_body,+ build_nim_request_body,)from free_claude_code.providers.nvidia_nim.retry import (clone_body_without_chat_template,@@ -51,19 +50,41 @@ GREP_SCHEMA_FROM_SERVER_LOG: dict[str, Any] = {@pytest.fixture-def req() -> MessagesRequest:+def req() -> InferenceRequest:+ return make_request()+++def make_request(**overrides: object) -> InferenceRequest:+ data: dict[str, object] = {+ "messages": [{"role": "user", "content": "hi"}],+ "max_tokens": 100,+ "system": None,+ "temperature": None,+ "top_p": None,+ "stop_sequences": None,+ "tools": None,+ "extra_body": None,+ "top_k": None,+ "thinking": None,+ }+ data.update(overrides)return make_messages_request(model="test",- messages=[{"role": "user", "content": "hi"}],- max_tokens=100,- system=None,- temperature=None,- top_p=None,- stop_sequences=None,- tools=None,- extra_body=None,- top_k=None,- thinking=None,+ **data,+ )+++def build_request_body(+ request: InferenceRequest,+ nim: NimSettings,+ *,+ reasoning: ReasoningPolicy,+) -> dict[str, Any]:+ return build_nim_request_body(+ request,+ nim,+ provider_model=request.model,+ reasoning=reasoning,)@@ -157,15 +178,15 @@ class TestBuildRequestBody:"reasoning_budget": 2048,}- def test_max_tokens_capped_by_nim(self, req):- req.max_tokens = 100000+ def test_max_tokens_capped_by_nim(self):+ req = make_request(max_tokens=100000)nim = NimSettings(max_tokens=4096)body = build_request_body(req, nim, reasoning=REASONING_ON)assert body["max_tokens"] == 4096@pytest.mark.parametrize("client_top_p", (None, 0.0, 0.5, 0.95, 1.0))- def test_top_p_always_uses_nim_policy(self, req, client_top_p):- req.top_p = client_top_p+ def test_top_p_always_uses_nim_policy(self, client_top_p):+ req = make_request(top_p=client_top_p)body = build_request_body(req, NimSettings(), reasoning=REASONING_ON)@@ -186,7 +207,7 @@ class TestBuildRequestBody:assert body["parallel_tool_calls"] is Falsedef test_tool_schema_boolean_subschemas_are_removed_without_mutating_request(- self, req+ self,):tool_schema = {"type": "object",@@ -199,13 +220,15 @@ class TestBuildRequestBody:"additionalProperties": False,"required": ["query"],}- req.tools = [- Tool(- name="search",- description="search",- input_schema=tool_schema,- )- ]+ req = make_request(+ tools=[+ Tool(+ name="search",+ description="search",+ input_schema=tool_schema,+ )+ ]+ )body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)@@ -219,7 +242,7 @@ class TestBuildRequestBody:assert tool_schema["additionalProperties"] is Falseassert tool_schema["properties"]["nested"]["additionalProperties"] is False- def test_grep_schema_type_parameter_is_aliased_without_mutating_request(self, req):+ def test_grep_schema_type_parameter_is_aliased_without_mutating_request(self):tool_schema = deepcopy(GREP_SCHEMA_FROM_SERVER_LOG)tool_schema["properties"]["_fcc_arg_type"] = {"type": "string",@@ -227,13 +250,15 @@ class TestBuildRequestBody:}tool_schema["required"] = ["pattern", "-A", "_fcc_arg_type"]original_schema = deepcopy(tool_schema)- req.tools = [- Tool(- name="Grep",- description="Search file contents",- input_schema=tool_schema,- )- ]+ req = make_request(+ tools=[+ Tool(+ name="Grep",+ description="Search file contents",+ input_schema=tool_schema,+ )+ ]+ )body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)@@ -263,7 +288,7 @@ class TestBuildRequestBody:assert "_fcc_arg_type" in parameters["required"]assert tool_schema == original_schema- def test_reported_long_tool_name_uses_generic_alias_after_nim_repairs(self, req):+ def test_reported_long_tool_name_uses_generic_alias_after_nim_repairs(self):"""Issue #1307's 52nd tool is portable without losing NIM arg aliases."""long_name = "mcp__issue_1307__" + "x" * 85assert len(long_name) == 102@@ -281,8 +306,8 @@ class TestBuildRequestBody:},))- req.tools = tools- snapshot = req.model_dump()+ req = make_request(tools=tools)+ snapshot = reqbody = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)@@ -290,15 +315,15 @@ class TestBuildRequestBody:assert wire_name != long_nameassert re.fullmatch(r"[A-Za-z0-9_-]{1,64}", wire_name)assert body[NIM_TOOL_ARGUMENT_ALIASES_KEY] == {- long_name: {"_fcc_arg_type": "type"}+ wire_name: {"_fcc_arg_type": "type"}}assert (NIM_TOOL_ARGUMENT_ALIASES_KEYnot in body_without_nim_tool_argument_aliases(body))- assert req.model_dump() == snapshot+ assert req is snapshot- def test_safe_tool_schema_does_not_add_alias_metadata(self, req):+ def test_safe_tool_schema_does_not_add_alias_metadata(self):tool_schema = {"type": "object","properties": {@@ -308,13 +333,15 @@ class TestBuildRequestBody:},"required": ["pattern"],}- req.tools = [- Tool(- name="Glob",- description="Find files",- input_schema=tool_schema,- )- ]+ req = make_request(+ tools=[+ Tool(+ name="Glob",+ description="Find files",+ input_schema=tool_schema,+ )+ ]+ )body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)@@ -324,7 +351,7 @@ class TestBuildRequestBody:assert parameters["required"] == ["pattern"]def test_nested_schema_keyword_properties_are_aliased_without_mutating_request(- self, req+ self,):tool_schema = {"type": "object",@@ -341,13 +368,15 @@ class TestBuildRequestBody:"required": ["parent"],}original_schema = deepcopy(tool_schema)- req.tools = [- Tool(- name="NotionLike",- description="Nested type schema",- input_schema=tool_schema,- )- ]+ req = make_request(+ tools=[+ Tool(+ name="NotionLike",+ description="Nested type schema",+ input_schema=tool_schema,+ )+ ]+ )body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)diff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.pyindex 4cde616f..6eeb6681 100644--- a/tests/providers/test_ollama.py+++ b/tests/providers/test_ollama.py@@ -14,7 +14,7 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -80,7 +80,10 @@ def test_cloud_init_uses_fixed_openai_endpoint_and_api_key() -> None:def test_build_request_body_uses_openai_chat_shape() -> None:- body = _provider()._build_request_body(make_messages_request(OLLAMA_MODEL))+ body = _provider()._build_request_body(+ canonical_request(make_messages_request(OLLAMA_MODEL)),+ provider_model=(make_messages_request(OLLAMA_MODEL)).model,+ )assert body["model"] == OLLAMA_MODELassert body["messages"][0]["role"] == "system"@@ -94,7 +97,9 @@ def test_cloud_build_request_body_forwards_client_reasoning_effort() -> None:OLLAMA_CLOUD_MODEL, output_config={"effort": "high"})body = _cloud_provider()._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == OLLAMA_CLOUD_MODEL@@ -131,7 +136,9 @@ def test_cloud_build_request_body_replays_thinking_in_ollama_reasoning_field() -)body = _cloud_provider()._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assistant = next(@@ -157,7 +164,11 @@ def test_replay_is_independent_of_disabled_current_turn_reasoning(provider) -> N],)- body = provider()._build_request_body(request, reasoning=REASONING_OFF)+ body = provider()._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assistant = next(message for message in body["messages"] if message["role"] == "assistant")@@ -195,7 +206,10 @@ async def test_stream_response_uses_shared_openai_chat_provider() -> None:) as create:output = "".join(await collect_anthropic(- provider.stream_response(make_messages_request(OLLAMA_MODEL))+ provider.stream_response(+ canonical_request(make_messages_request(OLLAMA_MODEL)),+ provider_model=(make_messages_request(OLLAMA_MODEL)).model,+ )))@@ -232,7 +246,10 @@ async def test_cloud_stream_maps_ollama_reasoning_delta_to_anthropic_thinking()):output = "".join(await collect_anthropic(- client.stream_response(make_messages_request(OLLAMA_CLOUD_MODEL))+ client.stream_response(+ canonical_request(make_messages_request(OLLAMA_CLOUD_MODEL)),+ provider_model=(make_messages_request(OLLAMA_CLOUD_MODEL)).model,+ )))diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.pyindex d692a9bf..8d09edc7 100644--- a/tests/providers/test_open_router.py+++ b/tests/providers/test_open_router.py@@ -1,6 +1,7 @@"""Tests for the OpenRouter OpenAI-chat provider."""import json+from collections.abc import Mappingfrom types import SimpleNamespacefrom unittest.mock import AsyncMock, MagicMock, patch@@ -14,10 +15,22 @@ from free_claude_code.core.anthropic.stream_contracts import (text_content,thinking_content,)+from free_claude_code.core.inference import (+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+)+from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.replay_envelope import (+ decode_replay_envelope,+ encode_replay_envelope,+)from free_claude_code.providers.open_router import OpenRouterProviderfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from free_claude_code.providers.openai_compat import openai_replay_scopefrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -46,6 +59,24 @@ def make_request(**overrides):return make_messages_request("moonshotai/kimi-k2.6:free", **overrides)+def _reasoning_carrier(detail: Mapping[str, JsonValue], *, model: str = "m") -> str:+ return encode_replay_envelope(+ (+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENROUTER,+ kind=ReplayArtifactKind.REASONING_DETAILS,+ attachment=ReplayAttachment.REASONING,+ scope=openai_replay_scope(+ "OPENROUTER",+ model,+ replay_format="chat-completions",+ ),+ payload=detail,+ ),+ )+ )++@pytest.fixturedef open_router_provider():return OpenRouterProvider(@@ -84,7 +115,9 @@ def test_init_uses_openai_chat_provider(open_router_provider):def test_build_request_body_uses_openai_chat_shape(open_router_provider):- body = open_router_provider._build_request_body(make_request())+ body = open_router_provider._build_request_body(+ canonical_request(make_request()), provider_model=(make_request()).model+ )assert body["model"] == "moonshotai/kimi-k2.6:free"assert body["temperature"] == 0.5@@ -97,7 +130,10 @@ def test_build_request_body_uses_openai_chat_shape(open_router_provider):def test_build_request_body_default_max_tokens(open_router_provider):- body = open_router_provider._build_request_body(make_request(max_tokens=None))+ body = open_router_provider._build_request_body(+ canonical_request(make_request(max_tokens=None)),+ provider_model=(make_request(max_tokens=None)).model,+ )assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -107,14 +143,20 @@ def test_openrouter_extra_body_rejects_overriding_reserved_fields():with pytest.raises(InvalidRequestError, match="model"):open_router_provider._build_request_body(- make_request(extra_body={"model": "hijack"})+ canonical_request(make_request(extra_body={"model": "hijack"})),+ provider_model=(make_request(extra_body={"model": "hijack"})).model,)def test_openrouter_extra_body_allows_provider_keys(open_router_provider):body = open_router_provider._build_request_body(- make_request(extra_body={"transforms": ["no-web"], "plugins": []}),+ canonical_request(+ make_request(extra_body={"transforms": ["no-web"], "plugins": []})+ ),reasoning=REASONING_OFF,+ provider_model=(+ make_request(extra_body={"transforms": ["no-web"], "plugins": []})+ ).model,)assert body["extra_body"] == {@@ -129,7 +171,9 @@ def test_build_request_body_disables_reasoning_when_client_disables_it():request = make_request(thinking={"type": "disabled"})body = open_router_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["reasoning"] == {"enabled": False}@@ -140,7 +184,9 @@ def test_build_request_body_maps_thinking_budget_to_reasoning_max_tokens():request = make_request(thinking={"type": "enabled", "budget_tokens": 4096})body = open_router_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["extra_body"]["reasoning"] == {"max_tokens": 4096}@@ -159,7 +205,7 @@ def test_build_request_body_replays_openrouter_reasoning_details("content": [{"type": "redacted_thinking",- "data": '{"type":"reasoning.encrypted","data":"opaque"}',+ "data": _reasoning_carrier(detail),},{"type": "text", "text": "Need a tool."},],@@ -170,7 +216,9 @@ def test_build_request_body_replays_openrouter_reasoning_details()body = open_router_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assistant = next(msg for msg in body["messages"] if msg["role"] == "assistant")@@ -189,7 +237,7 @@ def test_reasoning_details_skip_neutral_tool_turn_boundary(open_router_provider)"content": [{"type": "redacted_thinking",- "data": json.dumps(first_detail),+ "data": _reasoning_carrier(first_detail),},{"type": "tool_use",@@ -215,7 +263,7 @@ def test_reasoning_details_skip_neutral_tool_turn_boundary(open_router_provider)"content": [{"type": "redacted_thinking",- "data": json.dumps(second_detail),+ "data": _reasoning_carrier(second_detail),},{"type": "text", "text": "done"},],@@ -225,7 +273,9 @@ def test_reasoning_details_skip_neutral_tool_turn_boundary(open_router_provider))body = open_router_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assistants = [@@ -250,7 +300,7 @@ def test_reasoning_details_preserve_redacted_only_assistant_after_tool("content": [{"type": "redacted_thinking",- "data": json.dumps(first_detail),+ "data": _reasoning_carrier(first_detail),},{"type": "tool_use",@@ -275,7 +325,7 @@ def test_reasoning_details_preserve_redacted_only_assistant_after_tool("content": [{"type": "redacted_thinking",- "data": json.dumps(second_detail),+ "data": _reasoning_carrier(second_detail),}],},@@ -286,7 +336,9 @@ def test_reasoning_details_preserve_redacted_only_assistant_after_tool()body = open_router_provider._build_request_body(- request, reasoning=reasoning_for(request)+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,)assistants = [@@ -319,14 +371,31 @@ async def test_stream_maps_reasoning_content_and_details(open_router_provider):return_value=stream,):events = await collect_anthropic(- open_router_provider.stream_response(make_request())+ open_router_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))event_text = "".join(events)parsed = parse_sse_text(event_text)assert thinking_content(parsed) == "plan "- assert "redacted_thinking" in event_text- assert "opaque" in event_text+ redacted_blocks = [+ event.data["content_block"]+ for event in parsed+ if event.event == "content_block_start"+ and event.data.get("content_block", {}).get("type") == "redacted_thinking"+ ]+ assert len(redacted_blocks) == 1+ artifacts = decode_replay_envelope(+ redacted_blocks[0]["data"],+ attachment=ReplayAttachment.REASONING,+ )+ assert artifacts is not None+ assert len(artifacts) == 1+ assert artifacts[0].kind is ReplayArtifactKind.REASONING_DETAILS+ assert isinstance(artifacts[0].payload, str)+ assert json.loads(artifacts[0].payload) == redacted+ assert artifacts[0].scope is not Noneassert text_content(parsed) == "done"assert stream.closeddiff --git a/tests/providers/test_openai_chat_output_cap.py b/tests/providers/test_openai_chat_output_cap.pyindex 16032f3e..eb9aa2e6 100644--- a/tests/providers/test_openai_chat_output_cap.py+++ b/tests/providers/test_openai_chat_output_cap.py@@ -16,7 +16,7 @@ from free_claude_code.providers.openai_chat.output_cap import (clamp_output_tokens,parse_output_token_cap,)-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -241,11 +241,20 @@ def groq_provider():@pytest.mark.asyncioasync def test_create_stream_clamps_and_learns_on_cap_rejection(groq_provider):body = groq_provider._build_request_body(- make_messages_request(- "llama-3.3-70b-versatile",- max_tokens=64000,- thinking={"enabled": False},- )+ canonical_request(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=64000,+ thinking={"enabled": False},+ )+ ),+ provider_model=(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=64000,+ thinking={"enabled": False},+ )+ ).model,)assert body["max_completion_tokens"] == 64000model = body["model"]@@ -281,11 +290,20 @@ async def test_create_stream_clamps_and_learns_on_cap_rejection(groq_provider):@pytest.mark.asyncioasync def test_learned_cap_clamps_next_request_without_a_400(groq_provider):body = groq_provider._build_request_body(- make_messages_request(- "llama-3.3-70b-versatile",- max_tokens=64000,- thinking={"enabled": False},- )+ canonical_request(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=64000,+ thinking={"enabled": False},+ )+ ),+ provider_model=(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=64000,+ thinking={"enabled": False},+ )+ ).model,)model = body["model"]groq_provider._model_output_caps[model] = 40960@@ -307,11 +325,20 @@ async def test_learned_cap_clamps_next_request_without_a_400(groq_provider):@pytest.mark.asyncioasync def test_unrelated_400_is_not_clamped_and_propagates(groq_provider):body = groq_provider._build_request_body(- make_messages_request(- "llama-3.3-70b-versatile",- max_tokens=100,- thinking={"enabled": False},- )+ canonical_request(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=100,+ thinking={"enabled": False},+ )+ ),+ provider_model=(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=100,+ thinking={"enabled": False},+ )+ ).model,)create = AsyncMock(side_effect=_BadRequest("messages: invalid role 'wizard'"))@@ -332,11 +359,20 @@ async def test_unrelated_400_is_not_clamped_and_propagates(groq_provider):@pytest.mark.asyncioasync def test_mixed_field_400_does_not_retry_or_poison_learned_cap(groq_provider):body = groq_provider._build_request_body(- make_messages_request(- "llama-3.3-70b-versatile",- max_tokens=64000,- thinking={"enabled": False},- )+ canonical_request(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=64000,+ thinking={"enabled": False},+ )+ ),+ provider_model=(+ make_messages_request(+ "llama-3.3-70b-versatile",+ max_tokens=64000,+ thinking={"enabled": False},+ )+ ).model,)error_body = {"param": "temperature",diff --git a/tests/providers/test_openai_chat_tool_names.py b/tests/providers/test_openai_chat_tool_names.pyindex 5c4956fc..3f55e0d0 100644--- a/tests/providers/test_openai_chat_tool_names.py+++ b/tests/providers/test_openai_chat_tool_names.py@@ -1,13 +1,15 @@from copy import deepcopyfrom typing import Any-from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.providers.openai_chat.request_codec import ReasoningReplayModefrom free_claude_code.providers.openai_chat.request_policy import (OpenAIChatRequestPolicy,build_openai_chat_request_body,)+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec+from tests.providers.request_factory import canonical_request_POLICY = OpenAIChatRequestPolicy(provider_name="TEST",@@ -67,10 +69,14 @@ def _request(name: str, *, continued: bool = False) -> MessagesRequest:def _body(request: MessagesRequest, *, postprocessors=()) -> dict[str, Any]:+ canonical = canonical_request(request)return build_openai_chat_request_body(- request,+ canonical,+ provider_model=canonical.model,reasoning=ReasoningPolicy.provider_default(),policy=_POLICY,+ tool_names=OpenAIToolNameCodec.from_request(canonical),+ replay_scope=None,postprocessors=postprocessors,)@@ -97,13 +103,13 @@ def test_chat_request_uses_one_alias_in_definition_choice_and_history() -> None:assistant = next(message for message in messages if message["role"] == "assistant")assert assistant["tool_calls"][0]["function"] == {"name": alias,- "arguments": '{"value": "x"}',+ "arguments": '{"value":"x"}',}assert assistant["tool_calls"][0]["id"] == "call_1"assert request.model_dump() == snapshot-def test_chat_name_encoding_runs_after_provider_postprocessors() -> None:+def test_provider_postprocessors_observe_final_upstream_tool_names() -> None:original = "mcp__postprocessor_order__" + "x" * 80request = _request(original)observed: list[str] = []@@ -113,8 +119,9 @@ def test_chat_name_encoding_runs_after_provider_postprocessors() -> None:body = _body(request, postprocessors=(observe_names,))- assert observed == [original]- assert body["tools"][0]["function"]["name"] != original+ alias = body["tools"][0]["function"]["name"]+ assert alias != original+ assert observed == [alias]def test_chat_aliases_remain_stable_for_append_only_requests() -> None:@@ -140,11 +147,21 @@ def test_chat_encoding_does_not_rewrite_unrelated_name_fields() -> None:)snapshot = deepcopy(request.extra_body)+ canonical = canonical_request(request)body = build_openai_chat_request_body(- request,+ canonical,+ provider_model=canonical.model,reasoning=ReasoningPolicy.provider_default(),policy=policy,+ tool_names=OpenAIToolNameCodec.from_request(canonical),+ replay_scope=None,)assert body["extra_body"] == snapshot- assert body["tools"][0]["function"]["name"] != original+ tools = body["tools"]+ assert isinstance(tools, list)+ tool = tools[0]+ assert isinstance(tool, dict)+ function = tool["function"]+ assert isinstance(function, dict)+ assert function["name"] != originaldiff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.pyindex 1218ec86..96b9a983 100644--- a/tests/providers/test_openai_chat_usage.py+++ b/tests/providers/test_openai_chat_usage.py@@ -8,15 +8,15 @@ import openaiimport pytestfrom httpx2 import Request, Response-from free_claude_code.core.anthropic import ReasoningReplayMode-from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.inference import InferenceRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderOperationKindfrom free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatProvider,OpenAIChatRequestPolicy,+ ReasoningReplayMode,)from free_claude_code.providers.openai_chat.reasoning import NO_REASONINGfrom free_claude_code.providers.openai_chat.usage import (@@ -26,7 +26,7 @@ from free_claude_code.providers.openai_chat.usage import (usage_int,)from tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -54,11 +54,12 @@ class _UsageTestProvider(OpenAIChatProvider):def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict:- return {"model": request.model, "messages": [{"role": "user", "content": "x"}]}+ return {"model": provider_model, "messages": [{"role": "user", "content": "x"}]}def _bad_request(message: str, body: object | None = None) -> openai.BadRequestError:@@ -184,7 +185,11 @@ async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokenswith patch.object(provider._client.chat.completions, "create", create):events = await collect_anthropic(- provider.stream_response(request, input_tokens=7)+ provider.stream_response(+ canonical_request(request),+ input_tokens=7,+ provider_model=(request).model,+ ))create.assert_awaited_once()@@ -220,8 +225,9 @@ async def test_openai_chat_stream_keeps_response_model_separate_from_upstream_mowith patch.object(provider._client.chat.completions, "create", create):events = await collect_anthropic(provider.stream_response(- request,+ canonical_request(request),response_model="anthropic/test/upstream/model",+ provider_model=(request).model,))diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.pyindex b5a6db7b..58e7d50a 100644--- a/tests/providers/test_openai_codex_provider.py+++ b/tests/providers/test_openai_codex_provider.py@@ -7,8 +7,8 @@ from unittest.mock import patchimport httpximport pytest-from free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.core.anthropic import AnthropicEventPresenter+from free_claude_code.core.anthropic.ingress import AnthropicIngressErrorfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import (assert_anthropic_stream_contract,@@ -27,6 +27,7 @@ from free_claude_code.providers.openai_codex.auth import ()from free_claude_code.providers.openai_codex.provider import OpenAICodexProviderfrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import make_provider_config@@ -206,11 +207,12 @@ async def test_provider_uses_subscription_headers_and_visible_model_catalog() ->infos = await provider.list_model_infos()body = await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),input_tokens=3,request_id="req_test",response_model="claude-opus-4",reasoning=ReasoningPolicy.provider_default(),+ provider_model=(_request()).model,))@@ -301,11 +303,23 @@ 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_response(+ canonical_request(_request()),+ response_model="claude-opus-4",+ provider_model=(_request()).model,+ )+ ),timeout=1,)second = await asyncio.wait_for(- _collect(provider.stream_response(_request(), response_model="claude-opus-4")),+ _collect(+ provider.stream_response(+ canonical_request(_request()),+ response_model="claude-opus-4",+ provider_model=(_request()).model,+ )+ ),timeout=1,)@@ -340,9 +354,10 @@ async def test_generation_close_failure_preserves_provider_failure() -> None:with pytest.raises(ExecutionFailure) as exc_info:await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_close_failure",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -377,15 +392,18 @@ 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_stream(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )assert requests == []body = await _collect(provider.stream_response(- request,+ canonical_request(request),request_id="req_client_controls",response_model="claude-opus-4",reasoning=reasoning,+ provider_model=(request).model,))@@ -404,7 +422,6 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> Nawait client.aclose()@pytest.mark.parametrize(("field", "value", "error_path"),[@@ -427,35 +444,19 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> N),],)-async def test_provider_preflight_rejects_unrepresentable_client_controls(+def test_ingress_rejects_unrepresentable_client_controls(field: str,value: object,error_path: str,) -> None:- requests: list[httpx.Request] = []-- def handler(request: httpx.Request) -> httpx.Response:- requests.append(request)- return httpx.Response(500, 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- )payload = {"model": "gpt-test","messages": [{"role": "user", "content": "hello"}],field: value,}- with pytest.raises(InvalidRequestError, match=error_path):- provider.preflight_stream(MessagesRequest.model_validate(payload))-- assert requests == []- await client.aclose()+ with pytest.raises(AnthropicIngressError, match=error_path):+ canonical_request(MessagesRequest.model_validate(payload))@pytest.mark.asyncio@@ -533,7 +534,11 @@ 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_response(+ canonical_request(request), provider_model=(request).model+ )+ )payload = payloads[0]alias = payload["tools"][0]["name"]@@ -589,9 +594,10 @@ async def test_early_truncated_attempt_is_retried_without_duplicate_output() ->body = await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_retry",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -633,9 +639,10 @@ async def test_pre_stream_retry_discards_held_message_start() -> None:body = await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_pre_stream",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -678,9 +685,10 @@ async def test_non_streaming_success_is_retried_then_reports_bounded_body() -> Nwith pytest.raises(ExecutionFailure) as exc_info:await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_non_stream",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -733,9 +741,10 @@ async def test_truncated_attempt_after_commit_is_not_retried_or_duplicated() ->with pytest.raises(ExecutionFailure):async for event in provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_committed",response_model="claude-opus-4",+ provider_model=(_request()).model,):chunks.extend(presenter.present(event))@@ -779,9 +788,10 @@ async def test_unauthorized_response_forces_one_auth_refresh() -> None:body = await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_auth",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -893,9 +903,10 @@ 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(- _request(),+ canonical_request(_request()),request_id="req_auth_transient",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -929,9 +940,10 @@ async def test_second_unauthorized_response_is_terminal_without_refresh_loop() -with pytest.raises(ExecutionFailure) as exc_info:await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_auth_terminal",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -967,9 +979,10 @@ async def test_final_attempt_unauthorized_preserves_the_provider_401() -> None:with pytest.raises(ExecutionFailure) as exc_info:await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_final_401",response_model="claude-opus-4",+ provider_model=(_request()).model,))@@ -1019,9 +1032,10 @@ async def test_stream_failure_redacts_credentials_from_customer_diagnostic() ->with pytest.raises(ExecutionFailure) as exc_info:await _collect(provider.stream_response(- _request(),+ canonical_request(_request()),request_id="req_redaction",response_model="claude-opus-4",+ provider_model=(_request()).model,))diff --git a/tests/providers/test_openai_compat_5xx_retry.py b/tests/providers/test_openai_compat_5xx_retry.pyindex 7db937d7..0ce6267f 100644--- a/tests/providers/test_openai_compat_5xx_retry.py+++ b/tests/providers/test_openai_compat_5xx_retry.py@@ -11,7 +11,7 @@ from free_claude_code.config.nim import NimSettingsfrom free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -73,7 +73,9 @@ 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 = await collect_anthropic(provider.stream_response(req))+ events = await collect_anthropic(+ provider.stream_response(canonical_request(req), provider_model=(req).model)+ )assert mock_create.await_count == 2assert any("Hi" in e for e in events)@@ -117,7 +119,9 @@ 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 = await collect_anthropic(provider.stream_response(req))+ events = await collect_anthropic(+ provider.stream_response(canonical_request(req), provider_model=(req).model)+ )assert mock_create.await_count == 2assert any("Recovered" in e for e in events)@@ -152,7 +156,13 @@ 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,):- await collect_anthropic(provider.stream_response(req, request_id="req_conn"))+ await collect_anthropic(+ provider.stream_response(+ canonical_request(req),+ request_id="req_conn",+ provider_model=(req).model,+ )+ )assert mock_create.await_count == 5error_traces = [@@ -205,7 +215,11 @@ 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:- await collect_anthropic(provider.stream_response(req))+ await collect_anthropic(+ provider.stream_response(+ canonical_request(req), provider_model=(req).model+ )+ )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 364b1bba..19346514 100644--- a/tests/providers/test_openai_responses_transport.py+++ b/tests/providers/test_openai_responses_transport.py@@ -20,6 +20,7 @@ from free_claude_code.core.anthropic.stream_contracts import (from free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.openai_responses import OpenAIResponsesTransportfrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import REASONING_ON, immediate_admission@@ -135,11 +136,12 @@ async def _collect() -> list[str]:return await collect_anthropic(transport.stream_response(- request or _request(),+ canonical_request(request or _request()),input_tokens=11,request_id="req_responses",response_model="public-model",reasoning=REASONING_ON,+ provider_model=(request or _request()).model,))@@ -371,11 +373,12 @@ async def test_post_commit_truncation_is_not_replayed() -> None:try:with pytest.raises(ExecutionFailure):async for event in _transport(client).stream_response(- _request(),+ canonical_request(_request()),input_tokens=1,request_id="req_committed",response_model="public-model",reasoning=REASONING_ON,+ provider_model=(_request()).model,):chunks.extend(presenter.present(event))finally:@@ -429,6 +432,10 @@ 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_stream(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )finally:await client.close()diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.pyindex 7d3a9355..bcc2b662 100644--- a/tests/providers/test_opencode.py+++ b/tests/providers/test_opencode.py@@ -31,6 +31,7 @@ from free_claude_code.providers.opencode.catalog import (parse_open_code_catalog,)from tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (capture_openai_chat_wire_body,immediate_admission,@@ -234,9 +235,10 @@ async def _collect(provider: OpenCodeProvider, model: str, **overrides: object)return "".join(await collect_anthropic(provider.stream_response(- _request(model, **overrides),+ canonical_request(_request(model, **overrides)),input_tokens=2,request_id="req_opencode",+ provider_model=(_request(model, **overrides)).model,)))@@ -582,10 +584,18 @@ 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_stream(+ canonical_request(_request("missing")),+ provider_model=(_request("missing")).model,+ )with pytest.raises(InvalidRequestError, match="stop_sequences"):provider.preflight_stream(- _request("responses-selector", stop_sequences=["done"])+ canonical_request(+ _request("responses-selector", stop_sequences=["done"])+ ),+ provider_model=(+ _request("responses-selector", stop_sequences=["done"])+ ).model,)finally:await provider.cleanup()@@ -660,7 +670,11 @@ def test_build_request_body_replays_tool_reasoning_natively(})- body = provider._build_request_body(request, reasoning=reasoning_for(request))+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assistant = body["messages"][0]assert assistant["content"] == ""@@ -717,7 +731,11 @@ async def test_tool_only_history_sends_empty_reasoning_content_on_wire(})- body = provider._build_request_body(request, reasoning=reasoning_for(request))+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )wire = await capture_openai_chat_wire_body(body)assistant = wire["messages"][0]diff --git a/tests/providers/test_poolside.py b/tests/providers/test_poolside.pyindex 4c81fa4c..b03d074b 100644--- a/tests/providers/test_poolside.py+++ b/tests/providers/test_poolside.py@@ -14,6 +14,7 @@ from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.json_types import JsonObject, JsonValuefrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -60,8 +61,9 @@ def test_encodes_documented_chat_template_thinking_control(enabled: bool,) -> None:body = poolside_provider._build_request_body(- _request(extra_body={"top_k": 20}),+ canonical_request(_request(extra_body={"top_k": 20})),reasoning=reasoning,+ provider_model=(_request(extra_body={"top_k": 20})).model,)assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -75,8 +77,9 @@ def test_omits_thinking_control_for_poolside_default(poolside_provider: OpenAIChatProvider,) -> None:body = poolside_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(_request()).model,)assert "extra_body" not in body@@ -93,7 +96,11 @@ def test_rejects_caller_reasoning_override(request = _request(extra_body={field: "caller-owned"})with pytest.raises(InvalidRequestError, match="must not override reasoning"):- poolside_provider._build_request_body(request, reasoning=REASONING_ON)+ poolside_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )def test_replays_reasoning_content_with_tool_history(@@ -129,8 +136,9 @@ def test_replays_reasoning_content_with_tool_history()body = poolside_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {@@ -143,7 +151,7 @@ def test_replays_reasoning_content_with_tool_history("type": "function","function": {"name": "read_file",- "arguments": '{"path": "example.py"}',+ "arguments": '{"path":"example.py"}',},}],@@ -166,8 +174,9 @@ async def test_thinking_control_reaches_wire_as_top_level_extension(poolside_provider: OpenAIChatProvider,) -> None:body = poolside_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=REASONING_OFF,+ provider_model=(_request()).model,)wire = await capture_openai_chat_wire_body(body)diff --git a/tests/providers/test_preflight_contract.py b/tests/providers/test_preflight_contract.pyindex 2dfe97dc..fb314678 100644--- a/tests/providers/test_preflight_contract.py+++ b/tests/providers/test_preflight_contract.py@@ -6,24 +6,30 @@ import pytestfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic.models import Message, MessagesRequest-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ InferenceStreamLedger,+)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.base import BaseProviderfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import make_provider_configclass RecordingOpenAIProvider(OpenAIChatProvider):def __init__(self) -> None:- self.build_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []+ self.build_calls: list[tuple[InferenceRequest, str, ReasoningPolicy]] = []def _build_request_body(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> dict:- self.build_calls.append((request, reasoning))+ self.build_calls.append((request, provider_model, reasoning))return {}@@ -36,9 +42,10 @@ class ProviderWithoutPreflight(BaseProvider):async def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,@@ -65,6 +72,12 @@ 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_stream(+ canonical_request(request),+ reasoning=ReasoningPolicy.off(),+ provider_model=(request).model,+ )- assert provider.build_calls == [(request, ReasoningPolicy.off())]+ assert provider.build_calls == [+ (canonical_request(request), request.model, ReasoningPolicy.off())+ ]diff --git a/tests/providers/test_provider_transport_logging.py b/tests/providers/test_provider_transport_logging.pyindex 047f3ab2..775e86ed 100644--- a/tests/providers/test_provider_transport_logging.py+++ b/tests/providers/test_provider_transport_logging.py@@ -10,7 +10,7 @@ import pytestfrom free_claude_code.config.nim import NimSettingsfrom free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.nvidia_nim import NvidiaNimProvider-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -42,7 +42,13 @@ 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_response(+ canonical_request(make_messages_request()),+ provider_model=(make_messages_request()).model,+ )+ ]messages = " | ".join(record.getMessage() for record in caplog.records)assert "SECRET_OPENAI_COMPAT" not in messages@@ -66,7 +72,13 @@ 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_response(+ canonical_request(make_messages_request()),+ provider_model=(make_messages_request()).model,+ )+ ]messages = " | ".join(record.getMessage() for record in caplog.records)assert "SECRET_CAUSE_DETAIL" not in messages@@ -89,7 +101,13 @@ 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_response(+ canonical_request(make_messages_request()),+ provider_model=(make_messages_request()).model,+ )+ ]messages = " | ".join(record.getMessage() for record in caplog.records)assert "api_key=<redacted>" in messagesdiff --git a/tests/providers/test_qwencloud.py b/tests/providers/test_qwencloud.pyindex e6852b37..c8f7ab7c 100644--- a/tests/providers/test_qwencloud.py+++ b/tests/providers/test_qwencloud.py@@ -13,6 +13,7 @@ from free_claude_code.config.provider_catalog import QWENCLOUD_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -82,8 +83,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images()body = qwencloud_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "qwen3.7-plus"@@ -111,7 +113,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(})- body = qwencloud_provider._build_request_body(request, reasoning=reasoning)+ body = qwencloud_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )extra_body = body.get("extra_body", {})for field in (@@ -145,8 +149,9 @@ def test_build_request_body_replays_prior_reasoning_content()body = qwencloud_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {diff --git a/tests/providers/test_qwencloud_coding.py b/tests/providers/test_qwencloud_coding.pyindex 167e358f..db9810b8 100644--- a/tests/providers/test_qwencloud_coding.py+++ b/tests/providers/test_qwencloud_coding.py@@ -11,6 +11,7 @@ from free_claude_code.config.provider_catalog import QWENCLOUD_CODING_DEFAULT_BAfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -80,8 +81,9 @@ def test_build_request_body_preserves_tools_and_images_without_inventing_a_cap()body = qwencloud_coding_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "qwen3.7-plus"@@ -110,8 +112,9 @@ def test_build_request_body_preserves_explicit_client_cap()body = qwencloud_coding_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["max_tokens"] == 321@@ -136,7 +139,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(})- body = qwencloud_coding_provider._build_request_body(request, reasoning=reasoning)+ body = qwencloud_coding_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )extra_body = body.get("extra_body", {})for field in (@@ -173,8 +178,9 @@ def test_build_request_body_replays_prior_reasoning_content()body = qwencloud_coding_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {diff --git a/tests/providers/test_sambanova.py b/tests/providers/test_sambanova.pyindex 494170e8..6d1d2ad5 100644--- a/tests/providers/test_sambanova.py+++ b/tests/providers/test_sambanova.py@@ -8,7 +8,7 @@ import pytestfrom free_claude_code.config.provider_catalog import SAMBANOVA_DEFAULT_BASEfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -67,7 +67,9 @@ def test_init_strips_trailing_slash(sambanova_config):def test_build_request_body_basic(sambanova_provider):"""Basic request body conversion attaches system message and keeps max_tokens."""- body = sambanova_provider._build_request_body(make_request())+ body = sambanova_provider._build_request_body(+ canonical_request(make_request()), provider_model=(make_request()).model+ )assert body["model"] == "Meta-Llama-3.3-70B-Instruct"assert body["messages"][0]["role"] == "system"@@ -78,7 +80,9 @@ def test_build_request_body_basic(sambanova_provider):def test_build_request_body_preserves_caller_extra_body(sambanova_provider):req = make_request(extra_body={"metadata": {"user": "u1"}})- body = sambanova_provider._build_request_body(req)+ body = sambanova_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )eb = body.get("extra_body")assert isinstance(eb, dict)@@ -99,8 +103,9 @@ def test_build_request_body_uses_only_documented_reasoning_efforts(sambanova_provider, reasoning, expected):body = sambanova_provider._build_request_body(- make_request(),+ canonical_request(make_request()),reasoning=reasoning,+ provider_model=(make_request()).model,)assert body.get("reasoning_effort") == expected@@ -131,7 +136,9 @@ async def test_stream_response_text(sambanova_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- sambanova_provider.stream_response(make_request())+ sambanova_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(@@ -166,7 +173,9 @@ async def test_stream_response_tool_call(sambanova_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- sambanova_provider.stream_response(make_request())+ sambanova_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(@@ -202,7 +211,9 @@ async def test_stream_response_reasoning_content(sambanova_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- sambanova_provider.stream_response(make_request())+ sambanova_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(diff --git a/tests/providers/test_siliconflow.py b/tests/providers/test_siliconflow.pyindex 7ae76f90..17141566 100644--- a/tests/providers/test_siliconflow.py+++ b/tests/providers/test_siliconflow.py@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -94,8 +95,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images()body = siliconflow_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(request).model,)assert body["model"] == _MODEL@@ -126,7 +128,11 @@ def test_build_request_body_omits_model_specific_thinking_controls(siliconflow_provider: OpenAIChatProvider,reasoning: ReasoningPolicy,) -> None:- body = siliconflow_provider._build_request_body(_request(), reasoning=reasoning)+ body = siliconflow_provider._build_request_body(+ canonical_request(_request()),+ reasoning=reasoning,+ provider_model=(_request()).model,+ )assert "extra_body" not in body@@ -137,8 +143,9 @@ def test_build_request_body_preserves_unrelated_extra_body(request = _request(extra_body={"min_p": 0.05})body = siliconflow_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(request).model,)assert body["extra_body"] == {@@ -154,7 +161,11 @@ def test_build_request_body_rejects_caller_thinking_override(request = _request(extra_body={field: "caller-owned"})with pytest.raises(InvalidRequestError, match="must not override reasoning"):- siliconflow_provider._build_request_body(request, reasoning=REASONING_ON)+ siliconflow_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )def test_build_request_body_replays_reasoning_content_verbatim(@@ -175,8 +186,9 @@ def test_build_request_body_replays_reasoning_content_verbatim()body = siliconflow_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 46c944e3..29c64c98 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -12,18 +12,15 @@ import openaiimport pytestfrom free_claude_code.config.nim import NimSettings-from free_claude_code.core.anthropic import AnthropicEventPresenter, OpenAIToolNameCodec+from free_claude_code.core.anthropic import AnthropicEventPresenterfrom free_claude_code.core.anthropic.stream_contracts import (parse_sse_text,)-from free_claude_code.core.anthropic.streaming import (- make_response_recovery_body,- make_text_recovery_body,-)from free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.core.inference import (InferenceEvent,InferenceStreamLedger,+ ReplayCompatibilityScope,ResponseStarted,)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy@@ -35,14 +32,19 @@ from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.openai_chat.provider import (_OpenAIChatStreamRunner,)+from free_claude_code.providers.openai_chat.recovery import (+ make_response_recovery_body,+ make_text_recovery_body,+)from free_claude_code.providers.openai_chat.tool_calls import (OpenAIToolCallAssembler,OpenAIToolCallCollector,has_generated_output,iter_heuristic_tool_use_events,)+from free_claude_code.providers.openai_compat import OpenAIToolNameCodecfrom free_claude_code.providers.stream_recovery import TruncatedProviderStreamError-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -130,7 +132,8 @@ def _make_provider():def _make_tool_assembler(provider: NvidiaNimProvider) -> OpenAIToolCallAssembler:return OpenAIToolCallAssembler(- record_extra_content=provider._record_tool_call_extra_content+ record_extra_content=provider._record_tool_call_extra_content,+ replay_scope=ReplayCompatibilityScope("test-chat-route"),)@@ -157,12 +160,14 @@ def _make_stream_runner(request=None,request_id: str | None = None,) -> _OpenAIChatStreamRunner:+ effective_request = request or _make_request()return _OpenAIChatStreamRunner(provider,- request=request or _make_request(),+ request=effective_request,+ provider_model=effective_request.model,input_tokens=0,request_id=request_id,- response_model=None,+ response_model=effective_request.model,reasoning=DEFAULT_REASONING_POLICY,)@@ -217,14 +222,21 @@ async def _collect_stream("""Collect all SSE events from a stream."""presenter = AnthropicEventPresenter()output: list[str] = []- async for event in provider.stream_response(request, reasoning=reasoning):+ async for event in provider.stream_response(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ ):output.extend(presenter.present(event))return outputasync 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_response(+ canonical_request(request), **kwargs, provider_model=(request).model+ )+ ]return exc_info.value@@ -234,7 +246,9 @@ async def _collect_stream_and_error(events: list[str] = []presenter = AnthropicEventPresenter()with pytest.raises(ExecutionFailure) as exc_info:- async for event in provider.stream_response(request, **kwargs):+ async for event in provider.stream_response(+ canonical_request(request), **kwargs, provider_model=(request).model+ ):events.extend(presenter.present(event))return events, exc_info.value@@ -1936,7 +1950,7 @@ class TestProcessToolCall:)def test_tool_name_restores_before_nim_argument_alias_lookup(self):- """Generic name decoding composes with original-name NIM arg metadata."""+ """Wire-name argument metadata composes with canonical identity decoding."""provider = _make_provider()original = "mcp__nim_argument_composition__" + "x" * 70request = _make_request(@@ -1967,7 +1981,9 @@ class TestProcessToolCall:sse,tool_names=codec,tool_name_buffers={},- tool_argument_aliases={original: {"_fcc_arg_type": "type"}},+ tool_argument_aliases={+ codec.encode(original): {"_fcc_arg_type": "type"}+ },tool_argument_alias_buffers={},))@@ -2082,7 +2098,7 @@ class TestProcessToolCall:assert buffers == {}def test_buffered_collector_decodes_before_schema_validation(self):- """Recovery validates the original tool identity, not its wire alias."""+ """Recovery validates canonically while preserving its upstream wire name."""original = "mcp__recovery_output__" + "x" * 70request = _make_request(tools=[{"name": original, "input_schema": {"type": "object"}}]@@ -2100,7 +2116,7 @@ class TestProcessToolCall:calls = collector.completed_calls(request, tool_names=codec)assert calls is not None- assert calls[0]["function"]["name"] == original+ assert calls[0]["function"]["name"] == codec.encode(original)def test_heuristic_tool_call_restores_original_name(self):"""Complete heuristic calls share the same outbound name contract."""@@ -2146,9 +2162,10 @@ class TestProcessToolCall:"id": "call_split","function": {"name": None, "arguments": "{}"},}- events1 = list(_make_tool_assembler(provider).process_tool_call(t1, sse))- events2 = list(_make_tool_assembler(provider).process_tool_call(t2, sse))- events3 = list(_make_tool_assembler(provider).process_tool_call(t3, sse))+ assembler = _make_tool_assembler(provider)+ events1 = list(assembler.process_tool_call(t1, sse))+ events2 = list(assembler.process_tool_call(t2, sse))+ events3 = list(assembler.process_tool_call(t3, sse))combined = _wire(events1 + events2 + events3)assert "call_split" in combinedassert "Grep" in combined@@ -2168,8 +2185,9 @@ class TestProcessToolCall:"id": "call_buf","function": {"name": "Read", "arguments": "1}"},}- events1 = list(_make_tool_assembler(provider).process_tool_call(t1, sse))- events2 = list(_make_tool_assembler(provider).process_tool_call(t2, sse))+ assembler = _make_tool_assembler(provider)+ events1 = list(assembler.process_tool_call(t1, sse))+ events2 = list(assembler.process_tool_call(t2, sse))assert events1 == []combined = _wire(events1 + events2)assert "Read" in combined@@ -2219,11 +2237,12 @@ class TestProcessToolCall:"function": {"name": None, "arguments": ' "prompt": "test"}'},}- events1 = list(_make_tool_assembler(provider).process_tool_call(tc1, sse))+ assembler = _make_tool_assembler(provider)+ events1 = list(assembler.process_tool_call(tc1, sse))assert len(events1) > 0assert "false" not in _wire(events1).lower()- events2 = list(_make_tool_assembler(provider).process_tool_call(tc2, sse))+ events2 = list(assembler.process_tool_call(tc2, sse))event_text = _wire(events1 + events2)assert "false" in event_text.lower()@@ -2236,11 +2255,12 @@ class TestProcessToolCall:"id": "call_task2","function": {"name": "Task", "arguments": "not json"},}- events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))+ assembler = _make_tool_assembler(provider)+ events = list(assembler.process_tool_call(tc, sse))assert len(events) > 0with caplog.at_level("WARNING"):- flushed = list(_make_tool_assembler(provider).flush_task_arg_buffers(sse))+ flushed = list(assembler.flush_task_arg_buffers(sse))assert len(flushed) > 0assert "{}" in _wire(events + flushed)assert any("Task args invalid JSON" in r.message for r in caplog.records)@@ -2385,9 +2405,10 @@ class TestStreamChunkEdgeCases:"function": {"name": None, "arguments": " never valid }"},}- events1 = list(_make_tool_assembler(provider).process_tool_call(tc1, sse))- events2 = list(_make_tool_assembler(provider).process_tool_call(tc2, sse))- flushed = list(_make_tool_assembler(provider).flush_task_arg_buffers(sse))+ assembler = _make_tool_assembler(provider)+ events1 = list(assembler.process_tool_call(tc1, sse))+ events2 = list(assembler.process_tool_call(tc2, sse))+ flushed = list(assembler.flush_task_arg_buffers(sse))event_text = _wire(events1 + events2 + flushed)assert "tool_use" in event_textdiff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.pyindex bb49fbce..1c93581b 100644--- a/tests/providers/test_subagent_interception.py+++ b/tests/providers/test_subagent_interception.py@@ -5,7 +5,10 @@ import pytestfrom free_claude_code.config.nim import NimSettingsfrom free_claude_code.config.provider_catalog import NVIDIA_NIM_DEFAULT_BASE-from free_claude_code.core.inference import InferenceBlockLedger+from free_claude_code.core.inference import (+ InferenceBlockLedger,+ ReplayCompatibilityScope,+)from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.openai_chat.tool_calls import (OpenAIToolCallAssembler,@@ -50,7 +53,8 @@ async def test_task_tool_interception():}tool_calls = OpenAIToolCallAssembler(- record_extra_content=provider._record_tool_call_extra_content+ record_extra_content=provider._record_tool_call_extra_content,+ replay_scope=ReplayCompatibilityScope("test-chat-route"),)# Call the assembler (consume generator to trigger side effects)diff --git a/tests/providers/test_together.py b/tests/providers/test_together.pyindex e5012b76..05be9cfc 100644--- a/tests/providers/test_together.py+++ b/tests/providers/test_together.py@@ -14,6 +14,7 @@ from free_claude_code.config.provider_catalog import TOGETHER_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -83,8 +84,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images()body = together_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "zai-org/GLM-5.2"@@ -112,7 +114,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(})- body = together_provider._build_request_body(request, reasoning=reasoning)+ body = together_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )extra_body = body.get("extra_body", {})for field in ("reasoning", "reasoning_effort", "chat_template_kwargs"):@@ -141,8 +145,9 @@ def test_build_request_body_replays_documented_reasoning_field()body = together_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {diff --git a/tests/providers/test_vercel.py b/tests/providers/test_vercel.pyindex 6f6ffd27..ec2eba08 100644--- a/tests/providers/test_vercel.py+++ b/tests/providers/test_vercel.py@@ -7,7 +7,7 @@ import pytestfrom free_claude_code.config.provider_catalog import VERCEL_AI_GATEWAY_DEFAULT_BASEfrom tests.inference_support import collect_anthropic-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -80,7 +80,9 @@ def test_build_request_body_keeps_max_tokens(vercel_provider):"max_tokens": 42,}- body = vercel_provider._build_request_body(make_request())+ body = vercel_provider._build_request_body(+ canonical_request(make_request()), provider_model=(make_request()).model+ )assert body["messages"][0].get("name") == "alice"assert body["max_tokens"] == 42@@ -90,7 +92,9 @@ def test_build_request_body_keeps_max_tokens(vercel_provider):def test_build_request_body_preserves_caller_extra_body(vercel_provider):req = make_request(extra_body={"providerOptions": {"openai": {"reasoning": "low"}}})- body = vercel_provider._build_request_body(req)+ body = vercel_provider._build_request_body(+ canonical_request(req), provider_model=(req).model+ )assert body["extra_body"] == {"providerOptions": {"openai": {"reasoning": "low"}}}@@ -119,7 +123,9 @@ async def test_stream_response_text(vercel_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- vercel_provider.stream_response(make_request())+ vercel_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(@@ -151,7 +157,9 @@ async def test_stream_response_reasoning_content(vercel_provider):mock_create.return_value = mock_stream()events = await collect_anthropic(- vercel_provider.stream_response(make_request())+ vercel_provider.stream_response(+ canonical_request(make_request()), provider_model=(make_request()).model+ ))assert any(diff --git a/tests/providers/test_vertex.py b/tests/providers/test_vertex.pyindex 60a30d07..7b2ac29b 100644--- a/tests/providers/test_vertex.py+++ b/tests/providers/test_vertex.py@@ -26,7 +26,7 @@ from free_claude_code.providers.vertex.endpoint import (vertex_service_endpoint,)from free_claude_code.providers.vertex.models import extract_vertex_model_page-from tests.providers.request_factory import make_messages_request+from tests.providers.request_factory import canonical_request, make_messages_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -247,7 +247,11 @@ def test_vertex_request_uses_google_thinking_budget_without_named_effort() -> Nothinking={"type": "enabled", "budget_tokens": 2048},)- body = provider._build_request_body(request, reasoning=reasoning_for(request))+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["model"] == "google/gemini-3.5-flash"assert "reasoning_effort" not in body@@ -264,7 +268,11 @@ def test_vertex_request_maps_reasoning_off_to_zero_budget() -> None:thinking={"type": "disabled"},)- body = provider._build_request_body(request, reasoning=reasoning_for(request))+ body = provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["extra_body"]["extra_body"]["google"]["thinking_config"] == {"thinking_budget": 0,@@ -302,8 +310,9 @@ def test_vertex_reasoning_has_one_google_wire_owner(provider = _provider()body = provider._build_request_body(- make_messages_request("google/gemini", thinking=None),+ canonical_request(make_messages_request("google/gemini", thinking=None)),reasoning=reasoning,+ provider_model=(make_messages_request("google/gemini", thinking=None)).model,)wire = _simulate_openai_sdk_wire_json(body)@@ -329,8 +338,9 @@ def test_vertex_preserves_caller_thinking_config_only_for_provider_default() ->)body = provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(request).model,)wire = _simulate_openai_sdk_wire_json(body)@@ -352,8 +362,9 @@ def test_vertex_rejects_caller_thinking_config_with_fcc_reasoning_control() -> Nwith pytest.raises(InvalidRequestError, match="thinking_config"):provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ provider_model=(request).model,)diff --git a/tests/providers/test_wafer.py b/tests/providers/test_wafer.pyindex afe7fd98..b0eb7ae8 100644--- a/tests/providers/test_wafer.py+++ b/tests/providers/test_wafer.py@@ -11,6 +11,7 @@ from free_claude_code.core.anthropic.models import Message, MessagesRequest, Toofrom free_claude_code.providers.openai_chat import (OpenAIChatProvider,)+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -66,7 +67,11 @@ def test_build_request_body_openai_shape_and_defaults(wafer_provider):})- body = wafer_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = wafer_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["model"] == "DeepSeek-V4-Pro"assert body["messages"][0] == {"role": "user", "content": "Hello"}@@ -83,7 +88,11 @@ def test_build_request_body_honors_effective_no_thinking(wafer_provider):})- body = wafer_provider._build_request_body(request, reasoning=REASONING_OFF)+ body = wafer_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["reasoning_effort"] == "none"@@ -97,7 +106,11 @@ def test_build_request_body_preserves_request_disabled_thinking(wafer_provider):})- body = wafer_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = wafer_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["reasoning_effort"] == "none"@@ -112,7 +125,11 @@ def test_build_request_body_uses_resolved_policy_without_inspecting_model(})- body = wafer_provider._build_request_body(request, reasoning=REASONING_OFF)+ body = wafer_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_OFF,+ provider_model=(request).model,+ )assert body["reasoning_effort"] == "none"diff --git a/tests/providers/test_wandb.py b/tests/providers/test_wandb.pyindex 33a5b26c..fe7fdaab 100644--- a/tests/providers/test_wandb.py+++ b/tests/providers/test_wandb.py@@ -15,6 +15,7 @@ from free_claude_code.config.provider_catalog import WANDB_INFERENCE_DEFAULT_BASfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -64,7 +65,11 @@ def test_build_request_body_encodes_documented_thinking_control(reasoning: ReasoningPolicy,enabled: bool,) -> None:- body = wandb_provider._build_request_body(_request(), reasoning=reasoning)+ body = wandb_provider._build_request_body(+ canonical_request(_request()),+ reasoning=reasoning,+ provider_model=(_request()).model,+ )assert body["extra_body"] == {"chat_template_kwargs": {"enable_thinking": enabled}}@@ -73,8 +78,9 @@ def test_build_request_body_uses_provider_defaults_when_reasoning_is_inherited(wandb_provider: OpenAIChatProvider,) -> None:body = wandb_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(_request()).model,)assert "extra_body" not in body@@ -113,8 +119,9 @@ def test_build_request_body_drops_undocumented_reasoning_replay_but_keeps_tools()body = wandb_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {@@ -126,7 +133,7 @@ def test_build_request_body_drops_undocumented_reasoning_replay_but_keeps_tools("type": "function","function": {"name": "read_file",- "arguments": '{"path": "example.py"}',+ "arguments": '{"path":"example.py"}',},}],@@ -155,14 +162,22 @@ def test_build_request_body_rejects_caller_reasoning_override(request = _request(extra_body={field: "caller-owned"})with pytest.raises(InvalidRequestError, match="must not override reasoning"):- wandb_provider._build_request_body(request, reasoning=REASONING_ON)+ wandb_provider._build_request_body(+ canonical_request(request),+ reasoning=REASONING_ON,+ provider_model=(request).model,+ )@pytest.mark.asyncioasync def test_wire_body_uses_current_output_limit_and_thinking_fields(wandb_provider: OpenAIChatProvider,) -> None:- body = wandb_provider._build_request_body(_request(), reasoning=REASONING_ON)+ body = wandb_provider._build_request_body(+ canonical_request(_request()),+ reasoning=REASONING_ON,+ provider_model=(_request()).model,+ )wire_body = await capture_openai_chat_wire_body(body)diff --git a/tests/providers/test_xai.py b/tests/providers/test_xai.pyindex fe3caabd..b59a3af9 100644--- a/tests/providers/test_xai.py+++ b/tests/providers/test_xai.py@@ -14,6 +14,7 @@ from free_claude_code.config.provider_catalog import XAI_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -81,8 +82,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images()body = xai_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "grok-4.5"@@ -109,7 +111,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(})- body = xai_provider._build_request_body(request, reasoning=reasoning)+ body = xai_provider._build_request_body(+ canonical_request(request), reasoning=reasoning, provider_model=(request).model+ )assert "reasoning_effort" not in bodyassert "reasoning" not in body.get("extra_body", {})@@ -136,8 +140,9 @@ def test_build_request_body_replays_prior_reasoning_content()body = xai_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["messages"][1] == {diff --git a/tests/providers/test_zai.py b/tests/providers/test_zai.pyindex 8cc4d0ea..8b0c5975 100644--- a/tests/providers/test_zai.py+++ b/tests/providers/test_zai.py@@ -12,6 +12,7 @@ from free_claude_code.config.provider_catalog import ()from free_claude_code.core.anthropic.models import Message, MessagesRequestfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -60,7 +61,11 @@ def test_build_request_body_openai_chat(zai_provider):})- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = zai_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["model"] == "glm-5.2"assert body["max_tokens"] == 100@@ -77,7 +82,11 @@ def test_build_request_body_default_max_tokens(zai_provider):messages=[Message(role="user", content="x")],)- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = zai_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS@@ -92,7 +101,11 @@ def test_build_request_body_rejects_caller_extra_body(zai_provider):)with pytest.raises(InvalidRequestError, match=r"Z\.ai Chat Completions"):- zai_provider._build_request_body(request, reasoning=reasoning_for(request))+ zai_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )def test_build_request_body_disables_zai_thinking(zai_provider):@@ -104,7 +117,11 @@ def test_build_request_body_disables_zai_thinking(zai_provider):})- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = zai_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["extra_body"]["thinking"] == {"type": "disabled"}@@ -123,7 +140,11 @@ def test_build_request_body_replays_prior_reasoning_content(zai_provider):})- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))+ body = zai_provider._build_request_body(+ canonical_request(request),+ reasoning=reasoning_for(request),+ provider_model=(request).model,+ )assert body["messages"][0]["reasoning_content"] == "prior"assert "extra_body" not in bodydiff --git a/tests/providers/test_zenmux.py b/tests/providers/test_zenmux.pyindex ccbd42ab..9a686590 100644--- a/tests/providers/test_zenmux.py+++ b/tests/providers/test_zenmux.py@@ -1,6 +1,7 @@"""Tests for the ZenMux OpenAI-chat provider profile."""import json+from collections.abc import Mappingfrom types import SimpleNamespacefrom typing import Anyfrom unittest.mock import AsyncMock, patch@@ -18,10 +19,23 @@ from free_claude_code.core.anthropic.stream_contracts import (text_content,thinking_content,)+from free_claude_code.core.inference import (+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+)+from free_claude_code.core.json_types import JsonValuefrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.core.replay_envelope import (+ decode_replay_envelope,+ encode_replay_envelope,+)from free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from free_claude_code.providers.openai_compat import openai_replay_scopefrom tests.inference_support import collect_anthropic+from tests.providers.request_factory import canonical_requestfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -53,6 +67,24 @@ def _request(**overrides: Any) -> MessagesRequest:return MessagesRequest.model_validate(payload)+def _reasoning_carrier(detail: Mapping[str, JsonValue]) -> str:+ return encode_replay_envelope(+ (+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,+ kind=ReplayArtifactKind.REASONING_DETAILS,+ attachment=ReplayAttachment.REASONING,+ scope=openai_replay_scope(+ "ZENMUX",+ "deepseek/deepseek-v4-flash-free",+ replay_format="chat-completions",+ ),+ payload=detail,+ ),+ )+ )++class AsyncStream:def __init__(self, chunks: list[Any]) -> None:self._chunks = chunks@@ -131,8 +163,9 @@ def test_build_request_body_uses_supported_output_field_tools_and_images()body = zenmux_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assert body["model"] == "deepseek/deepseek-v4-flash-free"@@ -163,8 +196,9 @@ def test_build_request_body_maps_reasoning_effort_to_documented_vocabulary(expected: str,) -> None:body = zenmux_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.on(effort=effort),+ provider_model=(_request()).model,)assert body["extra_body"]["reasoning"] == {"effort": expected}@@ -183,7 +217,11 @@ def test_build_request_body_maps_reasoning_control_and_budget(reasoning: ReasoningPolicy,expected: dict[str, Any],) -> None:- body = zenmux_provider._build_request_body(_request(), reasoning=reasoning)+ body = zenmux_provider._build_request_body(+ canonical_request(_request()),+ reasoning=reasoning,+ provider_model=(_request()).model,+ )assert body["extra_body"]["reasoning"] == expected@@ -192,8 +230,9 @@ def test_build_request_body_leaves_reasoning_to_provider_by_default(zenmux_provider: OpenAIChatProvider,) -> None:body = zenmux_provider._build_request_body(- _request(),+ canonical_request(_request()),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(_request()).model,)assert "reasoning" not in body.get("extra_body", {})@@ -205,8 +244,9 @@ def test_build_request_body_preserves_unrelated_gateway_options(request = _request(extra_body={"provider": {"fallback": "true"}})body = zenmux_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.provider_default(),+ provider_model=(request).model,)assert body["extra_body"] == {"provider": {"fallback": "true"}}@@ -224,8 +264,9 @@ def test_build_request_body_rejects_caller_canonical_override(with pytest.raises(InvalidRequestError, match="must not override canonical"):zenmux_provider._build_request_body(- request,+ canonical_request(request),reasoning=ReasoningPolicy.on(),+ provider_model=(request).model,)@@ -246,7 +287,7 @@ def test_build_request_body_replays_reasoning_and_signed_details_unchanged("role": "assistant","content": [{"type": "thinking", "thinking": "Need a tool."},- {"type": "redacted_thinking", "data": json.dumps(detail)},+ {"type": "redacted_thinking", "data": _reasoning_carrier(detail)},{"type": "tool_use","id": "call_read",@@ -269,8 +310,9 @@ def test_build_request_body_replays_reasoning_and_signed_details_unchanged()body = zenmux_provider._build_request_body(- request,+ canonical_request(request),reasoning=reasoning_for(request),+ provider_model=(request).model,)assistant = next(@@ -334,7 +376,11 @@ async def test_stream_preserves_signed_details_without_duplicating_reasoning(return_value=stream,):event_text = "".join(- await collect_anthropic(zenmux_provider.stream_response(_request()))+ await collect_anthropic(+ zenmux_provider.stream_response(+ canonical_request(_request()), provider_model=(_request()).model+ )+ ))events = parse_sse_text(event_text)@@ -347,7 +393,16 @@ async def test_stream_preserves_signed_details_without_duplicating_reasoning(and event.data.get("content_block", {}).get("type") == "redacted_thinking"]assert len(redacted_blocks) == 1- assert json.loads(redacted_blocks[0]["data"]) == detail+ artifacts = decode_replay_envelope(+ redacted_blocks[0]["data"],+ attachment=ReplayAttachment.REASONING,+ )+ assert artifacts is not None+ assert len(artifacts) == 1+ assert artifacts[0].kind is ReplayArtifactKind.REASONING_DETAILS+ assert isinstance(artifacts[0].payload, str)+ assert json.loads(artifacts[0].payload) == detail+ assert artifacts[0].scope is not Noneassert stream.closeddiff --git a/tests/runtime/test_application_runtime.py b/tests/runtime/test_application_runtime.pyindex e493e50e..910f7758 100644--- a/tests/runtime/test_application_runtime.py+++ b/tests/runtime/test_application_runtime.py@@ -15,8 +15,11 @@ from free_claude_code.application.errors import ApplicationUnavailableErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.admin.persistence import PreparedAdminUpdatefrom free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceRequest,+ InferenceStreamLedger,+)from 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 (@@ -61,8 +64,9 @@ class AdminModelProvider(BaseProvider):def preflight_stream(self,- request: MessagesRequest,+ request: InferenceRequest,*,+ provider_model: str,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:return None@@ -77,9 +81,10 @@ class AdminModelProvider(BaseProvider):async def stream_response(self,- request: MessagesRequest,+ request: InferenceRequest,input_tokens: int = 0,*,+ provider_model: str,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,diff --git a/uv.lock b/uv.lockindex 10c2eeec..32b177d4 100644--- a/uv.lock+++ b/uv.lock@@ -607,7 +607,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.14.2"+version = "5.14.3"source = { editable = "." }dependencies = [{ name = "aiohttp" },