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
Fix Auto mode failures on providers that require thinking (#1703)
Ali Khokhardcd55e8ce31c
diff --git a/e2e/conftest.py b/e2e/conftest.pyindex 340a480f..9154481b 100644--- a/e2e/conftest.py+++ b/e2e/conftest.py@@ -75,6 +75,7 @@ class _ModelListingProvider(BaseProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:return None@@ -103,6 +104,7 @@ class _ModelListingProvider(BaseProvider):response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del input_tokens, request_id, response_modelsummary = str(request.system).startswith("Summarize")diff --git a/pyproject.toml b/pyproject.tomlindex 5138c164..0c45c3a0 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.23.3"+version = "5.23.4"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/src/free_claude_code/api/handlers/classifier_response.py b/src/free_claude_code/api/handlers/classifier_response.pynew file mode 100644index 00000000..10e39a19--- /dev/null+++ b/src/free_claude_code/api/handlers/classifier_response.py@@ -0,0 +1,66 @@+"""Hide structured provider reasoning from Claude's classifier response."""++import sys+from collections.abc import AsyncIterator++from free_claude_code.core.anthropic.stream_contracts import SSEEvent+from free_claude_code.core.anthropic.streaming import format_sse_event+from free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoder+from free_claude_code.core.trace import close_stream_input+++async def classifier_response(source: AsyncIterator[str]) -> AsyncIterator[str]:+ """Project block lifecycles without interpreting any classifier text."""+ decoder = AnthropicSSEDecoder()+ indices: dict[int, int | None] = {}+ next_index = 0++ def project(event: SSEEvent) -> str | None:+ nonlocal next_index+ payload = event.data+ kind = payload.get("type", event.event)+ if kind not in {+ "content_block_start",+ "content_block_delta",+ "content_block_stop",+ }:+ return event.raw + "\n\n"+ index = payload.get("index")+ if not isinstance(index, int):+ return event.raw + "\n\n"+ if kind == "content_block_start":+ block = payload.get("content_block")+ if isinstance(block, dict) and block.get("type") in {+ "thinking",+ "redacted_thinking",+ }:+ indices[index] = None+ else:+ indices[index] = next_index+ next_index += 1+ if index not in indices:+ return event.raw + "\n\n"+ visible_index = indices[index]+ if kind == "content_block_stop":+ del indices[index]+ if visible_index is None:+ return None+ return format_sse_event(event.event, {**payload, "index": visible_index})++ try:+ async for chunk in source:+ for event in decoder.feed(chunk):+ projected = project(event)+ if projected is not None:+ yield projected+ for event in decoder.finish():+ projected = project(event)+ if projected is not None:+ yield projected+ finally:+ await close_stream_input(+ source,+ owner="classifier_response",+ source="api",+ preserved_error=sys.exception(),+ )diff --git a/src/free_claude_code/api/handlers/messages.py b/src/free_claude_code/api/handlers/messages.pyindex fc2e836e..0b505aef 100644--- a/src/free_claude_code/api/handlers/messages.py+++ b/src/free_claude_code/api/handlers/messages.py@@ -38,6 +38,7 @@ from free_claude_code.api.web_tools.request import (from free_claude_code.api.web_tools.streaming import stream_web_server_tool_responsefrom free_claude_code.application.errors import ApplicationError, InvalidRequestErrorfrom free_claude_code.application.execution import ProviderExecutor, TokenCounter+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.application.ports import ProviderResolverfrom free_claude_code.application.routing import ModelRouter, RoutedMessagesRequestfrom free_claude_code.config.settings import Settings@@ -55,6 +56,8 @@ from free_claude_code.core.failures import ExecutionFailure, find_execution_failfrom free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicyfrom free_claude_code.core.trace import trace_event+from .classifier_response import classifier_response+@dataclass(frozen=True)class _MessagesStreamResult:@@ -83,6 +86,7 @@ class MessagesHandler:provider_executor: ProviderExecutor | None = None,generation_id: int | None = None,request_headers: Mapping[str, str] | None = None,+ model_infos: tuple[ProviderModelInfo, ...] = (),) -> None:self._settings = settingsself._model_router = model_router or ModelRouter(settings)@@ -94,6 +98,7 @@ class MessagesHandler:generation_id=generation_id,log_raw_payloads=settings.log_raw_api_payloads,request_headers=request_headers,+ model_infos=model_infos,)self._message_intercepts: tuple[MessageIntercept, ...] = (self._intercept_web_server_tool,@@ -141,6 +146,10 @@ class MessagesHandler:request_id=request_id,))+ if routed.reasoning.control is ReasoningControl.PREFER_OFF and isinstance(+ result, _MessagesStreamResult+ ):+ result = _MessagesStreamResult(classifier_response(result.body))return await self._to_public_response(result,stream=request_data.stream,@@ -312,7 +321,7 @@ class MessagesHandler:if classifier_stop_sequence is None:return routed- reasoning_changed = routed.reasoning.control is not ReasoningControl.OFF+ reasoning_changed = routed.reasoning.control is not ReasoningControl.PREFER_OFFstop_sequences = routed.request.stop_sequencesremaining_stop_sequences = ([@@ -345,7 +354,7 @@ class MessagesHandler:routed,request=request,reasoning=(- ReasoningPolicy.off() if reasoning_changed else routed.reasoning+ ReasoningPolicy.prefer_off() if reasoning_changed else routed.reasoning),)diff --git a/src/free_claude_code/api/routes.py b/src/free_claude_code/api/routes.pyindex 4f37a28c..6e62c124 100644--- a/src/free_claude_code/api/routes.py+++ b/src/free_claude_code/api/routes.py@@ -52,13 +52,14 @@ async def _create_messages_response() -> object:lease: RequestRuntimeLease | None = Nonetry:- lease = await services.requests.acquire()+ lease = await services.requests.acquire(include_model_infos=True)handler = MessagesHandler(lease.settings,provider_resolver=_provider_resolver(lease),token_counter=get_token_count,generation_id=lease.generation_id,request_headers=request_headers,+ model_infos=lease.model_infos,)response = await handler.create(request_data, request_id=request_id)except ApplicationError as exc:diff --git a/src/free_claude_code/application/execution.py b/src/free_claude_code/application/execution.pyindex 1d1e4dc8..93ad02d7 100644--- a/src/free_claude_code/application/execution.py+++ b/src/free_claude_code/application/execution.py@@ -29,6 +29,7 @@ from free_claude_code.core.trace import (traced_async_stream,)+from .model_metadata import ProviderModelInfofrom .ports import ProviderResolverfrom .routing import (ProviderModelTarget,@@ -61,10 +62,12 @@ class ProviderExecutor:generation_id: int | None = None,log_raw_payloads: bool = False,request_headers: Mapping[str, str] | None = None,+ model_infos: tuple[ProviderModelInfo, ...] = (),) -> None:if not math.isfinite(progress_timeout_seconds) or progress_timeout_seconds <= 0:raise ValueError("progress_timeout_seconds must be finite and positive")self._provider_resolver = provider_resolver+ self._model_infos = {info.model_id: info for info in model_infos}self._token_counter = token_counterself._responses_token_counter = responses_token_counterself._generation_id = generation_id@@ -179,6 +182,7 @@ class ProviderExecutor:primary_provider.preflight_messages(primary_request,reasoning=routed.reasoning,+ model_info=self._model_infos.get(primary.provider_model_ref),)except ExecutionFailure as failure:primary_failure = failure@@ -208,13 +212,18 @@ class ProviderExecutor:if index == 0 and primary_failure is not None:raise primary_failureif index > 0:- provider.preflight_messages(request, reasoning=routed.reasoning)+ provider.preflight_messages(+ request,+ reasoning=routed.reasoning,+ model_info=self._model_infos.get(target.provider_model_ref),+ )return provider.stream_messages(request,input_tokens=input_tokens,request_id=request_id,response_model=routed.resolved.original_model,reasoning=routed.reasoning,+ model_info=self._model_infos.get(target.provider_model_ref),request_headers=self._request_headers,)diff --git a/src/free_claude_code/application/model_metadata.py b/src/free_claude_code/application/model_metadata.pyindex b980bebe..08ac3590 100644--- a/src/free_claude_code/application/model_metadata.py+++ b/src/free_claude_code/application/model_metadata.py@@ -3,6 +3,7 @@from dataclasses import dataclassfrom free_claude_code.core.model_capabilities import ModelInputModality+from free_claude_code.core.reasoning import ReasoningCapability@dataclass(frozen=True, slots=True)@@ -14,6 +15,7 @@ class ProviderModelInfo:input_modalities: frozenset[ModelInputModality] | None = Nonecontext_window_tokens: int | None = Nonemax_output_tokens: int | None = None+ reasoning_capability: ReasoningCapability = ReasoningCapability.UNKNOWN@dataclass(frozen=True, slots=True)diff --git a/src/free_claude_code/application/ports.py b/src/free_claude_code/application/ports.pyindex 91aa5186..88205e3b 100644--- a/src/free_claude_code/application/ports.py+++ b/src/free_claude_code/application/ports.py@@ -20,6 +20,7 @@ class ProviderPort(Protocol):request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None: ...def stream_messages(@@ -31,6 +32,7 @@ class ProviderPort(Protocol):response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]: ...def preflight_responses(diff --git a/src/free_claude_code/core/diagnostics.py b/src/free_claude_code/core/diagnostics.pyindex 1f35b807..098e50d8 100644--- a/src/free_claude_code/core/diagnostics.py+++ b/src/free_claude_code/core/diagnostics.py@@ -56,6 +56,18 @@ class UpstreamErrorDetail:category_hint: str | None = Nonebody_truncated: bool = False+ def is_invalid_request(self, *, code: object = None) -> bool:+ """Recognize HTTP validation failures and explicit streamed equivalents."""+ if self.status_code is not None:+ return self.status_code in {400, 422}+ codes = {+ "invalid_request_error",+ "invalid_request",+ "unsupported_parameter",+ "unsupported_value",+ }+ return self.category_hint in codes or (isinstance(code, str) and code in codes)+def redact_sensitive_error_text(text: str) -> str:"""Redact recognizable credentials while preserving diagnostic context."""diff --git a/src/free_claude_code/core/reasoning.py b/src/free_claude_code/core/reasoning.pyindex 252d8bc2..7bf18d35 100644--- a/src/free_claude_code/core/reasoning.py+++ b/src/free_claude_code/core/reasoning.py@@ -9,9 +9,19 @@ class ReasoningControl(StrEnum):DEFAULT = "default"OFF = "off"+ PREFER_OFF = "prefer_off"ON = "on"+class ReasoningCapability(StrEnum):+ """Explicit provider facts; absent computation controls remain unknown."""++ UNKNOWN = "unknown"+ NONE = "none"+ OPTIONAL = "optional"+ REQUIRED = "required"++class ReasoningEffort(StrEnum):"""Named reasoning effort understood at the FCC application boundary."""@@ -74,6 +84,11 @@ class ReasoningPolicy:return cls(control=ReasoningControl.OFF)+ @classmethod+ def prefer_off(cls) -> ReasoningPolicy:+ """Prefer disabling computation, allowing provider defaults if necessary."""+ return cls(control=ReasoningControl.PREFER_OFF)+@classmethoddef on(cls,@@ -91,7 +106,7 @@ class ReasoningPolicy:@propertydef output_enabled(self) -> bool:- """Return whether provider reasoning may be exposed to the client."""+ """Allow normalized reasoning; classifier ingress owns its public filter."""return self.control is not ReasoningControl.OFFdiff --git a/src/free_claude_code/providers/anthropic_messages/transport.py b/src/free_claude_code/providers/anthropic_messages/transport.pyindex 911a951a..7a029ce8 100644--- a/src/free_claude_code/providers/anthropic_messages/transport.py+++ b/src/free_claude_code/providers/anthropic_messages/transport.py@@ -1,6 +1,7 @@"""Native Messages HTTP execution with one admitted recovery budget."""import asyncio+import jsonimport sysfrom collections.abc import AsyncIterator, Callable, Mappingfrom typing import cast@@ -8,6 +9,7 @@ from typing import castimport httpxfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic.errors import anthropic_status_for_error_typefrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.native import (@@ -32,7 +34,11 @@ from free_claude_code.core.openai_responses import (ResponsesMessagesRequest,build_responses_messages_request,)-from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy+from free_claude_code.core.reasoning import (+ DEFAULT_REASONING_POLICY,+ ReasoningControl,+ ReasoningPolicy,+)from free_claude_code.core.trace import trace_eventfrom free_claude_code.providers.admission import (ProviderAdmissionController,@@ -50,12 +56,20 @@ 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.reasoning_compatibility import (+ ReasoningCorrection,+ prepare_messages_reasoning,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,)-from .request_policy import MessagesModelCapabilities, resolve_messages_options+from .request_policy import (+ DEFAULT_MESSAGES_OUTPUT_TOKENS,+ MessagesModelCapabilities,+ resolve_messages_options,+)type _Presenter = NativeMessagesRelay | AnthropicToResponsesStream@@ -81,8 +95,18 @@ class AnthropicMessagesTransport:self._capabilities = capabilitiesdef _messages_body(- self, request: MessagesRequest, reasoning: ReasoningPolicy+ self,+ request: MessagesRequest,+ reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> PreparedMessagesRequest:+ request, reasoning = prepare_messages_reasoning(+ request,+ reasoning,+ model_info=model_info,+ can_disable=True,+ normal_max_tokens=DEFAULT_MESSAGES_OUTPUT_TOKENS,+ )try:options = resolve_messages_options(model=request.model,@@ -122,8 +146,9 @@ class AnthropicMessagesTransport:request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:- self._messages_body(request, reasoning)+ self._messages_body(request, reasoning, model_info)def preflight_responses(self,@@ -141,10 +166,30 @@ class AnthropicMessagesTransport:request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:- prepared = self._messages_body(request, reasoning)+ prepared_request, wire_reasoning = prepare_messages_reasoning(+ request,+ reasoning,+ model_info=model_info,+ can_disable=True,+ normal_max_tokens=DEFAULT_MESSAGES_OUTPUT_TOKENS,+ )+ prepared = self._messages_body(prepared_request, wire_reasoning)+ correction = (+ ReasoningCorrection(+ (("thinking",),),+ "max_tokens",+ DEFAULT_MESSAGES_OUTPUT_TOKENS,+ self._capabilities.max_output_tokens,+ )+ if reasoning.control is ReasoningControl.PREFER_OFF+ and wire_reasoning.control is ReasoningControl.OFF+ else None+ )return self._stream(prepared.body,+ reasoning_correction=correction,betas=prepared.betas,endpoint_context=endpoint_context,request_id=request_id,@@ -184,10 +229,12 @@ class AnthropicMessagesTransport:endpoint_context: EndpointContext,request_id: str | None,presenter_factory: Callable[[], _Presenter],+ reasoning_correction: ReasoningCorrection | None = None,) -> AsyncIterator[str]:execution = self._admission.start_execution(request_id=request_id)run = self._run(body,+ reasoning_correction=reasoning_correction,betas=betas,endpoint_context=endpoint_context,execution=execution,@@ -215,6 +262,7 @@ class AnthropicMessagesTransport:endpoint_context: EndpointContext,execution: ProviderExecution,presenter_factory: Callable[[], _Presenter],+ reasoning_correction: ReasoningCorrection | None = None,) -> AsyncIterator[str]:recovery = RecoveryController()refreshed = False@@ -318,6 +366,24 @@ class AnthropicMessagesTransport:recovery.discard()continueattempt_failure = None+ if (+ scope is not None+ and reasoning_correction is not None+ and not recovery.committed+ ):+ corrected_body = reasoning_correction.retry_body(error, body)+ if corrected_body is not None:+ retry = (+ execution.can_attempt+ if scope.attempt.accepted+ else await scope.attempt.correct(error)+ is ProviderCorrectionAction.RETRY+ )+ reasoning_correction = None+ if retry:+ body = corrected_body+ recovery.discard()+ continueif scope is not None and not scope.attempt.accepted:attempt_failure = await scope.attempt.fail(error)if attempt_failure is not None and attempt_failure.retry_allowed:@@ -417,7 +483,7 @@ def _check_failure(event_type: str, payload: JsonObject) -> None:529: FailureKind.OVERLOADED,}.get(status, FailureKind.UPSTREAM)message = error.get("message") if isinstance(error, Mapping) else None- raise ExecutionFailure(+ failure = ExecutionFailure(failure_kind,status,redact_sensitive_error_text(message[:ERROR_DETAIL_DISPLAY_CAP_BYTES])@@ -425,6 +491,8 @@ def _check_failure(event_type: str, payload: JsonObject) -> None:else "Messages upstream returned an error.",status == 429 or status >= 500,)+ attach_upstream_error_body(failure, json.dumps(payload))+ raise failureasync def _status_error(response: httpx.Response) -> httpx.HTTPStatusError:diff --git a/src/free_claude_code/providers/base.py b/src/free_claude_code/providers/base.pyindex 758cef65..7edb1e04 100644--- a/src/free_claude_code/providers/base.py+++ b/src/free_claude_code/providers/base.py@@ -50,6 +50,7 @@ class BaseProvider(ABC):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:"""Validate a Messages request before opening its SSE stream."""@@ -123,6 +124,7 @@ class BaseProvider(ABC):response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""diff --git a/src/free_claude_code/providers/deepseek/client.py b/src/free_claude_code/providers/deepseek/client.pyindex df970746..7c4697c4 100644--- a/src/free_claude_code/providers/deepseek/client.py+++ b/src/free_claude_code/providers/deepseek/client.py@@ -2,6 +2,8 @@from typing import Any+from free_claude_code.application.model_metadata import ProviderModelInfo+from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENSfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionController@@ -49,6 +51,14 @@ def _deepseek_cache_partition(class DeepSeekProvider(OpenAIChatProvider):"""DeepSeek using ``https://api.deepseek.com`` Chat Completions."""+ @property+ def _reasoning_off_fields(self) -> tuple[tuple[str, ...], ...]:+ return (("extra_body", "thinking"),)++ @property+ def _normal_max_tokens(self) -> int:+ return ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+def __init__(self, config: ProviderConfig, *, admission: ProviderAdmissionController):@@ -63,7 +73,11 @@ class DeepSeekProvider(OpenAIChatProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> dict:+ request, reasoning = self._prepare_messages_reasoning(+ request, reasoning, model_info+ )return build_deepseek_request_body(request,reasoning=reasoning,diff --git a/src/free_claude_code/providers/github_copilot/provider.py b/src/free_claude_code/providers/github_copilot/provider.pyindex c319c652..3520187a 100644--- a/src/free_claude_code/providers/github_copilot/provider.py+++ b/src/free_claude_code/providers/github_copilot/provider.py@@ -120,6 +120,7 @@ class GitHubCopilotProvider(BaseProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:# Endpoint family and capabilities belong to the current account lease.# Conversion runs after acquisition and before opening the physical stream.@@ -151,6 +152,7 @@ class GitHubCopilotProvider(BaseProvider):response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:self.preflight_messages(request, reasoning=reasoning)return self._dispatch(@@ -236,6 +238,7 @@ class GitHubCopilotProvider(BaseProvider):request_id=request_id,response_model=response_model,reasoning=reasoning,+ model_info=lease.model.info,)else:selected = native.stream_responses(@@ -255,14 +258,28 @@ class GitHubCopilotProvider(BaseProvider):else self._chat(lease.model))if isinstance(request, MessagesRequest):- selected = transport.stream_messages(- request,- input_tokens=input_tokens,- request_id=request_id,- response_model=response_model,- reasoning=resolved,- endpoint_context=lease,- )+ if lease.egress is CopilotEgress.RESPONSES:+ selected = self._responses.stream_messages(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=resolved,+ endpoint_context=lease,+ model_info=lease.model.info,+ can_disable_reasoning="none"+ in (lease.model.supported_efforts or ()),+ )+ else:+ selected = self._chat(lease.model).stream_messages(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=resolved,+ endpoint_context=lease,+ model_info=lease.model.info,+ )else:selected = transport.stream_responses(request,diff --git a/src/free_claude_code/providers/github_copilot/request_policy.py b/src/free_claude_code/providers/github_copilot/request_policy.pyindex 5bce0c97..aa881e08 100644--- a/src/free_claude_code/providers/github_copilot/request_policy.py+++ b/src/free_claude_code/providers/github_copilot/request_policy.py@@ -16,6 +16,9 @@ from free_claude_code.providers.openai_chat import (OpenAIChatProfile,OpenAIChatRequestPolicy,)+from free_claude_code.providers.reasoning_compatibility import (+ prepare_messages_reasoning,+)from .types import CopilotModel@@ -52,6 +55,18 @@ def non_messages_reasoning(model: CopilotModel,) -> ReasoningPolicy:"""Reject controls these egresses cannot encode before any inference."""+ if policy.control is ReasoningControl.PREFER_OFF and isinstance(+ request, MessagesRequest+ ):+ prepared, wire_policy = prepare_messages_reasoning(+ request,+ policy,+ model_info=model.info,+ can_disable="none" in (model.supported_efforts or ()),+ normal_max_tokens=None,+ )+ non_messages_reasoning(prepared, wire_policy, model)+ return policyraw_effort = ((request.output_config.get("effort") if request.output_config else None)if isinstance(request, MessagesRequest)diff --git a/src/free_claude_code/providers/github_copilot/sdk.py b/src/free_claude_code/providers/github_copilot/sdk.pyindex 532641e9..7548cc9b 100644--- a/src/free_claude_code/providers/github_copilot/sdk.py+++ b/src/free_claude_code/providers/github_copilot/sdk.py@@ -42,6 +42,7 @@ from free_claude_code.providers.anthropic_messages.request_policy import (MessagesModelCapabilities,)from free_claude_code.providers.endpoint import HttpEndpoint+from free_claude_code.providers.model_listing import reasoning_capability_from_optionsfrom .lifecycle import drain_ownedfrom .types import (@@ -444,6 +445,9 @@ def _model(model: Model) -> CopilotModel:context = limits.max_context_window_tokens if limits is not None else Noneinfo = ProviderModelInfo(model_id=model.id,+ reasoning_capability=reasoning_capability_from_options(+ {"supported_efforts": efforts}+ ),supports_thinking=Trueif effort_support is True or adaptive in {"optional", "required"}else None,diff --git a/src/free_claude_code/providers/google_openai/reasoning.py b/src/free_claude_code/providers/google_openai/reasoning.pyindex bfeff191..3fa5afca 100644--- a/src/free_claude_code/providers/google_openai/reasoning.py+++ b/src/free_claude_code/providers/google_openai/reasoning.py@@ -33,6 +33,8 @@ _THINKING_CONFIG_CONFLICT = (class GeminiReasoningEncoder:"""Choose one Gemini API reasoning channel for each resolved policy."""+ off_field = ("reasoning_effort",)+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:if _preserve_caller_thinking_config(body, policy):return@@ -59,6 +61,8 @@ class GeminiReasoningEncoder:class VertexReasoningEncoder:"""Encode Vertex reasoning through one Google thinking-config object."""+ off_field = ("extra_body", "extra_body", "google", "thinking_config")+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:if _preserve_caller_thinking_config(body, policy):returndiff --git a/src/free_claude_code/providers/groq/client.py b/src/free_claude_code/providers/groq/client.pyindex 99387a75..4fda86a0 100644--- a/src/free_claude_code/providers/groq/client.py+++ b/src/free_claude_code/providers/groq/client.py@@ -25,6 +25,7 @@ from free_claude_code.providers.openai_chat import (OpenAIModelListing,validate_extra_body_does_not_override_reasoning_fields,)+from free_claude_code.providers.reasoning_compatibility import ReasoningCorrectionfrom .tpm import correct_tpm_completion_budget@@ -117,6 +118,10 @@ class GroqProvider(OpenAIChatProvider):return bodyreturn _rewrite_reasoning_effort(body, accepted) or body+ def _reasoning_disable_rejected(self, error: Exception) -> bool:+ accepted = _parse_reasoning_vocabulary(error)+ return accepted is not None and "none" not in accepted+def _get_retry_request_body(self, error: Exception, body: dict[str, Any]) -> dict[str, Any] | None:@@ -143,8 +148,17 @@ class GroqProvider(OpenAIChatProvider):error: Exception,body: JsonObject,used_retry_kinds: set[str],+ *,+ reasoning_correction: ReasoningCorrection | None = None,+ sent_body: Mapping[str, Any] | None = None,) -> JsonObject | None:- retry_body = super()._next_create_retry_body(error, body, used_retry_kinds)+ retry_body = super()._next_create_retry_body(+ error,+ body,+ used_retry_kinds,+ reasoning_correction=reasoning_correction,+ sent_body=sent_body,+ )if retry_body is not None or "groq_tpm" in used_retry_kinds:return retry_bodydiff --git a/src/free_claude_code/providers/lmstudio/client.py b/src/free_claude_code/providers/lmstudio/client.pyindex 62ad330e..07692214 100644--- a/src/free_claude_code/providers/lmstudio/client.py+++ b/src/free_claude_code/providers/lmstudio/client.py@@ -16,6 +16,7 @@ import timeimport httpxfrom loguru import logger+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayMode, get_token_countfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.openai_responses import (@@ -85,8 +86,9 @@ class LMStudioProvider(OpenAIChatProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:- super().preflight_messages(request, reasoning=reasoning)+ super().preflight_messages(request, reasoning=reasoning, model_info=model_info)self._preflight_context_budget(get_token_count(request.messages, request.system, request.tools))diff --git a/src/free_claude_code/providers/mistral/client.py b/src/free_claude_code/providers/mistral/client.pyindex aaf00cfe..ccb5109c 100644--- a/src/free_claude_code/providers/mistral/client.py+++ b/src/free_claude_code/providers/mistral/client.py@@ -48,6 +48,10 @@ _PROFILE = OpenAIChatProfile(class MistralProvider(OpenAIChatProvider):"""Mistral API using ``https://api.mistral.ai/v1/chat/completions``."""+ @property+ def _reasoning_off_fields(self) -> tuple[tuple[str, ...], ...]:+ return (("reasoning_effort",),)+def __init__(self, config: ProviderConfig, *, admission: ProviderAdmissionController):diff --git a/src/free_claude_code/providers/model_listing.py b/src/free_claude_code/providers/model_listing.pyindex 76f11b74..f56d6728 100644--- a/src/free_claude_code/providers/model_listing.py+++ b/src/free_claude_code/providers/model_listing.py@@ -8,6 +8,7 @@ from free_claude_code.application.model_metadata import (ProviderModelInfo as _ProviderModelInfo,)from free_claude_code.core.model_capabilities import ModelInputModality+from free_claude_code.core.reasoning import ReasoningCapabilitytype ModelListScalar = str | booltype RequiredPathValues = tuple[@@ -124,11 +125,16 @@ def extract_openai_model_infos(continuesupports_thinking: bool | None = None+ intrinsic_facts: set[bool] = set()if tags_field is not None:tags_value = _field(item, tags_field)tags = _optional_string_sequence(tags_value)if tags is not None:tag_set = frozenset(tags)+ if thinking_tag in tag_set:+ intrinsic_facts.add(True)+ if non_thinking_tag is not None and non_thinking_tag in tag_set:+ intrinsic_facts.add(False)if thinking_tag in tag_set:supports_thinking = Trueelif non_thinking_tag is not None and non_thinking_tag in tag_set:@@ -138,6 +144,7 @@ def extract_openai_model_infos(capability = _path(item, thinking_boolean_path)if isinstance(capability, bool):supports_thinking = capability+ intrinsic_facts.add(capability)if thinking_sequence_path is not None:values = _optional_string_sequence(_path(item, thinking_sequence_path))@@ -162,6 +169,9 @@ def extract_openai_model_infos(model_info = _ProviderModelInfo(model_id=model_id,+ reasoning_capability=ReasoningCapability.NONE+ if intrinsic_facts == {False}+ else ReasoningCapability.UNKNOWN,supports_thinking=supports_thinking,input_modalities=input_modalities,context_window_tokens=context_window_tokens,@@ -216,6 +226,9 @@ def extract_tool_capable_model_infos(model_infos.add(_ProviderModelInfo(model_id=model_id,+ reasoning_capability=reasoning_capability_from_options(+ _field(item, "reasoning")+ ),supports_thinking=("reasoning" in capability_parametersif capability_parameters is not None@@ -236,6 +249,24 @@ def extract_tool_capable_model_infos(return frozenset(model_infos)+def reasoning_capability_from_options(options: object) -> ReasoningCapability:+ """Retain explicit gateway computation facts; missing controls prove nothing."""+ if not isinstance(options, Mapping):+ return ReasoningCapability.UNKNOWN+ mandatory = options.get("mandatory")+ efforts = options.get("supported_efforts")+ if mandatory is not None and not isinstance(mandatory, bool):+ return ReasoningCapability.UNKNOWN+ if efforts is not None and _optional_string_sequence(efforts) is None:+ return ReasoningCapability.UNKNOWN+ can_disable = isinstance(efforts, (list, tuple)) and "none" in efforts+ if mandatory is True:+ return (+ ReasoningCapability.UNKNOWN if can_disable else ReasoningCapability.REQUIRED+ )+ return ReasoningCapability.OPTIONAL if can_disable else ReasoningCapability.UNKNOWN++def model_list_items(payload: Any,*,diff --git a/src/free_claude_code/providers/nvidia_nim/client.py b/src/free_claude_code/providers/nvidia_nim/client.pyindex ac571528..1d3e6085 100644--- a/src/free_claude_code/providers/nvidia_nim/client.py+++ b/src/free_claude_code/providers/nvidia_nim/client.py@@ -8,6 +8,7 @@ from typing import Anyimport openaifrom loguru import logger+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.nim import NimSettingsfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.failures import ExecutionFailure@@ -54,6 +55,17 @@ _PROFILE = OpenAIChatProfile(class NvidiaNimProvider(OpenAIChatProvider):"""NVIDIA NIM provider using official OpenAI client."""+ @property+ def _reasoning_off_fields(self) -> tuple[tuple[str, ...], ...]:+ return (+ ("extra_body", "chat_template_kwargs", "thinking"),+ ("extra_body", "chat_template_kwargs", "enable_thinking"),+ )++ @property+ def _normal_max_tokens(self) -> int | None:+ return self._nim_settings.max_tokens+def __init__(self,config: ProviderConfig,@@ -73,8 +85,12 @@ class NvidiaNimProvider(OpenAIChatProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> dict:"""Internal helper for tests and shared building."""+ request, reasoning = self._prepare_messages_reasoning(+ request, reasoning, model_info+ )return build_nim_request_body(request,self._nim_settings,diff --git a/src/free_claude_code/providers/open_router/client.py b/src/free_claude_code/providers/open_router/client.pyindex 7410f4cb..57b96fe9 100644--- a/src/free_claude_code/providers/open_router/client.py+++ b/src/free_claude_code/providers/open_router/client.py@@ -1,8 +1,11 @@"""OpenRouter provider implementation."""+import json+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENSfrom free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.core.diagnostics import extract_upstream_error_detailfrom free_claude_code.core.reasoning import ReasoningEffortfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -15,6 +18,9 @@ from free_claude_code.providers.openai_chat import (apply_reasoning_details_replay,validate_extra_body_does_not_override_canonical_fields,)+from free_claude_code.providers.reasoning_compatibility import (+ reasoning_control_rejected,+)_REQUEST_POLICY = OpenAIChatRequestPolicy(provider_name="OPENROUTER",@@ -37,6 +43,26 @@ class OpenRouterProvider(OpenAIChatProvider):admission=admission,)+ def _reasoning_disable_rejected(self, error: Exception) -> bool:+ detail = extract_upstream_error_detail(error)+ if detail.status_code not in {None, 200}:+ return False+ try:+ payload = json.loads(detail.body_text or "")+ except ValueError:+ return False+ if not isinstance(payload, dict):+ return False+ error_body = payload.get("error", payload)+ if not isinstance(error_body, dict):+ return False+ code = error_body.get("code")+ return (+ isinstance(code, int)+ and code == 400+ and reasoning_control_rejected(error_body, ("reasoning",))+ )+async def list_model_infos(self) -> frozenset[ProviderModelInfo]:"""Advertise OpenRouter tool models with reasoning capability metadata."""payload = await self._list_models_payload()diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.pyindex 93a117d9..612f9040 100644--- a/src/free_claude_code/providers/openai_chat/provider.py+++ b/src/free_claude_code/providers/openai_chat/provider.py@@ -46,7 +46,11 @@ from free_claude_code.core.openai_tool_names import (OpenAIToolNameCodec,encode_openai_chat_tool_names,)-from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy+from free_claude_code.core.reasoning import (+ DEFAULT_REASONING_POLICY,+ ReasoningControl,+ ReasoningPolicy,+)from free_claude_code.core.trace import provider_chat_body_snapshot, trace_eventfrom free_claude_code.providers.admission import (ProviderAdmissionController,@@ -76,6 +80,10 @@ from free_claude_code.providers.model_listing import (model_infos_from_ids,validate_model_list_page,)+from free_claude_code.providers.reasoning_compatibility import (+ ReasoningCorrection,+ prepare_messages_reasoning,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -665,8 +673,12 @@ class OpenAIChatProvider(BaseProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> dict[str, Any]:"""Build a provider request from the immutable profile."""+ request, reasoning = self._prepare_messages_reasoning(+ request, reasoning, model_info+ )body = build_openai_chat_request_body(request,reasoning=reasoning,@@ -675,6 +687,29 @@ class OpenAIChatProvider(BaseProvider):)return self._finalize_chat_body(body, reasoning=reasoning)+ @property+ def _reasoning_off_fields(self) -> tuple[tuple[str, ...], ...]:+ field = self._profile.reasoning.off_field+ return (field,) if field is not None else ()++ @property+ def _normal_max_tokens(self) -> int | None:+ return self._profile.request_policy.default_max_tokens++ def _prepare_messages_reasoning(+ self,+ request: MessagesRequest,+ reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None,+ ) -> tuple[MessagesRequest, ReasoningPolicy]:+ return prepare_messages_reasoning(+ request,+ reasoning,+ model_info=model_info,+ can_disable=bool(self._reasoning_off_fields),+ normal_max_tokens=self._normal_max_tokens,+ )+def _build_responses_request_body(self,request: OpenAIResponsesRequest,@@ -718,9 +753,10 @@ class OpenAIChatProvider(BaseProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:"""Validate OpenAI-chat request conversion before streaming."""- self._build_request_body(request, reasoning=reasoning)+ self._build_request_body(request, reasoning=reasoning, model_info=model_info)def preflight_responses(self,@@ -741,6 +777,10 @@ class OpenAIChatProvider(BaseProvider):"""Return a modified request body for one retry, or None."""return None+ def _reasoning_disable_rejected(self, error: Exception) -> bool:+ """Recognize provider-owned OFF rejection formats without learning state."""+ return False+def _provider_failure_override(self, error: Exception) -> ExecutionFailure | None:"""Return provider-specific failure semantics, or defer to shared policy."""return None@@ -797,7 +837,8 @@ class OpenAIChatProvider(BaseProvider):used_retry_kinds: set[str] | None = None,endpoint: RequestEndpoint | None = None,extra_headers: Mapping[str, str] | None = None,- ) -> tuple[Any, dict, ProviderAttempt]:+ reasoning_correction: ReasoningCorrection | None = None,+ ) -> tuple[Any, dict, ProviderAttempt, dict]:"""Create a streaming chat completion with bounded request fallbacks."""body = self._apply_learned_output_cap(body)if used_retry_kinds is None:@@ -807,6 +848,7 @@ class OpenAIChatProvider(BaseProvider):attempt = await execution.open_attempt(operation_kind)stream: Any | None = Noneretain_attempt = False+ create_body = bodytry:create_body = self._prepare_create_body(body)client = (@@ -827,7 +869,7 @@ class OpenAIChatProvider(BaseProvider):)stream = self._normalize_stream(stream, body)retain_attempt = True- return stream, body, attempt+ return stream, body, attempt, create_bodyexcept asyncio.CancelledError:raiseexcept Exception as error:@@ -835,11 +877,17 @@ class OpenAIChatProvider(BaseProvider):error, attempt, execution):continue- retry_body = self._next_create_retry_body(error, body, used_retry_kinds)+ retry_body = self._next_create_retry_body(+ error,+ body,+ used_retry_kinds,+ reasoning_correction=reasoning_correction,+ sent_body=create_body,+ )if retry_body is not None:correction = await attempt.correct(error)if correction is ProviderCorrectionAction.RETRY:- body = retry_body+ body = self._apply_learned_output_cap(retry_body)continueraisedecision = await attempt.fail(@@ -872,7 +920,17 @@ class OpenAIChatProvider(BaseProvider):error: Exception,body: dict,used_retry_kinds: set[str],+ *,+ reasoning_correction: ReasoningCorrection | None = None,+ sent_body: Mapping[str, Any] | None = None,) -> dict | None:+ if reasoning_correction is not None and "reasoning" not in used_retry_kinds:+ retry_body = reasoning_correction.retry_body(+ error, body, sent_body=sent_body+ )+ if retry_body is not None:+ used_retry_kinds.add("reasoning")+ return retry_bodyretry_body = self._retry_body_for_output_cap(error, body)if retry_body is not None:return retry_body@@ -935,11 +993,28 @@ class OpenAIChatProvider(BaseProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,endpoint_context: EndpointContext | None = None,request_headers: Mapping[str, str] | None = None,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""- body = self._build_request_body(request, reasoning=reasoning)+ prepared_request, wire_reasoning = self._prepare_messages_reasoning(+ request, reasoning, model_info+ )+ body = self._build_request_body(prepared_request, reasoning=wire_reasoning)+ off_fields = self._reasoning_off_fields+ correction = (+ ReasoningCorrection(+ off_fields,+ self._profile.request_policy.max_tokens_field,+ self._normal_max_tokens,+ provider_rejection=self._reasoning_disable_rejected,+ )+ if reasoning.control is ReasoningControl.PREFER_OFF+ and wire_reasoning.control is ReasoningControl.OFF+ and off_fields+ else None+ )tool_names = OpenAIToolNameCodec.from_request(request)message_id = f"msg_{uuid.uuid4()}"runner = _OpenAIChatStreamRunner(@@ -962,6 +1037,7 @@ class OpenAIChatProvider(BaseProvider):reasoning=reasoning,endpoint_context=endpoint_context,extra_headers=self._upstream_headers(request_headers or {}),+ reasoning_correction=correction,)return runner.run()@@ -1022,6 +1098,7 @@ class _OpenAIChatStreamRunner:reasoning: ReasoningPolicy,endpoint_context: EndpointContext | None = None,extra_headers: Mapping[str, str] | None = None,+ reasoning_correction: ReasoningCorrection | None = None,) -> None:self._provider = providerself._body = body@@ -1033,6 +1110,7 @@ class _OpenAIChatStreamRunner:self._request_id = request_idself._response_model = response_modelself._reasoning = reasoning+ self._reasoning_correction = reasoning_correctionself._extra_headers = dict(extra_headers or {})self._terminal_failure: ExecutionFailure | None = Noneself._endpoint = (@@ -1106,13 +1184,14 @@ class _OpenAIChatStreamRunner:assembler = self._new_stream_assembler(output_reasoning=output_reasoning)scope: ProviderAttemptScope | None = Nonetry:- stream, body, attempt = await self._provider._create_stream(+ stream, body, attempt, sent_body = await self._provider._create_stream(body,execution,ProviderOperationKind.GENERATION,used_retry_kinds=used_retry_kinds,endpoint=self._endpoint,extra_headers=self._extra_headers,+ reasoning_correction=self._reasoning_correction,)scope = ProviderAttemptScope(attempt,@@ -1141,6 +1220,29 @@ class _OpenAIChatStreamRunner:except asyncio.CancelledError, GeneratorExit:raiseexcept Exception as error:+ if (+ scope is not None+ and not recovery.committed+ and self._reasoning_correction is not None+ and "reasoning" not in used_retry_kinds+ ):+ corrected_body = self._reasoning_correction.retry_body(+ error, body, sent_body=sent_body+ )+ if corrected_body is not None:+ used_retry_kinds.add("reasoning")+ retry = (+ execution.can_attempt+ if scope.attempt.accepted+ else await scope.attempt.correct(error)+ is ProviderCorrectionAction.RETRY+ )+ if retry:+ body = self._provider._apply_learned_output_cap(+ corrected_body+ )+ recovery.discard()+ continueresolution = await self._resolve_attempt_failure(error=error,scope=scope,@@ -1389,7 +1491,7 @@ class _OpenAIChatStreamRunner:while execution.can_attempt:scope: ProviderAttemptScope | None = Nonetry:- stream, body, attempt = await self._provider._create_stream(+ stream, body, attempt, _sent_body = await self._provider._create_stream(body,execution,operation_kind,diff --git a/src/free_claude_code/providers/openai_chat/reasoning.py b/src/free_claude_code/providers/openai_chat/reasoning.pyindex 0c36a82f..1a8faec8 100644--- a/src/free_claude_code/providers/openai_chat/reasoning.py+++ b/src/free_claude_code/providers/openai_chat/reasoning.py@@ -17,11 +17,16 @@ class ReasoningEncoder(Protocol):def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None: ...+ @property+ def off_field(self) -> tuple[str, ...] | None: ...+@dataclass(frozen=True, slots=True)class NoReasoning:"""Leave reasoning computation entirely to the upstream provider."""+ off_field = None+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:return@@ -37,6 +42,12 @@ class NamedEffortReasoning:budget_field: str | None = Noneuse_extra_body: bool = False+ @property+ def off_field(self) -> tuple[str, ...] | None:+ if self.disabled_value is None:+ return None+ return ("extra_body", self.field) if self.use_extra_body else (self.field,)+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:target = _extra_body(body) if self.use_extra_body else bodyif policy.control is ReasoningControl.OFF:@@ -64,6 +75,8 @@ class ReasoningObject:efforts: EffortValuessupports_budget: bool = True+ off_field = ("extra_body", "reasoning")+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:if policy.control is ReasoningControl.OFF:_extra_body(body)["reasoning"] = {"enabled": False}@@ -88,6 +101,8 @@ class ThinkingObjectReasoning:enabled: dict[str, Any]disabled: dict[str, Any]+ off_field = ("extra_body", "thinking")+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:if policy.control is ReasoningControl.OFF:_extra_body(body)["thinking"] = dict(self.disabled)@@ -101,6 +116,10 @@ class ChatTemplateReasoning:field: str = "thinking"+ @property+ def off_field(self) -> tuple[str, ...]:+ return ("extra_body", "chat_template_kwargs", self.field)+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:if not policy.requests_reasoning and policy.control is not ReasoningControl.OFF:return@@ -112,6 +131,8 @@ class ChatTemplateReasoning:class LlamaCppReasoning:"""Encode llama.cpp's per-request numeric thinking budget."""+ off_field = ("extra_body", "thinking_budget_tokens")+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:if policy.control is ReasoningControl.OFF:_extra_body(body)["thinking_budget_tokens"] = 0@@ -123,6 +144,8 @@ class LlamaCppReasoning:class SplitReasoningOutput:"""Request separate reasoning output where compute is not controllable."""+ off_field = None+def encode(self, body: dict[str, Any], policy: ReasoningPolicy) -> None:_extra_body(body)["reasoning_split"] = Truediff --git a/src/free_claude_code/providers/openai_codex/provider.py b/src/free_claude_code/providers/openai_codex/provider.pyindex f6058335..6ecf1c42 100644--- a/src/free_claude_code/providers/openai_codex/provider.py+++ b/src/free_claude_code/providers/openai_codex/provider.py@@ -24,6 +24,7 @@ from free_claude_code.providers.http import ProviderAttemptScopefrom free_claude_code.providers.model_listing import (optional_input_modalities,optional_positive_int,+ reasoning_capability_from_options,)from free_claude_code.providers.openai_responses import OpenAIResponsesTransport@@ -96,8 +97,11 @@ class OpenAICodexProvider(BaseProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:- self._responses.preflight_messages(request, reasoning=reasoning)+ self._responses.preflight_messages(+ request, reasoning=reasoning, model_info=model_info+ )def preflight_responses(self,@@ -174,6 +178,7 @@ class OpenAICodexProvider(BaseProvider):response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:return self._responses.stream_messages(request,@@ -182,6 +187,7 @@ class OpenAICodexProvider(BaseProvider):response_model=response_model or request.model,reasoning=reasoning,endpoint_context=self._endpoint(session_id=str(uuid.uuid4())),+ model_info=model_info,)def stream_responses(@@ -233,6 +239,13 @@ def _model_infos(payload: Any) -> frozenset[ProviderModelInfo]:ProviderModelInfo(model_id=model_id,supports_thinking=_supports_reasoning(efforts),+ reasoning_capability=reasoning_capability_from_options(+ {+ "supported_efforts": [level["effort"] for level in efforts]+ if _supports_reasoning(efforts) is not None+ else None,+ }+ ),input_modalities=optional_input_modalities(model.get("input_modalities")),diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex 3b7a395f..c7a6b2e1 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -12,6 +12,7 @@ from openai.types.responses import ResponseInputParam, ResponseStreamEventfrom openai.types.responses.response_create_params import ResponseCreateParamsStreamingfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.diagnostics import extract_upstream_error_detailfrom free_claude_code.core.failures import ExecutionFailure, FailureKind@@ -28,10 +29,11 @@ from free_claude_code.core.openai_responses import (responses_stream_failure_from_event,)from free_claude_code.core.openai_tool_names import OpenAIToolNameCodec-from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicyfrom free_claude_code.core.trace import trace_eventfrom free_claude_code.providers.admission import (ProviderAdmissionController,+ ProviderCorrectionAction,ProviderExecution,ProviderOperationKind,)@@ -46,6 +48,10 @@ from free_claude_code.providers.failure_policy import (reports_context_window_incomplete,)from free_claude_code.providers.http import ProviderAttemptScope, maybe_await_aclose+from free_claude_code.providers.reasoning_compatibility import (+ ReasoningCorrection,+ prepare_messages_reasoning,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -112,8 +118,15 @@ class OpenAIResponsesTransport:request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,+ can_disable_reasoning: bool = True,) -> None:- self._build_messages_body(request, reasoning=reasoning)+ self._build_messages_body(+ request,+ reasoning=reasoning,+ model_info=model_info,+ can_disable_reasoning=can_disable_reasoning,+ )def stream_messages(self,@@ -125,12 +138,28 @@ class OpenAIResponsesTransport:reasoning: ReasoningPolicy,endpoint_context: EndpointContext | None = None,extra_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,+ can_disable_reasoning: bool = True,) -> AsyncIterator[str]:- body = self._build_messages_body(request, reasoning=reasoning)+ prepared, wire_reasoning = prepare_messages_reasoning(+ request,+ reasoning,+ model_info=model_info,+ can_disable=can_disable_reasoning,+ normal_max_tokens=None,+ )+ body = self._build_messages_body(prepared, reasoning=wire_reasoning)+ correction = (+ ReasoningCorrection((("reasoning",),), "max_output_tokens", None)+ if reasoning.control is ReasoningControl.PREFER_OFF+ and wire_reasoning.control is ReasoningControl.OFF+ else None+ )tool_names = OpenAIToolNameCodec.from_request(request)message_id = f"msg_{uuid.uuid4()}"return self._run_stream(body,+ reasoning_correction=correction,endpoint_context=endpoint_context,extra_headers=dict(extra_headers or {}),request_id=request_id,@@ -183,7 +212,16 @@ class OpenAIResponsesTransport:request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,+ can_disable_reasoning: bool = True,) -> JsonObject:+ request, reasoning = prepare_messages_reasoning(+ request,+ reasoning,+ model_info=model_info,+ can_disable=can_disable_reasoning,+ normal_max_tokens=None,+ )try:return self._prepare_body(cast(@@ -234,6 +272,7 @@ class OpenAIResponsesTransport:presenter_factory: ResponsesPresenterFactory,endpoint_context: EndpointContext | None = None,extra_headers: Mapping[str, str] | None = None,+ reasoning_correction: ReasoningCorrection | None = None,) -> AsyncIterator[str]:execution = self._admission.start_execution(request_id=request_id)outcome = ResponsesExecutionOutcome()@@ -244,6 +283,7 @@ class OpenAIResponsesTransport:)provider_stream = self._run_execution(body,+ reasoning_correction=reasoning_correction,request_id=request_id,response_model=response_model,presenter_factory=presenter_factory,@@ -288,6 +328,7 @@ class OpenAIResponsesTransport:outcome: ResponsesExecutionOutcome,endpoint: RequestEndpoint | None = None,extra_headers: Mapping[str, str] | None = None,+ reasoning_correction: ReasoningCorrection | None = None,) -> AsyncIterator[str]:recovery = RecoveryController()trace_event(@@ -404,6 +445,24 @@ class OpenAIResponsesTransport:):recovery.discard()continue+ if (+ scope is not None+ and reasoning_correction is not None+ and not recovery.committed+ ):+ corrected_body = reasoning_correction.retry_body(raw_error, body)+ if corrected_body is not None:+ retry = (+ execution.can_attempt+ if scope.attempt.accepted+ else await scope.attempt.correct(error)+ is ProviderCorrectionAction.RETRY+ )+ reasoning_correction = None+ if retry:+ body = corrected_body+ recovery.discard()+ continueattempt_failure = Noneif scope is not None and not scope.attempt.accepted:attempt_failure = await scope.attempt.fail(error)diff --git a/src/free_claude_code/providers/opencode/catalog.py b/src/free_claude_code/providers/opencode/catalog.pyindex 38cfcc2f..20bdae19 100644--- a/src/free_claude_code/providers/opencode/catalog.py+++ b/src/free_claude_code/providers/opencode/catalog.py@@ -10,6 +10,7 @@ import httpxfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.model_capabilities import ModelInputModality+from free_claude_code.core.reasoning import ReasoningCapabilityfrom free_claude_code.providers.admission import (ProviderAdmissionController,ProviderOperationKind,@@ -48,6 +49,19 @@ class OpenCodeModelRoute:context_window_tokens: int | Nonemax_output_tokens: int | None+ @property+ def model_info(self) -> ProviderModelInfo:+ return ProviderModelInfo(+ model_id=self.selector_id,+ supports_thinking=self.supports_thinking,+ input_modalities=self.input_modalities,+ context_window_tokens=self.context_window_tokens,+ max_output_tokens=self.max_output_tokens,+ reasoning_capability=ReasoningCapability.NONE+ if self.supports_thinking is False+ else ReasoningCapability.UNKNOWN,+ )+@dataclass(frozen=True, slots=True)class OpenCodeCatalogSnapshot:@@ -159,16 +173,7 @@ def parse_open_code_catalog(if not routes:raise _catalog_error(provider_name, "no active or beta models")- model_infos = frozenset(- ProviderModelInfo(- model_id=route.selector_id,- supports_thinking=route.supports_thinking,- input_modalities=route.input_modalities,- context_window_tokens=route.context_window_tokens,- max_output_tokens=route.max_output_tokens,- )- for route in routes.values()- )+ model_infos = frozenset(route.model_info for route in routes.values())return OpenCodeCatalogSnapshot(routes=MappingProxyType(routes),model_infos=model_infos,diff --git a/src/free_claude_code/providers/opencode/provider.py b/src/free_claude_code/providers/opencode/provider.pyindex bb00ce55..64d22bd7 100644--- a/src/free_claude_code/providers/opencode/provider.py+++ b/src/free_claude_code/providers/opencode/provider.py@@ -144,6 +144,7 @@ class OpenCodeProvider(OpenAIChatProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:"""Validate synchronously when a route snapshot is already warm."""snapshot = self._catalog.current_snapshot@@ -152,9 +153,13 @@ class OpenCodeProvider(OpenAIChatProvider):route = self._require_route(snapshot, request.model)routed = _routed_messages_request(request, route)if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_messages(routed, reasoning=reasoning)+ self._responses.preflight_messages(+ routed, reasoning=reasoning, model_info=route.model_info+ )return- super().preflight_messages(routed, reasoning=reasoning)+ super().preflight_messages(+ routed, reasoning=reasoning, model_info=route.model_info+ )def preflight_responses(self,@@ -183,6 +188,7 @@ class OpenCodeProvider(OpenAIChatProvider):reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,endpoint_context: EndpointContext | None = None,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:return self._dispatch_stream(request,@@ -211,7 +217,9 @@ class OpenCodeProvider(OpenAIChatProvider):selected_stream: AsyncIterator[str] | None = Nonetry:if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_messages(routed, reasoning=reasoning)+ self._responses.preflight_messages(+ routed, reasoning=reasoning, model_info=route.model_info+ )selected_stream = self._responses.stream_messages(routed,input_tokens=input_tokens,@@ -220,9 +228,12 @@ class OpenCodeProvider(OpenAIChatProvider):reasoning=reasoning,endpoint_context=endpoint_context,extra_headers=self._upstream_headers(request_headers or {}),+ model_info=route.model_info,)else:- super().preflight_messages(routed, reasoning=reasoning)+ super().preflight_messages(+ routed, reasoning=reasoning, model_info=route.model_info+ )selected_stream = super().stream_messages(routed,input_tokens=input_tokens,@@ -231,6 +242,7 @@ class OpenCodeProvider(OpenAIChatProvider):reasoning=reasoning,endpoint_context=endpoint_context,request_headers=request_headers,+ model_info=route.model_info,)async for event in selected_stream:yield eventdiff --git a/src/free_claude_code/providers/reasoning_compatibility.py b/src/free_claude_code/providers/reasoning_compatibility.pynew file mode 100644index 00000000..a7d34bff--- /dev/null+++ b/src/free_claude_code/providers/reasoning_compatibility.py@@ -0,0 +1,199 @@+"""Prepare tolerant computation intent without guessing backend identity."""++import json+import re+from collections.abc import Callable, Iterator, Mapping+from copy import deepcopy+from dataclasses import dataclass+from typing import Any++from free_claude_code.application.model_metadata import ProviderModelInfo+from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.diagnostics import extract_upstream_error_detail+from free_claude_code.core.reasoning import (+ ReasoningCapability,+ ReasoningControl,+ ReasoningPolicy,+)+++def prepare_messages_reasoning(+ request: MessagesRequest,+ reasoning: ReasoningPolicy,+ *,+ model_info: ProviderModelInfo | None,+ can_disable: bool,+ normal_max_tokens: int | None,+) -> tuple[MessagesRequest, ReasoningPolicy]:+ """Resolve only tolerant intent; retain original intent in execution owners."""+ if reasoning.control is not ReasoningControl.PREFER_OFF:+ return request, reasoning+ capability = (+ model_info.reasoning_capability if model_info else ReasoningCapability.UNKNOWN+ )+ disable = can_disable and capability not in {+ ReasoningCapability.NONE,+ ReasoningCapability.REQUIRED,+ }+ normal_allowance = capability not in {+ ReasoningCapability.NONE,+ ReasoningCapability.OPTIONAL,+ } or (capability is ReasoningCapability.OPTIONAL and not can_disable)+ output_config = dict(request.output_config or {})+ output_config.pop("effort", None)+ limit = request.max_tokens+ if normal_allowance:+ limit = (+ max(limit or 0, normal_max_tokens)+ if normal_max_tokens is not None+ else None+ )+ return request.model_copy(+ update={+ "thinking": None,+ "output_config": output_config or None,+ "max_tokens": limit,+ }+ ), ReasoningPolicy.off() if disable else ReasoningPolicy.provider_default()+++@dataclass(frozen=True, slots=True)+class ReasoningCorrection:+ """One request's owned OFF field and normal output allowance."""++ off_fields: tuple[tuple[str, ...], ...]+ limit_field: str+ normal_max_tokens: int | None+ output_cap: int | None = None+ provider_rejection: Callable[[Exception], bool] | None = None++ def retry_body(+ self,+ error: Exception,+ body: dict[str, Any],+ *,+ sent_body: Mapping[str, Any] | None = None,+ ) -> dict[str, Any] | None:+ """Remove the sent control only after an explicit validation rejection."""+ present = []+ for path in self.off_fields:+ target: object = body+ sent: object = body if sent_body is None else sent_body+ for key in path:+ if (+ not isinstance(target, Mapping)+ or key not in target+ or not isinstance(sent, Mapping)+ or key not in sent+ ):+ break+ target = target[key]+ sent = sent[key]+ else:+ if target == sent:+ present.append(path)+ if not present or not (+ any(_disable_rejected(error, path) for path in present)+ or (self.provider_rejection is not None and self.provider_rejection(error))+ ):+ return None+ result = deepcopy(body)+ for path in present:+ parents = []+ current = result+ for key in path[:-1]:+ parents.append((current, key))+ current = current[key]+ del current[path[-1]]+ for parent, key in reversed(parents):+ if not parent[key]:+ del parent[key]+ if self.normal_max_tokens is None:+ result.pop(self.limit_field, None)+ else:+ existing = result.get(self.limit_field)+ limit = max(+ existing if isinstance(existing, int) else 0, self.normal_max_tokens+ )+ result[self.limit_field] = (+ min(limit, self.output_cap) if self.output_cap is not None else limit+ )+ return result+++def _disable_rejected(error: Exception, field: tuple[str, ...]) -> bool:+ detail = extract_upstream_error_detail(error)+ if not detail.is_invalid_request(code=getattr(error, "code", None)):+ return False+ text = detail.body_text or detail.exception_text or ""+ try:+ payload = json.loads(text)+ except ValueError:+ payload = {"message": text}+ return reasoning_control_rejected(payload, field)+++def reasoning_control_rejected(payload: object, field: tuple[str, ...]) -> bool:+ """Match an explicit rejection tied to an owned field in an error payload."""+ return any(+ _record_rejects_control(record, field) for record in _error_records(payload)+ )+++def _error_records(payload: object) -> Iterator[Mapping[str, object]]:+ if isinstance(payload, Mapping):+ if any(+ isinstance(payload.get(key), str) for key in ("message", "msg", "detail")+ ):+ yield payload+ for key in ("error", "errors", "detail"):+ if key in payload:+ yield from _error_records(payload[key])+ elif isinstance(payload, list):+ for item in payload:+ yield from _error_records(item)+++def _record_rejects_control(+ record: Mapping[str, object], field: tuple[str, ...]+) -> bool:+ message = next(+ (+ record[key]+ for key in ("message", "msg", "detail")+ if isinstance(record.get(key), str)+ ),+ "",+ )+ text = str(message).lower()+ param = record.get("param", record.get("loc"))+ rejected = r"(?:not supported|unsupported|unknown parameter|unrecognized|extra inputs are not permitted|must be one of|not allowed|invalid value)"+ if param is not None:+ parts = re.findall(r"[a-z_][a-z_0-9]*", str(param).lower())+ while parts and parts[0] in {"body", "request", "extra_body"}:+ parts.pop(0)+ expected = [part for part in field if part != "extra_body"]+ matches = parts[: len(expected)] == expected or parts == [field[-1]]+ if not matches:+ return False+ return bool(re.search(rejected, text) or _mandatory_reasoning(text))+ if _mandatory_reasoning(text):+ return True+ name = re.escape(field[-1]) + r"(?:\.[a-z_][a-z_0-9]*)*"+ return bool(+ re.search(+ rf"\b{name}\b['\"\s:]*(?:(?:parameter|field|value)\s+)?(?:is\s+)?{rejected}"+ rf"|\b(?:unsupported|unrecognized|unknown)(?:\s+(?:parameter|field|argument))?[:\s'\"]+{name}\b"+ rf"|\bdoes not support\s+['\"]?{name}\b",+ text,+ )+ )+++def _mandatory_reasoning(text: str) -> bool:+ return bool(+ re.search(+ r"\b(?:reasoning|thinking)\s+(?:is\s+)?(?:mandatory|required|cannot be disabled|can't be disabled)\b",+ text,+ )+ )diff --git a/tests/api/model_fallback_support.py b/tests/api/model_fallback_support.pyindex d352a5c1..38d15af8 100644--- a/tests/api/model_fallback_support.py+++ b/tests/api/model_fallback_support.py@@ -8,6 +8,7 @@ from unittest.mock import patchfrom fastapi.testclient import TestClientfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.streaming import format_sse_event@@ -206,6 +207,7 @@ class ControlledFallbackProvider:request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:del reasoningself.preflight_models.append(request.model)@@ -221,6 +223,7 @@ class ControlledFallbackProvider:response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del input_tokens, request_id, reasoningself.stream_models.append(request.model)diff --git a/tests/api/test_api.py b/tests/api/test_api.pyindex b4be0ebc..a148d61c 100644--- a/tests/api/test_api.py+++ b/tests/api/test_api.py@@ -193,7 +193,7 @@ def test_auto_mode_classifier_without_stream_returns_json(client: TestClient):assert body["usage"] == {"input_tokens": 0, "output_tokens": 0}routed_request = _stream_messages_calls[0][0][0]assert routed_request.stream is False- assert _stream_messages_calls[0][1]["reasoning"] == ReasoningPolicy.off()+ assert _stream_messages_calls[0][1]["reasoning"] == ReasoningPolicy.prefer_off()def test_create_message_ingress_error_has_request_id_without_terminal_header(diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.pyindex c2dc6f50..0f6c6916 100644--- a/tests/api/test_api_handlers.py+++ b/tests/api/test_api_handlers.py@@ -52,7 +52,11 @@ class FakeProvider:]def preflight_messages(- self, request: MessagesRequest, *, reasoning: ReasoningPolicy+ self,+ request: MessagesRequest,+ *,+ reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:self.preflight_calls.append((request, reasoning))@@ -76,6 +80,7 @@ class FakeProvider:response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:self.requests.append(request)self.stream_kwargs.append(@@ -170,6 +175,7 @@ async def test_messages_handler_preflight_invalid_request_stays_http_error(request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:raise InvalidRequestError("bad tool shape")@@ -379,6 +385,7 @@ async def test_messages_handler_stream_false_provider_exception_keeps_status() -response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:self.requests.append(request)self.stream_kwargs.append(@@ -446,8 +453,8 @@ 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.stream_kwargs[0]["reasoning"] == ReasoningPolicy.off()+ assert provider.preflight_calls[0][1] == ReasoningPolicy.prefer_off()+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()assert provider.requests[0].model == "test-model"assert provider.requests[0].system == systemassert provider.preflight_calls[0][0].stop_sequences is None@@ -507,7 +514,7 @@ async def test_messages_handler_preserves_thinking_for_non_classifier() -> None:@pytest.mark.asyncio-async def test_messages_handler_keeps_existing_no_thinking_for_classifier() -> None:+async def test_messages_handler_tolerates_required_thinking_for_classifier() -> None:provider = FakeProvider()handler = MessagesHandler(Settings(), provider_resolver=lambda _: provider)request = MessagesRequest(@@ -524,8 +531,8 @@ 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.stream_kwargs[0]["reasoning"] == ReasoningPolicy.off()+ assert provider.preflight_calls[0][1] == ReasoningPolicy.prefer_off()+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()assert provider.requests[0].stop_sequences is Noneassert request.stop_sequences == ["</block>"]assert _trace_events(@@ -537,14 +544,14 @@ async def test_messages_handler_keeps_existing_no_thinking_for_classifier() -> N"source": "api","model": "claude-3-freecc-no-thinking/nvidia_nim/test-model","classifier_stop_sequence": "</block>",- "reasoning_changed": False,+ "reasoning_changed": True,"stop_sequence_removed": True,}]@pytest.mark.asyncio-async def test_messages_handler_forces_no_thinking_without_classifier_stop_hint() -> (+async def test_messages_handler_prefers_no_thinking_without_classifier_stop_hint() -> (None):provider = FakeProvider()@@ -562,7 +569,7 @@ 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.preflight_calls[0][1] == ReasoningPolicy.prefer_off()assert provider.requests[0].stop_sequences is Noneassert _trace_events(trace_mock, "free_claude_code.api.route.safety_classifier_policy"@@ -597,7 +604,7 @@ 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][1] == ReasoningPolicy.prefer_off()assert provider.preflight_calls[0][0].stop_sequences == ["custom","custom",diff --git a/tests/api/test_classifier_provider_compatibility.py b/tests/api/test_classifier_provider_compatibility.pynew file mode 100644index 00000000..24c71d05--- /dev/null+++ b/tests/api/test_classifier_provider_compatibility.py@@ -0,0 +1,300 @@+"""Claude Auto mode exercises the real handler/provider request boundary."""++import json+from types import SimpleNamespace+from unittest.mock import AsyncMock, patch++import httpx2 as httpx+import pytest+from fastapi.responses import JSONResponse, StreamingResponse+from openai import APIError, AsyncOpenAI, BadRequestError++from free_claude_code.api.handlers import MessagesHandler+from free_claude_code.application.model_metadata import ProviderModelInfo+from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+from free_claude_code.config.settings import Settings+from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.anthropic.stream_contracts import (+ parse_sse_text,+ text_content,+ thinking_content,+)+from free_claude_code.core.reasoning import ReasoningCapability+from free_claude_code.providers.open_router import OpenRouterProvider+from tests.providers.support import immediate_admission, make_provider_config+++class ClassifierStream:+ def __init__(self, *, starved: bool = False, error: Exception | None = None):+ self.starved = starved+ self.error = error+ self.closed = False++ async def __aiter__(self):+ if self.error is not None:+ raise self.error+ for text, reasoning, finish in (+ (None, "Internal provider analysis", None),+ (None if self.starved else "<severity>0</severity>", None, None),+ (None, None, "length" if self.starved else "stop"),+ ):+ yield SimpleNamespace(+ choices=[+ SimpleNamespace(+ delta=SimpleNamespace(+ content=text,+ reasoning=reasoning,+ reasoning_content=reasoning,+ tool_calls=None,+ ),+ finish_reason=finish,+ )+ ],+ usage=None,+ )++ async def aclose(self):+ self.closed = True+++def classifier_request():+ return MessagesRequest.model_validate(+ {+ "model": "open_router/dynamic-route",+ "system": "Output <severity>N</severity> for this command's safety.",+ "messages": [+ {+ "role": "user",+ "content": "<transcript>Read the requested file.</transcript>",+ }+ ],+ "max_tokens": 64,+ "thinking": {"type": "disabled"},+ "stop_sequences": ["</severity>"],+ "stream": False,+ }+ )+++ ("error", "corrects"),+ [+ ({"code": 400, "message": "Reasoning cannot be disabled."}, True),+ (+ {+ "code": 400,+ "message": "Reasoning cannot be disabled.",+ "metadata": {"error_type": "invalid_request"},+ },+ True,+ ),+ ({"code": 400, "message": "Messages contain an invalid role."}, False),+ (+ {"code": 400, "param": "tools", "message": "Reasoning is required."},+ False,+ ),+ ({"code": 403, "message": "Reasoning cannot be disabled."}, False),+ ],+ ids=["numeric", "metadata", "unrelated", "other-field", "permission"],+)+async def test_openrouter_numeric_sse_rejection_uses_classifier_correction(+ error, corrects+):+ bodies = []++ def upstream(request):+ bodies.append(json.loads(request.content))+ chunk = {+ "id": "gen-test",+ "object": "chat.completion.chunk",+ "created": 1,+ "model": "dynamic-route",+ "provider": "test",+ "choices": [+ {+ "index": 0,+ "delta": {"content": "<severity>0</severity>"},+ "finish_reason": "stop",+ }+ ],+ }+ if len(bodies) == 1:+ chunk["error"] = error+ chunk["choices"] = [+ {"index": 0, "delta": {"content": ""}, "finish_reason": "error"}+ ]+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=f"data: {json.dumps(chunk)}\n\ndata: [DONE]\n\n",+ )++ provider = OpenRouterProvider(+ make_provider_config("test", "https://provider.invalid/v1"),+ admission=immediate_admission(),+ )+ try:+ async with AsyncOpenAI(+ api_key="test",+ base_url="https://provider.invalid/v1",+ max_retries=0,+ http_client=httpx.AsyncClient(transport=httpx.MockTransport(upstream)),+ ) as client:+ with patch.object(provider, "_client", client):+ response = await MessagesHandler(+ Settings(), provider_resolver=lambda _: provider+ ).create(classifier_request())+ assert isinstance(response, JSONResponse)+ assert len(bodies) == (2 if corrects else 1)+ if corrects:+ assert response.status_code == 200+ assert json.loads(bytes(response.body))["content"] == [+ {"type": "text", "text": "<severity>0</severity>"}+ ]+ assert bodies[0]["reasoning"] == {"enabled": False}+ assert "reasoning" not in bodies[1]+ assert bodies[1]["max_tokens"] == 81920+ else:+ assert response.status_code >= 400+ finally:+ await provider.cleanup()++[email protected]("stream", [False, True])+ "reject_off",+ [False, True, "stream"],+ ids=["off-ignored", "off-rejected", "off-stream-rejected"],+)+async def test_classifier_mandatory_reasoning_still_returns_verdict(reject_off, stream):+ provider = OpenRouterProvider(+ make_provider_config(api_key="test", base_url="https://openrouter.test/v1"),+ admission=immediate_admission(),+ )+ bodies = []+ streams = []++ async def upstream(**body):+ bodies.append(body)+ if (+ reject_off+ and body.get("extra_body", {}).get("reasoning", {}).get("enabled") is False+ ):+ error = {+ "error": {+ "code": "invalid_request_error",+ "message": "Reasoning is mandatory for this endpoint and cannot be disabled.",+ }+ }+ if reject_off == "stream":+ rejected = ClassifierStream(+ error=APIError(+ error["error"]["message"],+ request=httpx.Request(+ "POST", "https://openrouter.test/v1/chat/completions"+ ),+ body=error["error"],+ )+ )+ streams.append(rejected)+ return rejected+ raise BadRequestError(+ error["error"]["message"],+ response=httpx.Response(+ 400,+ request=httpx.Request(+ "POST", "https://openrouter.test/v1/chat/completions"+ ),+ json=error,+ ),+ body=error,+ )+ result = ClassifierStream(starved=body.get("max_tokens", 0) < 2048)+ streams.append(result)+ return result++ try:+ handler = MessagesHandler(Settings(), provider_resolver=lambda _: provider)+ with patch.object(+ provider._client.chat.completions,+ "create",+ new=AsyncMock(side_effect=upstream),+ ):+ response = await handler.create(+ classifier_request().model_copy(update={"stream": stream})+ )+ assert isinstance(response, (JSONResponse, StreamingResponse))+ assert response.status_code == 200+ if stream:+ assert isinstance(response, StreamingResponse)+ raw = "".join([str(chunk) async for chunk in response.body_iterator])+ events = parse_sse_text(raw)+ assert text_content(events) == "<severity>0</severity>"+ assert thinking_content(events) == ""+ assert events[-1].event == "message_stop"+ else:+ assert isinstance(response, JSONResponse)+ message = json.loads(bytes(response.body))+ assert message["content"] == [+ {"type": "text", "text": "<severity>0</severity>"}+ ]+ assert message["stop_reason"] == "end_turn"+ assert bodies[0]["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+ assert len(bodies) == (2 if reject_off else 1)+ assert all(stream.closed for stream in streams)+ finally:+ await provider.cleanup()+++ ("capability", "off", "limit"),+ [+ ("none", False, 64),+ ("optional", True, 64),+ ("required", False, 81920),+ ("unknown", True, 81920),+ ],+)+async def test_handler_uses_cached_capabilities_for_the_selected_provider(+ capability, off, limit+):+ provider = OpenRouterProvider(+ make_provider_config("test", "https://provider.invalid/v1"),+ admission=immediate_admission(),+ )+ bodies = []++ async def upstream(**body):+ bodies.append(body)+ return ClassifierStream()++ try:+ handler = MessagesHandler(+ Settings(),+ provider_resolver=lambda _: provider,+ model_infos=(+ ProviderModelInfo(+ "open_router/dynamic-route",+ reasoning_capability=ReasoningCapability(capability),+ ),+ ),+ )+ with patch.object(+ provider._client.chat.completions,+ "create",+ new=AsyncMock(side_effect=upstream),+ ):+ response = await handler.create(classifier_request())+ assert isinstance(response, JSONResponse) and response.status_code == 200+ assert json.loads(bytes(response.body))["content"] == [+ {"type": "text", "text": "<severity>0</severity>"}+ ]+ assert (+ bodies[0].get("extra_body", {}).get("reasoning", {}).get("enabled") is False+ ) is off+ assert bodies[0]["max_tokens"] == limit+ finally:+ await provider.cleanup()diff --git a/tests/api/test_classifier_response.py b/tests/api/test_classifier_response.pynew file mode 100644index 00000000..fa5cd318--- /dev/null+++ b/tests/api/test_classifier_response.py@@ -0,0 +1,207 @@+import asyncio+import json++import pytest++from free_claude_code.api.handlers.classifier_response import classifier_response+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.anthropic.streaming import format_sse_event+++def wire(payloads):+ return "".join(format_sse_event(payload["type"], payload) for payload in payloads)++[email protected]("chunk_size", [1, 17, 10000])+async def test_projection_preserves_text_extensions_and_sparse_interleaved_blocks(+ chunk_size,+):+ literal = "<thinking>Classifier explanation</thinking><severity>0</severity>"+ start = {+ "type": "message_start",+ "message": {+ "id": "original",+ "model": "public",+ "content": [],+ "usage": {"input_tokens": 3},+ },+ "extension": {"a": 1},+ }+ terminal = {+ "type": "message_delta",+ "delta": {"stop_reason": "stop_sequence", "stop_sequence": "custom"},+ "usage": {"output_tokens": 50, "extra": 7},+ }+ payloads = [+ start,+ {+ "type": "content_block_start",+ "index": 5,+ "content_block": {"type": "thinking", "thinking": "hidden"},+ },+ {+ "type": "content_block_start",+ "index": 9,+ "content_block": {+ "type": "text",+ "text": literal,+ "citations": [],+ "extension": {"index": 9},+ },+ },+ {+ "type": "content_block_delta",+ "index": 5,+ "delta": {"type": "signature_delta", "signature": "hidden"},+ },+ {+ "type": "content_block_delta",+ "index": 9,+ "delta": {+ "type": "text_delta",+ "text": "<reason>fine</reason><category>read</category>",+ },+ },+ {"type": "content_block_stop", "index": 5},+ {+ "type": "content_block_start",+ "index": 12,+ "content_block": {"type": "redacted_thinking", "data": "opaque"},+ },+ {"type": "content_block_stop", "index": 12},+ {+ "type": "content_block_start",+ "index": 3,+ "content_block": {+ "type": "tool_use",+ "id": "tool-id",+ "name": "read",+ "input": {},+ },+ },+ {"type": "content_block_stop", "index": 9},+ {"type": "content_block_stop", "index": 3},+ {"type": "ping", "extension": 1},+ terminal,+ {"type": "message_stop"},+ ]+ raw = wire(payloads)+ closed = False++ async def source():+ nonlocal closed+ try:+ for offset in range(0, len(raw), chunk_size):+ yield raw[offset : offset + chunk_size]+ finally:+ closed = True++ output = "".join([chunk async for chunk in classifier_response(source())])+ actual = [event.data for event in parse_sse_text(output)]+ assert actual == [+ start,+ {**payloads[2], "index": 0},+ {**payloads[4], "index": 0},+ {**payloads[8], "index": 1},+ {**payloads[9], "index": 0},+ {**payloads[10], "index": 1},+ payloads[11],+ terminal,+ payloads[13],+ ]+ assert closed+++async def test_reasoning_only_completion_stays_empty_with_original_termination():+ start = {"type": "message_start", "message": {"content": []}}+ end = {+ "type": "message_delta",+ "delta": {"stop_reason": "max_tokens"},+ "usage": {"output_tokens": 64},+ }++ async def source():+ yield wire(+ [+ start,+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "thinking", "thinking": "analysis"},+ },+ {"type": "content_block_stop", "index": 0},+ end,+ {"type": "message_stop"},+ ]+ )++ output = [+ event.data+ for event in parse_sse_text(+ "".join([chunk async for chunk in classifier_response(source())])+ )+ ]+ assert output == [start, end, {"type": "message_stop"}]+++async def test_cancellation_during_hidden_reasoning_closes_input():+ blocked = asyncio.Event()+ closed = asyncio.Event()++ async def source():+ try:+ yield wire([{"type": "message_start", "message": {"content": []}}])+ yield wire(+ [+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "thinking", "thinking": ""},+ }+ ]+ )+ blocked.set()+ await asyncio.Event().wait()+ finally:+ closed.set()++ filtered = classifier_response(source())+ assert "message_start" in await anext(filtered)++ async def advance():+ return await anext(filtered)++ pending = asyncio.create_task(advance())+ await asyncio.wait_for(blocked.wait(), 1)+ pending.cancel()+ with pytest.raises(asyncio.CancelledError):+ await pending+ assert closed.is_set()++[email protected]("fails", [False, True])+async def test_only_normal_exhaustion_flushes_unterminated_event(fails):+ failure = RuntimeError("upstream failed")+ raw = "event: error\ndata: " + json.dumps(+ {"type": "error", "error": {"message": "unchanged"}}+ )++ async def source():+ yield raw+ if fails:+ raise failure++ if fails:+ with pytest.raises(RuntimeError) as caught:+ _ = [chunk async for chunk in classifier_response(source())]+ assert caught.value is failure+ else:+ output = "".join([chunk async for chunk in classifier_response(source())])+ assert parse_sse_text(output)[0].data == {+ "type": "error",+ "error": {"message": "unchanged"},+ }diff --git a/tests/api/test_execution_failure_contract.py b/tests/api/test_execution_failure_contract.pyindex 92451fa0..005761da 100644--- a/tests/api/test_execution_failure_contract.py+++ b/tests/api/test_execution_failure_contract.py@@ -9,6 +9,7 @@ from unittest.mock import MagicMock, patchimport pytestfrom fastapi.testclient import TestClient+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text@@ -106,6 +107,7 @@ class StalledProvider:_request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:del reasoning@@ -126,6 +128,7 @@ class StalledProvider:response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del input_tokens, request_id, response_model, reasoningtry:diff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.pyindex 67aaa7fc..72786123 100644--- a/tests/api/test_request_lifetime.py+++ b/tests/api/test_request_lifetime.py@@ -398,6 +398,7 @@ class _ControlledProvider:_request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:del reasoning@@ -418,6 +419,7 @@ class _ControlledProvider:response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del input_tokens, response_model, reasoningself.request_ids.append(request_id)@@ -478,7 +480,7 @@ class _Requests:async def acquire(self, *, include_model_infos: bool = False) -> RequestRuntimeLease:- assert include_model_infos is False+ del include_model_infosreturn self._leasedef current_settings(self) -> Settings:diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.pyindex 2221325d..8b43be78 100644--- a/tests/api/test_web_server_tools.py+++ b/tests/api/test_web_server_tools.py@@ -29,6 +29,7 @@ from free_claude_code.api.web_tools.request import ()from free_claude_code.api.web_tools.streaming import stream_web_server_tool_responsefrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.application.routing import (ModelRouter,ProviderModelTarget,@@ -128,7 +129,11 @@ class ScriptedSelectionProvider:self.close_count = 0def preflight_messages(- self, request: MessagesRequest, *, reasoning: ReasoningPolicy+ self,+ request: MessagesRequest,+ *,+ reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:return None@@ -162,6 +167,7 @@ class ScriptedSelectionProvider:response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:self.requests.append(request)self.stream_kwargs.append(diff --git a/tests/application/test_chat_service.py b/tests/application/test_chat_service.pyindex 31b0c593..c5a26e82 100644--- a/tests/application/test_chat_service.py+++ b/tests/application/test_chat_service.py@@ -212,6 +212,7 @@ class FakeChatProvider:request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:del reasoningself.requests.append(request)@@ -233,6 +234,7 @@ class FakeChatProvider:response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del input_tokens, request_id, response_model, reasoningtext = "summary" if str(request.system).startswith("Summarize") else "answer"@@ -344,6 +346,7 @@ class ContextRecoveryProvider(FakeChatProvider):response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:is_summary = str(request.system).startswith("Summarize")if is_summary:@@ -405,6 +408,7 @@ class MixedFallbackFailureProvider(ContextRecoveryProvider):response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:if self.fail_candidates and not str(request.system).startswith("Summarize"):if request.model == "model":@@ -437,6 +441,7 @@ class BackpressuredCompletionProvider(FakeChatProvider):response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del request, input_tokens, request_id, response_model, reasoningyield format_sse_event(diff --git a/tests/application/test_execution.py b/tests/application/test_execution.pyindex 3d34d158..2a2ab696 100644--- a/tests/application/test_execution.py+++ b/tests/application/test_execution.py@@ -8,6 +8,7 @@ import pytestfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.execution import ProviderExecutor+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.application.routing import (ProviderModelTarget,ResolvedModelRoute,@@ -19,7 +20,7 @@ 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, FailureKindfrom free_claude_code.core.openai_responses import OpenAIResponsesRequest-from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.core.reasoning import ReasoningCapability, ReasoningPolicyclass FakeProvider:@@ -33,6 +34,7 @@ class FakeProvider:request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:self.preflight_calls.append((request, reasoning))@@ -53,6 +55,7 @@ class FakeProvider:response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:self._record_stream_call(request,@@ -118,6 +121,7 @@ class ResponsesFakeProvider:request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:raise AssertionError("Responses test provider received a Messages request")@@ -130,6 +134,7 @@ class ResponsesFakeProvider:response_model: str,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:raise AssertionError("Responses test provider received a Messages request")yield ""@@ -194,6 +199,7 @@ class ControlledProvider(FakeProvider):response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:self._record_stream_call(request,@@ -226,6 +232,7 @@ class FailingPreflightProvider(FakeProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:raise ValueError("invalid provider request")@@ -240,6 +247,7 @@ class ApplicationErrorPreflightProvider(FakeProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:raise self._error@@ -254,6 +262,7 @@ class ExecutionFailurePreflightProvider(FakeProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy,+ model_info: ProviderModelInfo | None = None,) -> None:super().preflight_messages(request, reasoning=reasoning)raise self._failure@@ -269,6 +278,7 @@ class FailingStreamConstructionProvider(FakeProvider):response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:raise RuntimeError("stream construction failed")@@ -287,6 +297,7 @@ class ExecutionFailureStreamConstructionProvider(FakeProvider):response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del request, input_tokens, request_id, response_model, reasoningraise self._failure@@ -315,6 +326,7 @@ class CloseControlledProvider(FakeProvider):response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:self._record_stream_call(request,@@ -369,6 +381,52 @@ def _routed_request()+async def test_fallback_receives_its_own_cached_capability_in_preflight_and_stream():+ seen = []++ class MetadataProvider(ControlledProvider):+ def preflight_messages(self, request, **kwargs):+ seen.append(("preflight", request.model, kwargs["model_info"]))++ async def stream_messages(self, request, input_tokens=0, **kwargs):+ seen.append(("stream", request.model, kwargs["model_info"]))+ async for event in super().stream_messages(request, input_tokens, **kwargs):+ yield event++ primary_info = ProviderModelInfo(+ "provider/provider-model", reasoning_capability=ReasoningCapability.NONE+ )+ fallback_info = ProviderModelInfo(+ "fallback/fallback-model", reasoning_capability=ReasoningCapability.REQUIRED+ )+ primary = MetadataProvider(+ [ExecutionFailure(FailureKind.UNAVAILABLE, 503, "unavailable", True)]+ )+ fallback = MetadataProvider(["verdict"])+ providers = {"provider": primary, "fallback": fallback}+ executor = ProviderExecutor(+ lambda name: providers[name],+ progress_timeout_seconds=10,+ model_infos=(primary_info, fallback_info),+ )+ output = [+ event+ async for event in executor.stream_messages(+ _routed_request(_target("fallback", "fallback-model")),+ raw_log_payload={},+ request_id="capability-fallback",+ )+ ]+ assert output == ["verdict"]+ assert seen == [+ ("preflight", "provider-model", primary_info),+ ("stream", "provider-model", primary_info),+ ("preflight", "fallback-model", fallback_info),+ ("stream", "fallback-model", fallback_info),+ ]++def _routed_responses_request(*fallbacks: ProviderModelTarget,) -> RoutedResponsesRequest:@@ -924,6 +982,7 @@ async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:response_model: str | None = None,reasoning: ReasoningPolicy,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:request.messages[0].content = "mutated"async for chunk in super().stream_messages(diff --git a/tests/providers/test_anthropic_messages_transport.py b/tests/providers/test_anthropic_messages_transport.pyindex 0a7ba49a..ae8b82fd 100644--- a/tests/providers/test_anthropic_messages_transport.py+++ b/tests/providers/test_anthropic_messages_transport.py@@ -13,6 +13,7 @@ from free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.json_types import JsonObjectfrom free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.anthropic_messages.transport import (AnthropicMessagesTransport,@@ -22,6 +23,70 @@ from free_claude_code.providers.http import maybe_await_aclosefrom tests.providers.support import immediate_admission[email protected]("stream_error", [False, True])+ "error",+ [+ {+ "type": "invalid_request_error",+ "message": "Reasoning is mandatory and cannot be disabled.",+ },+ {+ "type": "invalid_request_error",+ "param": "thinking.type",+ "message": "Value 'disabled' is not supported",+ },+ {+ "type": "invalid_request_error",+ "loc": ["body", "thinking", "type"],+ "message": "Value 'disabled' is not supported",+ },+ ],+ ids=["mandatory", "param", "loc"],+)+async def test_tolerant_classifier_corrects_required_reasoning(stream_error, error):+ bodies = []++ def handler(request):+ body = json.loads(request.content)+ bodies.append(body)+ if body.get("thinking", {}).get("type") == "disabled":+ if stream_error:+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=Wire([_sse({"type": "error", "error": error})]),+ )+ return httpx.Response(400, json={"error": error})+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=Wire([_sse(*_events("<severity>0</severity>"))]),+ )++ async with httpx.AsyncClient(transport=httpx.MockTransport(handler)) as client:+ output = [+ event+ async for event in _transport(client).stream_messages(+ MessagesRequest.model_validate(+ {+ "model": "route",+ "messages": [{"role": "user", "content": "classify"}],+ "max_tokens": 64,+ "thinking": {"type": "disabled"},+ }+ ),+ endpoint_context=Endpoint(),+ reasoning=ReasoningPolicy.prefer_off(),+ )+ ]+ assert "<severity>0</severity>" in "".join(output)+ assert len(bodies) == 2+ assert bodies[0]["max_tokens"] == 8192+ assert "thinking" not in bodies[1]++class Endpoint:def __init__(self) -> None:self.refreshes: list[bool] = []diff --git a/tests/providers/test_deepinfra.py b/tests/providers/test_deepinfra.pyindex 5d4160f9..8fd3700c 100644--- a/tests/providers/test_deepinfra.py+++ b/tests/providers/test_deepinfra.py@@ -13,7 +13,11 @@ from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENSfrom free_claude_code.config.provider_catalog import DEEPINFRA_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.core.reasoning import (+ ReasoningCapability,+ ReasoningEffort,+ ReasoningPolicy,+)from free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.support import (@@ -245,7 +249,11 @@ async def test_lists_only_active_text_models_with_thinking_metadata(assert model_infos == frozenset({ProviderModelInfo("reasoning-model", supports_thinking=True),- ProviderModelInfo("plain-model", supports_thinking=False),+ ProviderModelInfo(+ "plain-model",+ supports_thinking=False,+ reasoning_capability=ReasoningCapability.NONE,+ ),ProviderModelInfo("hybrid-model", supports_thinking=True),ProviderModelInfo("unknown-model"),}diff --git a/tests/providers/test_github_copilot_provider.py b/tests/providers/test_github_copilot_provider.pyindex 5219a5d4..f3d25959 100644--- a/tests/providers/test_github_copilot_provider.py+++ b/tests/providers/test_github_copilot_provider.py@@ -29,6 +29,7 @@ from free_claude_code.core.openai_responses.reasoning_replay import ()from free_claude_code.core.reasoning import (DEFAULT_REASONING_POLICY,+ ReasoningCapability,ReasoningEffort,ReasoningPolicy,)@@ -246,6 +247,66 @@ class Harness:await self.auth.close()[email protected]("egress", list(CopilotEgress))[email protected]("supports_off", [False, True])+async def test_classifier_uses_current_lease_controls_and_clears_raw_hints(+ tmp_path, egress, supports_off+):+ harness = Harness(tmp_path, egress)+ current = harness.runtime.available[0]+ efforts = ("none", "high") if supports_off else ("high",)+ harness.runtime.available = (+ replace(+ current,+ supported_efforts=efforts,+ info=replace(+ current.info,+ reasoning_capability=ReasoningCapability.OPTIONAL+ if supports_off+ else ReasoningCapability.UNKNOWN,+ ),+ ),+ )+ request = MessagesRequest.model_validate(+ {+ "model": harness.runtime.name,+ "messages": [{"role": "user", "content": "classify"}],+ "max_tokens": 64,+ "thinking": {"type": "enabled", "budget_tokens": 1024},+ "output_config": {"effort": "xhigh"},+ }+ )+ try:+ output = [+ event+ async for event in harness.provider.stream_messages(+ request,+ reasoning=ReasoningPolicy.prefer_off(),+ model_info=ProviderModelInfo(+ harness.runtime.name, reasoning_capability=ReasoningCapability.NONE+ ),+ )+ ]+ assert text_content(parse_sse_text("".join(output))) == "ok"+ body = json.loads(harness.seen[0].content)+ if egress is CopilotEgress.MESSAGES:+ assert body["thinking"] == {"type": "disabled"}+ assert body["max_tokens"] == (64 if supports_off else 4096)+ elif egress is CopilotEgress.RESPONSES:+ assert body.get("reasoning") == (+ {"effort": "none"} if supports_off else None+ )+ assert body.get("max_output_tokens") == (64 if supports_off else None)+ else:+ assert body.get("reasoning_effort") == ("none" if supports_off else None)+ assert body.get("max_tokens") == (64 if supports_off else None)+ assert request.thinking is not None and request.thinking.budget_tokens == 1024+ assert all(wire.closed for wire in harness.wires)+ finally:+ await harness.close()++def _request(responses: bool, model: str, *, history: bool = False) -> MessagesRequest | OpenAIResponsesRequest:diff --git a/tests/providers/test_groq_reasoning.py b/tests/providers/test_groq_reasoning.pyindex 6d359ac0..8095845e 100644--- a/tests/providers/test_groq_reasoning.py+++ b/tests/providers/test_groq_reasoning.py@@ -8,9 +8,17 @@ import httpx2import openaiimport pytest+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import GROQ_DEFAULT_BASE-from free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.core.anthropic.stream_contracts import (+ parse_sse_text,+ text_content,+)+from free_claude_code.core.reasoning import (+ ReasoningCapability,+ ReasoningEffort,+ ReasoningPolicy,+)from free_claude_code.providers.admission import ProviderOperationKindfrom free_claude_code.providers.groq import GroqProviderfrom free_claude_code.providers.groq.client import (@@ -91,6 +99,61 @@ async def _successful_stream(text: str = "visible"):yield _chunk(finish_reason="stop")+ "message",+ [+ "`reasoning_effort` must be one of `default`",+ "reasoning_effort value `none` must be one of `default`",+ "accepted options for reasoning_effort include default",+ ],+)+async def test_classifier_correction_does_not_change_later_requests(message):+ provider = _provider()+ sent = []++ async def create(**body):+ sent.append(body)+ if len(sent) == 1:+ raise _BadRequest(message, body={"message": message})+ return _successful_stream("<severity>0</severity>")++ try:+ with patch.object(provider._client.chat.completions, "create", create):+ classifier = "".join(+ [+ event+ async for event in provider.stream_messages(+ make_messages_request(_MODEL, max_tokens=64),+ reasoning=ReasoningPolicy.prefer_off(),+ model_info=ProviderModelInfo(+ _MODEL, reasoning_capability=ReasoningCapability.OPTIONAL+ ),+ )+ ]+ )+ ordinary = "".join(+ [+ event+ async for event in provider.stream_messages(+ _request(),+ reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),+ )+ ]+ )+ finally:+ await provider.cleanup()++ assert text_content(parse_sse_text(classifier)) == "<severity>0</severity>"+ assert text_content(parse_sse_text(ordinary)) == "<severity>0</severity>"+ assert len(sent) == 3+ assert sent[2]["reasoning_effort"] == "high"+ assert sent[0]["reasoning_effort"] == "none"+ assert sent[0]["max_completion_tokens"] == 64+ assert "reasoning_effort" not in sent[1]+ assert "max_completion_tokens" not in sent[1]++def test_parse_exact_issue_vocabulary_excludes_rejected_value() -> None:error = _BadRequest(_ISSUE_MESSAGE,@@ -346,7 +409,7 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:create = AsyncMock(side_effect=[_vocabulary_error(), object()])with patch.object(provider._client.chat.completions, "create", create):- _stream, used_body, attempt = await provider._create_stream(+ _stream, used_body, attempt, _sent_body = await provider._create_stream(body,provider._admission.start_execution(),ProviderOperationKind.GENERATION,@@ -365,7 +428,12 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:assert next_body["reasoning_effort"] == "default"next_create = AsyncMock(return_value=object())with patch.object(provider._client.chat.completions, "create", next_create):- _stream, next_used_body, next_attempt = await provider._create_stream(+ (+ _stream,+ next_used_body,+ next_attempt,+ _sent_body,+ ) = await provider._create_stream(next_body,provider._admission.start_execution(),ProviderOperationKind.GENERATION,@@ -435,7 +503,7 @@ async def test_unknown_vocabulary_retries_without_effort_and_negative_caches() -)with patch.object(provider._client.chat.completions, "create", create):- _stream, used_body, attempt = await provider._create_stream(+ _stream, used_body, attempt, _sent_body = await provider._create_stream(body,provider._admission.start_execution(),ProviderOperationKind.GENERATION,@@ -490,7 +558,7 @@ async def test_concurrent_first_requests_can_learn_without_state_corruption() ->return object()async def execute(body: dict):- _stream, used_body, attempt = await provider._create_stream(+ _stream, used_body, attempt, _sent_body = await provider._create_stream(body,provider._admission.start_execution(),ProviderOperationKind.GENERATION,@@ -526,7 +594,7 @@ async def test_stale_cache_self_heals_without_guessing_original_effort() -> None)with patch.object(provider._client.chat.completions, "create", create):- _stream, corrected_body, attempt = await provider._create_stream(+ _stream, corrected_body, attempt, _sent_body = await provider._create_stream(cached_body,provider._admission.start_execution(),ProviderOperationKind.GENERATION,@@ -657,7 +725,7 @@ async def test_output_cap_and_reasoning_corrections_share_one_session() -> None:execution = provider._admission.start_execution()with patch.object(provider._client.chat.completions, "create", create):- _stream, used_body, attempt = await provider._create_stream(+ _stream, used_body, attempt, _sent_body = await provider._create_stream(body,execution,ProviderOperationKind.GENERATION,diff --git a/tests/providers/test_groq_tpm.py b/tests/providers/test_groq_tpm.pyindex 34791b0c..465a8b03 100644--- a/tests/providers/test_groq_tpm.py+++ b/tests/providers/test_groq_tpm.py@@ -308,7 +308,7 @@ async def test_tpm_and_reasoning_corrections_compose(execution = provider._admission.start_execution()with patch.object(provider._client.chat.completions, "create", create):- _stream, accepted_body, attempt = await provider._create_stream(+ _stream, accepted_body, attempt, _sent_body = await provider._create_stream(body,execution,ProviderOperationKind.GENERATION,@@ -331,14 +331,19 @@ async def test_distinct_bodies_get_independent_tpm_corrections() -> None:create = AsyncMock(side_effect=[_status_error(), object(), second_error, object()])with patch.object(provider._client.chat.completions, "create", create):- _stream, first_body, first_attempt = await provider._create_stream(+ _stream, first_body, first_attempt, _sent_body = await provider._create_stream(_body(),execution,ProviderOperationKind.CONTINUATION,)await first_attempt.accept()await first_attempt.aclose()- _stream, second_body, second_attempt = await provider._create_stream(+ (+ _stream,+ second_body,+ second_attempt,+ _sent_body,+ ) = await provider._create_stream(_body(20_000),execution,ProviderOperationKind.TOOL_REPAIR,diff --git a/tests/providers/test_llm7.py b/tests/providers/test_llm7.pyindex 48da2fd7..8c73eed8 100644--- a/tests/providers/test_llm7.py+++ b/tests/providers/test_llm7.py@@ -12,7 +12,7 @@ from free_claude_code.config.provider_catalog import LLM7_DEFAULT_BASEfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.json_types import JsonObject, JsonValuefrom free_claude_code.core.model_capabilities import ModelInputModality-from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.core.reasoning import ReasoningCapability, ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.support import (@@ -218,6 +218,7 @@ async def test_filters_catalog_and_adds_live_authoritative_selectors(ProviderModelInfo("plain-model",supports_thinking=False,+ reasoning_capability=ReasoningCapability.NONE,input_modalities=frozenset({ModelInputModality.TEXT}),),ProviderModelInfo(diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex 41ae4d5e..903a40f9 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -119,8 +119,9 @@ def test_preflight_builds_before_context_budget_and_preserves_policy(request = make_request()calls: list[tuple[str, object]] = []- def build(request_arg, *, reasoning):+ def build(request_arg, *, reasoning, model_info):assert request_arg is request+ assert model_info is Nonecalls.append(("build", reasoning))return {}diff --git a/tests/providers/test_model_discovery.py b/tests/providers/test_model_discovery.pyindex 6af00ea5..0727a632 100644--- a/tests/providers/test_model_discovery.py+++ b/tests/providers/test_model_discovery.py@@ -359,6 +359,7 @@ class FakeProvider(BaseProvider):request: Any,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:return None@@ -395,6 +396,7 @@ class FakeProvider(BaseProvider):response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:if False:yield ""diff --git a/tests/providers/test_nararoute.py b/tests/providers/test_nararoute.pyindex 533604d0..b7d1b5b9 100644--- a/tests/providers/test_nararoute.py+++ b/tests/providers/test_nararoute.py@@ -7,6 +7,7 @@ import pytestfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import NARAROUTE_DEFAULT_BASE+from free_claude_code.core.reasoning import ReasoningCapabilityfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -44,7 +45,11 @@ async def test_model_catalog_extracts_strict_optional_reasoning_boolean() -> Nonassert infos == frozenset({ProviderModelInfo("reasoning", supports_thinking=True),- ProviderModelInfo("plain", supports_thinking=False),+ ProviderModelInfo(+ "plain",+ supports_thinking=False,+ reasoning_capability=ReasoningCapability.NONE,+ ),ProviderModelInfo("unknown"),ProviderModelInfo("malformed"),}diff --git a/tests/providers/test_openai_chat_output_cap.py b/tests/providers/test_openai_chat_output_cap.pyindex 16032f3e..684152b3 100644--- a/tests/providers/test_openai_chat_output_cap.py+++ b/tests/providers/test_openai_chat_output_cap.py@@ -265,7 +265,7 @@ async def test_create_stream_clamps_and_learns_on_cap_rejection(groq_provider):create = AsyncMock(side_effect=[error, object()])with patch.object(groq_provider._client.chat.completions, "create", create):- _stream, used_body, attempt = await groq_provider._create_stream(+ _stream, used_body, attempt, _sent_body = await groq_provider._create_stream(body,groq_provider._admission.start_execution(),ProviderOperationKind.GENERATION,@@ -292,7 +292,7 @@ async def test_learned_cap_clamps_next_request_without_a_400(groq_provider):create = AsyncMock(return_value=object())with patch.object(groq_provider._client.chat.completions, "create", create):- _stream, used_body, attempt = await groq_provider._create_stream(+ _stream, used_body, attempt, _sent_body = await groq_provider._create_stream(body,groq_provider._admission.start_execution(),ProviderOperationKind.GENERATION,diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.pyindex ee64986c..f94a20c5 100644--- a/tests/providers/test_openai_chat_usage.py+++ b/tests/providers/test_openai_chat_usage.py@@ -9,6 +9,7 @@ import pytestfrom httpx2 import Request, Responsefrom openai.types.completion_usage import CompletionUsage, PromptTokensDetails+from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.sse_aggregation import (@@ -61,6 +62,7 @@ class _UsageTestProvider(OpenAIChatProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> dict:return {"model": request.model, "messages": [{"role": "user", "content": "x"}]}@@ -533,7 +535,7 @@ async def test_openai_chat_stream_retries_without_usage_when_option_is_rejected()with patch.object(provider._client.chat.completions, "create", create):- _stream_obj, used_body, attempt = await provider._create_stream(+ _stream_obj, used_body, attempt, _sent_body = await provider._create_stream(body,provider._admission.start_execution(),ProviderOperationKind.GENERATION,diff --git a/tests/providers/test_openai_responses_transport.py b/tests/providers/test_openai_responses_transport.pyindex 62e3c876..93afe39e 100644--- a/tests/providers/test_openai_responses_transport.py+++ b/tests/providers/test_openai_responses_transport.py@@ -26,6 +26,64 @@ from free_claude_code.providers.openai_responses import OpenAIResponsesTransportfrom tests.providers.support import REASONING_ON, immediate_admission[email protected]("stream_error", [False, True])+ "error",+ [+ {+ "code": "invalid_request_error",+ "message": "Reasoning is mandatory and cannot be disabled.",+ },+ {+ "code": "unsupported_value",+ "param": "reasoning.effort",+ "message": "Value 'none' is not supported",+ },+ ],+ ids=["mandatory", "unsupported_value"],+)+async def test_tolerant_classifier_corrects_required_reasoning(stream_error, error):+ bodies = []++ def handler(request):+ body = json.loads(request.content)+ bodies.append(body)+ if body.get("reasoning", {}).get("effort") == "none":+ if stream_error:+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse({"type": "error", **error, "sequence_number": 0}),+ )+ return httpx2.Response(400, json={"error": error})+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_sse(_text_delta("<severity>0</severity>"), _completed_event()),+ )++ client = _client(handler)+ try:+ output = [+ event+ async for event in _transport(client).stream_messages(+ _request(max_tokens=64, thinking={"type": "disabled"}),+ input_tokens=11,+ request_id="classifier",+ response_model="public",+ reasoning=ReasoningPolicy.prefer_off(),+ )+ ]+ assert text_content(parse_sse_text("".join(output))) == "<severity>0</severity>"+ assert len(bodies) == 2+ assert bodies[0]["reasoning"]["effort"] == "none"+ assert "max_output_tokens" not in bodies[0]+ assert "reasoning" not in bodies[1]+ finally:+ await client.close()++def _request(**overrides: object) -> MessagesRequest:payload: dict[str, object] = {"model": "upstream-model",diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.pyindex 77f4d3d3..66e5e0a1 100644--- a/tests/providers/test_opencode.py+++ b/tests/providers/test_opencode.py@@ -31,7 +31,10 @@ from free_claude_code.core.anthropic.stream_contracts import (from free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.core.model_capabilities import ModelInputModalityfrom free_claude_code.core.openai_responses import OpenAIResponsesRequest-from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY+from free_claude_code.core.reasoning import (+ DEFAULT_REASONING_POLICY,+ ReasoningCapability,+)from free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.opencode import (OpenCodeProvider,@@ -384,6 +387,7 @@ def test_catalog_resolves_package_precedence_status_alias_and_reasoning() -> NonProviderModelInfo("provider-default",supports_thinking=False,+ reasoning_capability=ReasoningCapability.NONE,input_modalities=frozenset({ModelInputModality.TEXT}),context_window_tokens=131072,max_output_tokens=8192,@@ -1169,7 +1173,11 @@ async def test_model_listing_and_dispatch_use_same_snapshot() -> None:assert infos == frozenset({- ProviderModelInfo("chat-selector", supports_thinking=False),+ ProviderModelInfo(+ "chat-selector",+ supports_thinking=False,+ reasoning_capability=ReasoningCapability.NONE,+ ),ProviderModelInfo("responses-selector", supports_thinking=True),})diff --git a/tests/providers/test_preflight_contract.py b/tests/providers/test_preflight_contract.pyindex 17b12da9..0caa66b1 100644--- a/tests/providers/test_preflight_contract.py+++ b/tests/providers/test_preflight_contract.py@@ -21,6 +21,7 @@ class RecordingOpenAIProvider(OpenAIChatProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> dict:self.build_calls.append((request, reasoning))return {}@@ -42,6 +43,7 @@ class ProviderWithoutPreflight(BaseProvider):response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:if False:yield ""diff --git a/tests/providers/test_reasoning_capabilities.py b/tests/providers/test_reasoning_capabilities.pynew file mode 100644index 00000000..03ecd85f--- /dev/null+++ b/tests/providers/test_reasoning_capabilities.py@@ -0,0 +1,64 @@+import pytest++from free_claude_code.providers.model_listing import (+ extract_openai_model_infos,+ extract_tool_capable_model_infos,+)+++ ("reasoning", "expected"),+ [+ ({"mandatory": True}, "required"),+ ({"supported_efforts": ["none", "high"]}, "optional"),+ ({"mandatory": True, "supported_efforts": ["none"]}, "unknown"),+ ({"mandatory": "true"}, "unknown"),+ ({"mandatory": False}, "unknown"),+ (None, "unknown"),+ ],+)+def test_explicit_gateway_reasoning_capability(reasoning, expected):+ infos = extract_tool_capable_model_infos(+ {+ "data": [+ {+ "id": "route",+ "supported_parameters": ["tools"],+ "reasoning": reasoning,+ }+ ]+ },+ provider_name="GATEWAY",+ )+ assert next(iter(infos)).reasoning_capability.value == expected+++ ("payload", "options", "expected"),+ [+ ({"reasoning": False}, {"thinking_boolean_path": ("reasoning",)}, "none"),+ ({"reasoning": True}, {"thinking_boolean_path": ("reasoning",)}, "unknown"),+ (+ {"tags": ["non-reasoning"]},+ {"tags_field": "tags", "non_thinking_tag": "non-reasoning"},+ "none",+ ),+ (+ {"tags": ["non-reasoning", "reasoning"]},+ {"tags_field": "tags", "non_thinking_tag": "non-reasoning"},+ "unknown",+ ),+ (+ {"supported_parameters": ["tools"]},+ {"thinking_sequence_path": ("supported_parameters",)},+ "unknown",+ ),+ ],+)+def test_intrinsic_capability_is_distinct_from_available_controls(+ payload, options, expected+):+ infos = extract_openai_model_infos(+ {"data": [{"id": "route", **payload}]}, provider_name="TEST", **options+ )+ assert next(iter(infos)).reasoning_capability.value == expecteddiff --git a/tests/providers/test_reasoning_compatibility.py b/tests/providers/test_reasoning_compatibility.pynew file mode 100644index 00000000..717cb528--- /dev/null+++ b/tests/providers/test_reasoning_compatibility.py@@ -0,0 +1,171 @@+from copy import deepcopy++import httpx2+import pytest+from openai import BadRequestError++from free_claude_code.application.model_metadata import ProviderModelInfo+from free_claude_code.core.reasoning import ReasoningCapability, ReasoningPolicy+from free_claude_code.providers.reasoning_compatibility import (+ ReasoningCorrection,+ prepare_messages_reasoning,+)+from tests.providers.request_factory import make_messages_request+++ ("capability", "can_disable", "control", "limit"),+ [+ ("none", True, "default", 64),+ ("optional", True, "off", 64),+ ("optional", False, "default", 8192),+ ("required", True, "default", 8192),+ ("unknown", True, "off", 8192),+ ("unknown", False, "default", 8192),+ ],+)+def test_prepare_uses_explicit_capability_and_available_encoding(+ capability, can_disable, control, limit+):+ request = make_messages_request(+ "arbitrary",+ max_tokens=64,+ thinking={"type": "disabled"},+ output_config={"effort": "high", "format": {"type": "text"}},+ )+ prepared, policy = prepare_messages_reasoning(+ request,+ ReasoningPolicy.prefer_off(),+ model_info=ProviderModelInfo(+ "arbitrary", reasoning_capability=ReasoningCapability(capability)+ ),+ can_disable=can_disable,+ normal_max_tokens=8192,+ )+ assert policy.control.value == control+ assert prepared.max_tokens == limit+ assert prepared.thinking is None+ assert prepared.output_config == {"format": {"type": "text"}}+ assert request.max_tokens == 64+ assert request.thinking is not None and request.thinking.type == "disabled"+++ ("requested", "normal", "expected"), [(12000, 8192, 12000), (12000, None, None)]+)+def test_normal_allowance_preserves_larger_limits_or_omission(+ requested, normal, expected+):+ request = make_messages_request("route", max_tokens=requested)+ prepared, _ = prepare_messages_reasoning(+ request,+ ReasoningPolicy.prefer_off(),+ model_info=None,+ can_disable=True,+ normal_max_tokens=normal,+ )+ assert prepared.max_tokens == expected+++ ("message", "param", "correct"),+ [+ (+ "Reasoning is mandatory for this endpoint and cannot be disabled.",+ None,+ True,+ ),+ ("Thinking cannot be disabled for this endpoint.", None, True),+ ("Unsupported parameter: reasoning_effort", None, True),+ ("Value 'none' is not supported", "reasoning_effort", True),+ ("Value must be one of: low, high", "reasoning_effort", True),+ (+ "Use reasoning_effort for thinking. The response_format parameter is unsupported.",+ "response_format",+ False,+ ),+ (+ "Reasoning is enabled. This response_format cannot be disabled.",+ "response_format",+ False,+ ),+ ("Tool schema required fields missing", "tools", False),+ ("Unknown error", None, False),+ ],+)+def test_correction_requires_rejection_of_the_sent_control(message, param, correct):+ body = {+ "model": "route",+ "messages": [{"role": "user", "content": "classify"}],+ "reasoning_effort": "none",+ "max_tokens": 64,+ "stream_options": {"include_usage": True},+ }+ original = deepcopy(body)+ error = BadRequestError(+ message,+ response=httpx2.Response(+ 400, request=httpx2.Request("POST", "https://test.invalid")+ ),+ body={"error": {"message": message, "param": param}},+ )+ result = ReasoningCorrection(+ (("reasoning_effort",),), "max_tokens", 8192+ ).retry_body(error, body)+ assert (result is not None) is correct+ if result is not None:+ assert result == {+ key: value+ for key, value in original.items()+ if key not in {"max_tokens", "reasoning_effort"}+ } | {"max_tokens": 8192}+ assert body == original++[email protected]("sent", [{}, {"reasoning_effort": "high"}])+def test_correction_requires_the_off_control_to_have_reached_the_wire(sent):+ error = BadRequestError(+ "Reasoning cannot be disabled",+ response=httpx2.Response(+ 400, request=httpx2.Request("POST", "https://test.invalid")+ ),+ body={"message": "Reasoning cannot be disabled"},+ )+ correction = ReasoningCorrection((("reasoning_effort",),), "max_tokens", 8192)+ assert (+ correction.retry_body(error, {"reasoning_effort": "none"}, sent_body=sent)+ is None+ )+++def test_correction_removes_both_template_controls_preserving_other_options():+ error = BadRequestError(+ "Thinking cannot be disabled",+ response=httpx2.Response(+ 400, request=httpx2.Request("POST", "https://test.invalid")+ ),+ body={"message": "Thinking cannot be disabled"},+ )+ body = {+ "extra_body": {+ "chat_template_kwargs": {+ "thinking": False,+ "enable_thinking": False,+ "other": 1,+ }+ },+ "max_tokens": 64,+ }+ correction = ReasoningCorrection(+ (+ ("extra_body", "chat_template_kwargs", "thinking"),+ ("extra_body", "chat_template_kwargs", "enable_thinking"),+ ),+ "max_tokens",+ 8192,+ output_cap=4096,+ )+ assert correction.retry_body(error, body) == {+ "extra_body": {"chat_template_kwargs": {"other": 1}},+ "max_tokens": 4096,+ }diff --git a/tests/providers/test_zenmux.py b/tests/providers/test_zenmux.pyindex e2b0a3e3..13a23f43 100644--- a/tests/providers/test_zenmux.py+++ b/tests/providers/test_zenmux.py@@ -19,7 +19,11 @@ from free_claude_code.core.anthropic.stream_contracts import (thinking_content,)from free_claude_code.core.model_capabilities import ModelInputModality-from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.core.reasoning import (+ ReasoningCapability,+ ReasoningEffort,+ ReasoningPolicy,+)from free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.support import (@@ -403,6 +407,7 @@ async def test_model_catalog_filters_modalities_and_maps_reasoning_capability(ProviderModelInfo("plain-chat",supports_thinking=False,+ reasoning_capability=ReasoningCapability.NONE,input_modalities=frozenset({ModelInputModality.TEXT}),),ProviderModelInfo(diff --git a/tests/runtime/test_application_runtime.py b/tests/runtime/test_application_runtime.pyindex 554951c3..d9eeb8b3 100644--- a/tests/runtime/test_application_runtime.py+++ b/tests/runtime/test_application_runtime.py@@ -70,6 +70,7 @@ class AdminModelProvider(BaseProvider):request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,+ model_info: ProviderModelInfo | None = None,) -> None:return None@@ -98,6 +99,7 @@ class AdminModelProvider(BaseProvider):response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,+ model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:if False:yield ""diff --git a/uv.lock b/uv.lockindex 9a40ff5c..7aa80490 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.23.3"+version = "5.23.4"source = { editable = "." }dependencies = [{ name = "aiohttp" },