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
Convert provider requests once at stream startup (#1783)
Ali Khokhar90af0d5ea5eb
diff --git a/pyproject.toml b/pyproject.tomlindex 7b8481b2..88e8c876 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "6.2.20"+version = "6.2.21"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/application/execution.py b/src/free_claude_code/application/execution.pyindex 4ea33bd2..3d5b8754 100644--- a/src/free_claude_code/application/execution.py+++ b/src/free_claude_code/application/execution.py@@ -167,20 +167,11 @@ class ProviderExecutor:raw_log_payload: object,request_id: str,) -> AsyncIterator[str]:- """Preflight and execute one Anthropic Messages request."""+ """Execute one Anthropic Messages request."""primary = routed.resolved.primaryprimary_provider = self._provider_resolver(primary.provider_id)primary_request = routed.request.model_copy(deep=True)- primary_failure: ExecutionFailure | None = None- try:- 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 = failureinput_tokens = self._token_counter(routed.request.messages,routed.request.system,@@ -204,14 +195,6 @@ class ProviderExecutor:deep=True,))- if index == 0 and primary_failure is not None:- raise primary_failure- if index > 0:- 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,@@ -242,19 +225,11 @@ class ProviderExecutor:raw_log_payload: object,request_id: str,) -> AsyncIterator[str]:- """Preflight and execute one native OpenAI Responses request."""+ """Execute one native OpenAI Responses request."""primary = routed.resolved.primaryprimary_provider = self._provider_resolver(primary.provider_id)primary_request = routed.request.model_copy(deep=True)- primary_failure: ExecutionFailure | None = None- try:- primary_provider.preflight_responses(- primary_request,- reasoning=routed.reasoning,- )- except ExecutionFailure as failure:- primary_failure = failureinput_tokens = self._responses_token_counter(routed.request)def open_candidate(@@ -274,10 +249,6 @@ class ProviderExecutor:deep=True,))- if index == 0 and primary_failure is not None:- raise primary_failure- if index > 0:- provider.preflight_responses(request, reasoning=routed.reasoning)return provider.stream_responses(request,input_tokens=input_tokens,@@ -324,7 +295,7 @@ class ProviderExecutor:request_id: str,open_candidate: CandidateStreamOpener,) -> AsyncIterator[str]:- """Run one protocol-blind candidate lifecycle after eager preflight."""+ """Start and consume candidates through one protocol-blind lifecycle."""primary = resolved.primarycandidates = (primary, *resolved.fallbacks)diff --git a/src/free_claude_code/application/ports.py b/src/free_claude_code/application/ports.pyindex 88205e3b..98badb53 100644--- a/src/free_claude_code/application/ports.py+++ b/src/free_claude_code/application/ports.py@@ -15,14 +15,6 @@ from .model_metadata import ProviderModelInfoclass ProviderPort(Protocol):"""Minimal provider capability required to execute one request."""- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None: ...-def stream_messages(self,request: MessagesRequest,@@ -35,13 +27,6 @@ class ProviderPort(Protocol):model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]: ...- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None: ...-def stream_responses(self,request: OpenAIResponsesRequest,diff --git a/src/free_claude_code/providers/anthropic_messages/transport.py b/src/free_claude_code/providers/anthropic_messages/transport.pyindex 0e9d2312..f79fdbd8 100644--- a/src/free_claude_code/providers/anthropic_messages/transport.py+++ b/src/free_claude_code/providers/anthropic_messages/transport.py@@ -146,23 +146,6 @@ class AnthropicMessagesTransport:except (NativeMessagesError, ResponsesConversionError, ValueError) as error:raise InvalidRequestError(str(error)) from error- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- model_info: ProviderModelInfo | None = None,- ) -> None:- self._messages_body(request, reasoning, model_info)-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- self._responses_body(request, reasoning)-def stream_messages(self,request: MessagesRequest,diff --git a/src/free_claude_code/providers/base.py b/src/free_claude_code/providers/base.pyindex f04289f6..283f7766 100644--- a/src/free_claude_code/providers/base.py+++ b/src/free_claude_code/providers/base.py@@ -37,25 +37,6 @@ class BaseProvider(ABC):def __init__(self, config: ProviderConfig):self._config = config- @abstractmethod- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- model_info: ProviderModelInfo | None = None,- ) -> None:- """Validate a Messages request before opening its SSE stream."""-- @abstractmethod- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- """Validate a Responses request before opening its SSE stream."""-@abstractmethodasync def cleanup(self) -> None:"""Release any resources held by this provider."""@@ -76,7 +57,7 @@ class BaseProvider(ABC):request_headers: Mapping[str, str] | None = None,model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:- """Stream response in Anthropic SSE format."""+ """Validate the request before yielding a response in Anthropic SSE format."""@abstractmethoddef stream_responses(@@ -89,4 +70,4 @@ class BaseProvider(ABC):reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,) -> AsyncIterator[str]:- """Stream response in OpenAI Responses SSE format."""+ """Validate the request before yielding OpenAI Responses SSE events."""diff --git a/src/free_claude_code/providers/github_copilot/provider.py b/src/free_claude_code/providers/github_copilot/provider.pyindex cce07161..8e78b5fe 100644--- a/src/free_claude_code/providers/github_copilot/provider.py+++ b/src/free_claude_code/providers/github_copilot/provider.py@@ -118,25 +118,6 @@ class GitHubCopilotProvider(BaseProvider):"Choose a concrete model from the connected Copilot account.")- def preflight_messages(- self,- 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.- self._check_model(request.model)-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- self._check_model(request.model)-async def list_model_infos(self) -> frozenset[ProviderModelInfo]:if self._closing:raise ExecutionFailure(@@ -157,7 +138,7 @@ class GitHubCopilotProvider(BaseProvider):request_headers: Mapping[str, str] | None = None,model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:- self.preflight_messages(request, reasoning=reasoning)+ self._check_model(request.model)return self._dispatch(request,input_tokens,@@ -176,7 +157,7 @@ class GitHubCopilotProvider(BaseProvider):reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,request_headers: Mapping[str, str] | None = None,) -> AsyncIterator[str]:- self.preflight_responses(request, reasoning=reasoning)+ self._check_model(request.model)return self._dispatch(request,input_tokens,diff --git a/src/free_claude_code/providers/lmstudio/client.py b/src/free_claude_code/providers/lmstudio/client.pyindex 07692214..07507559 100644--- a/src/free_claude_code/providers/lmstudio/client.py+++ b/src/free_claude_code/providers/lmstudio/client.py@@ -12,6 +12,7 @@ heuristic recovery on top."""import time+from collections.abc import AsyncIterator, Mappingimport httpxfrom loguru import logger@@ -30,6 +31,7 @@ from free_claude_code.core.reasoning import ()from free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig+from free_claude_code.providers.endpoint import EndpointContextfrom free_claude_code.providers.failure_policy import (context_window_exceeded_provider_failure,)@@ -81,28 +83,57 @@ class LMStudioProvider(OpenAIChatProvider):)self._loaded_context_cache: tuple[float, int | None] = (0.0, None)- def preflight_messages(+ def stream_messages(self,request: MessagesRequest,+ input_tokens: int = 0,*,+ request_id: str | None = None,+ response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,model_info: ProviderModelInfo | None = None,- ) -> None:- super().preflight_messages(request, reasoning=reasoning, model_info=model_info)- self._preflight_context_budget(+ endpoint_context: EndpointContext | None = None,+ request_headers: Mapping[str, str] | None = None,+ ) -> AsyncIterator[str]:+ stream = super().stream_messages(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=reasoning,+ model_info=model_info,+ endpoint_context=endpoint_context,+ request_headers=request_headers,+ )+ self._validate_context_budget(get_token_count(request.messages, request.system, request.tools))+ return stream- def preflight_responses(+ def stream_responses(self,request: OpenAIResponsesRequest,+ input_tokens: int = 0,*,+ request_id: str | None = None,+ response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- super().preflight_responses(request, reasoning=reasoning)- self._preflight_context_budget(estimate_responses_input_tokens(request))+ endpoint_context: EndpointContext | None = None,+ request_headers: Mapping[str, str] | None = None,+ ) -> AsyncIterator[str]:+ stream = super().stream_responses(+ request,+ input_tokens=input_tokens,+ request_id=request_id,+ response_model=response_model,+ reasoning=reasoning,+ endpoint_context=endpoint_context,+ request_headers=request_headers,+ )+ self._validate_context_budget(estimate_responses_input_tokens(request))+ return stream- def _preflight_context_budget(self, estimate: int) -> None:+ def _validate_context_budget(self, estimate: int) -> None:loaded_context = self._loaded_context_length()if loaded_context is None:return@@ -141,7 +172,7 @@ class LMStudioProvider(OpenAIChatProvider):value = max(loaded) if loaded else Noneexcept Exception as error: # backstop only — never block the requestlogger.debug(- "LMSTUDIO context preflight unavailable: {}", type(error).__name__+ "LMSTUDIO context validation unavailable: {}", type(error).__name__)value = Noneself._loaded_context_cache = (time.monotonic(), value)diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.pyindex c3e7fdf5..5e1f27f8 100644--- a/src/free_claude_code/providers/openai_chat/provider.py+++ b/src/free_claude_code/providers/openai_chat/provider.py@@ -201,25 +201,6 @@ class OpenAIChatProvider(BaseProvider):collection_field=listing.collection_field,)- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- model_info: ProviderModelInfo | None = None,- ) -> None:- self._chat.preflight_messages(- request, reasoning=reasoning, model_info=model_info- )-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- self._chat.preflight_responses(request, reasoning=reasoning)-def stream_messages(self,request: MessagesRequest,diff --git a/src/free_claude_code/providers/openai_chat/transport.py b/src/free_claude_code/providers/openai_chat/transport.pyindex 3b33337f..c9858126 100644--- a/src/free_claude_code/providers/openai_chat/transport.py+++ b/src/free_claude_code/providers/openai_chat/transport.py@@ -639,25 +639,6 @@ class OpenAIChatTransport:tool_adapter=translated.tool_adapter,)- def preflight_messages(- self,- 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, model_info=model_info)-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- """Validate direct Responses-to-Chat conversion before streaming."""- self._build_responses_request_body(request, reasoning=reasoning)-async def _create_stream(self,body: dict,diff --git a/src/free_claude_code/providers/openai_codex/provider.py b/src/free_claude_code/providers/openai_codex/provider.pyindex 6ecf1c42..a7549f18 100644--- a/src/free_claude_code/providers/openai_codex/provider.py+++ b/src/free_claude_code/providers/openai_codex/provider.py@@ -92,25 +92,6 @@ class OpenAICodexProvider(BaseProvider):session_id=session_id,)- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- model_info: ProviderModelInfo | None = None,- ) -> None:- self._responses.preflight_messages(- request, reasoning=reasoning, model_info=model_info- )-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- self._responses.preflight_responses(request, reasoning=reasoning)-async def cleanup(self) -> None:await self._client.close()diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex 3964ea87..5034afb8 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -123,21 +123,6 @@ class OpenAIResponsesTransport:self._read_timeout_s = read_timeout_sself._log_raw_sse_events = log_raw_sse_events- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- can_disable_reasoning: bool = True,- ) -> None:- self._build_messages_body(- request,- reasoning=reasoning,- model_info=model_info,- can_disable_reasoning=can_disable_reasoning,- )-def stream_messages(self,request: MessagesRequest,@@ -185,14 +170,6 @@ class OpenAIResponsesTransport:),)- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- self._build_native_body(request, reasoning=reasoning)-def stream_responses(self,request: OpenAIResponsesRequest,diff --git a/src/free_claude_code/providers/opencode/provider.py b/src/free_claude_code/providers/opencode/provider.pyindex 82f70083..89daa942 100644--- a/src/free_claude_code/providers/opencode/provider.py+++ b/src/free_claude_code/providers/opencode/provider.py@@ -162,45 +162,6 @@ class OpenCodeProvider(BaseProvider):return {"x-opencode-session": session_id}return {}- def preflight_messages(- self,- 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- if snapshot is None:- return- 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, model_info=route.model_info- )- return- self._chat.preflight_messages(- routed, reasoning=reasoning, model_info=route.model_info- )-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- """Validate native Responses ingress against a warm catalog route."""- snapshot = self._catalog.current_snapshot- if snapshot is None:- return- route = self._require_route(snapshot, request.model)- routed = _routed_responses_request(request, route)- if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_responses(routed, reasoning=reasoning)- return- self._chat.preflight_responses(routed, reasoning=reasoning)-def stream_messages(self,request: MessagesRequest,@@ -240,9 +201,6 @@ class OpenCodeProvider(BaseProvider):selected_stream: AsyncIterator[str] | None = Nonetry:if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_messages(- routed, reasoning=reasoning, model_info=route.model_info- )selected_stream = self._responses.stream_messages(routed,input_tokens=input_tokens,@@ -254,9 +212,6 @@ class OpenCodeProvider(BaseProvider):model_info=route.model_info,)else:- self._chat.preflight_messages(- routed, reasoning=reasoning, model_info=route.model_info- )selected_stream = self._chat.stream_messages(routed,input_tokens=input_tokens,@@ -316,7 +271,6 @@ class OpenCodeProvider(BaseProvider):selected_stream: AsyncIterator[str] | None = Nonetry:if route.transport is OpenCodeUpstreamTransport.RESPONSES:- self._responses.preflight_responses(routed, reasoning=reasoning)selected_stream = self._responses.stream_responses(routed,input_tokens=input_tokens,@@ -327,7 +281,6 @@ class OpenCodeProvider(BaseProvider):extra_headers=self._upstream_headers(request_headers or {}),)else:- self._chat.preflight_responses(routed, reasoning=reasoning)selected_stream = self._chat.stream_responses(routed,input_tokens=input_tokens,diff --git a/tests/api/model_fallback_support.py b/tests/api/model_fallback_support.pyindex 38d15af8..1f71b81f 100644--- a/tests/api/model_fallback_support.py+++ b/tests/api/model_fallback_support.py@@ -190,30 +190,17 @@ class ControlledFallbackProvider:chunks_before_failure: tuple[str, ...] = (),responses_chunks_before_failure: tuple[str, ...] = (),text: str | None = None,- preflight_error: InvalidRequestError | None = None,+ validation_error: InvalidRequestError | None = None,) -> None:self._failure = failureself._chunks_before_failure = chunks_before_failureself._responses_chunks_before_failure = responses_chunks_before_failureself._text = text- self._preflight_error = preflight_error- self.preflight_models: list[str] = []+ self._validation_error = validation_errorself.stream_models: list[str] = []self.response_models: list[str] = []self.close_calls = 0- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- del reasoning- self.preflight_models.append(request.model)- if self._preflight_error is not None:- raise self._preflight_error-async def stream_messages(self,request: MessagesRequest,@@ -226,6 +213,8 @@ class ControlledFallbackProvider:model_info: ProviderModelInfo | None = None,) -> AsyncIterator[str]:del input_tokens, request_id, reasoning+ if self._validation_error is not None:+ raise self._validation_errorself.stream_models.append(request.model)public_model = response_model or request.modelself.response_models.append(public_model)@@ -240,17 +229,6 @@ class ControlledFallbackProvider:finally:self.close_calls += 1- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- del reasoning- self.preflight_models.append(request.model)- if self._preflight_error is not None:- raise self._preflight_error-async def stream_responses(self,request: OpenAIResponsesRequest,@@ -262,6 +240,8 @@ class ControlledFallbackProvider:request_headers: Mapping[str, str] | None = None,) -> AsyncIterator[str]:del input_tokens, request_id, reasoning+ if self._validation_error is not None:+ raise self._validation_errorself.stream_models.append(request.model)public_model = response_model or request.modelself.response_models.append(public_model)diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.pyindex 0f6c6916..77234049 100644--- a/tests/api/test_api_handlers.py+++ b/tests/api/test_api_handlers.py@@ -39,10 +39,6 @@ _CLASSIFIER_USER = (class FakeProvider:def __init__(self, events: list[str] | None = None) -> None:- self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []- self.responses_preflight_calls: list[- tuple[OpenAIResponsesRequest, ReasoningPolicy]- ] = []self.requests: list[MessagesRequest] = []self.responses_requests: list[OpenAIResponsesRequest] = []self.stream_kwargs: list[dict[str, Any]] = []@@ -51,20 +47,6 @@ class FakeProvider:'event: message_stop\ndata: {"type":"message_stop"}\n\n',]- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- self.preflight_calls.append((request, reasoning))-- def preflight_responses(- self, request: OpenAIResponsesRequest, *, reasoning: ReasoningPolicy- ) -> None:- self.responses_preflight_calls.append((request, reasoning))-async def cleanup(self) -> None:return None@@ -161,25 +143,27 @@ async def test_messages_handler_passes_routed_request_and_stream_metadata() -> Nassert provider.stream_kwargs[0]["request_id"].startswith("req_")assert provider.stream_kwargs[0]["response_model"] == "nvidia_nim/test-model"assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()- assert len(provider.preflight_calls) == 1+ assert len(provider.requests) == 1@pytest.mark.asyncio@pytest.mark.parametrize("stream", [True, False])-async def test_messages_handler_preflight_invalid_request_stays_http_error(+async def test_messages_handler_startup_invalid_request_stays_http_error(stream: bool,) -> None:- class RejectPreflightProvider(FakeProvider):- def preflight_messages(+ class RejectStartupProvider(FakeProvider):+ def stream_messages(self,request: MessagesRequest,+ input_tokens: int = 0,*,reasoning: ReasoningPolicy,model_info: ProviderModelInfo | None = None,- ) -> None:+ **kwargs: object,+ ) -> AsyncIterator[str]:raise InvalidRequestError("bad tool shape")- provider = RejectPreflightProvider()+ provider = RejectStartupProvider()handler = MessagesHandler(Settings(), provider_resolver=lambda _: provider)request = MessagesRequest(model="nvidia_nim/test-model",@@ -188,8 +172,14 @@ async def test_messages_handler_preflight_invalid_request_stays_http_error(stream=stream,)- with pytest.raises(InvalidRequestError):- await handler.create(request)+ if stream:+ response = await handler.create(request)+ assert isinstance(response, JSONResponse)+ assert response.status_code == 400+ assert json.loads(bytes(response.body))["error"]["message"] == "bad tool shape"+ else:+ with pytest.raises(InvalidRequestError, match="bad tool shape"):+ await handler.create(request)@pytest.mark.asyncio@@ -453,11 +443,11 @@ 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.prefer_off()+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()assert provider.requests[0].model == "test-model"assert provider.requests[0].system == system- assert provider.preflight_calls[0][0].stop_sequences is None+ assert provider.requests[0].stop_sequences is Noneassert provider.requests[0].stop_sequences is Noneassert request.stop_sequences == [classifier_stop_sequence]assert _trace_events(@@ -501,7 +491,7 @@ async def test_messages_handler_preserves_thinking_for_non_classifier() -> None:assert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.provider_default()+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()assert provider.requests[0].stop_sequences == ["</severity>"]assert (@@ -531,7 +521,7 @@ async def test_messages_handler_tolerates_required_thinking_for_classifier() ->assert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert provider.preflight_calls[0][1] == ReasoningPolicy.prefer_off()+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()assert provider.requests[0].stop_sequences is Noneassert request.stop_sequences == ["</block>"]@@ -569,7 +559,7 @@ async def test_messages_handler_prefers_no_thinking_without_classifier_stop_hintassert isinstance(response, StreamingResponse)await _streaming_body_text(response)- 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 _trace_events(trace_mock, "free_claude_code.api.route.safety_classifier_policy"@@ -604,8 +594,8 @@ 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.prefer_off()- assert provider.preflight_calls[0][0].stop_sequences == [+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.prefer_off()+ assert provider.requests[0].stop_sequences == ["custom","custom","tail",@@ -675,9 +665,7 @@ async def test_responses_handler_does_not_apply_safety_classifier_policy() -> Noassert isinstance(response, StreamingResponse)await _streaming_body_text(response)- assert (- provider.responses_preflight_calls[0][1] == ReasoningPolicy.provider_default()- )+ assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()assert (_trace_events(diff --git a/tests/api/test_execution_failure_contract.py b/tests/api/test_execution_failure_contract.pyindex 005761da..689720a5 100644--- a/tests/api/test_execution_failure_contract.py+++ b/tests/api/test_execution_failure_contract.py@@ -45,8 +45,6 @@ class CanonicalFailureProvider:self._message = messageself._retryable = retryableself._grouped = grouped- self.preflight_messages = MagicMock()- self.preflight_responses = MagicMock()self.stream_kwargs: list[dict[str, Any]] = []async def stream_messages(@@ -102,23 +100,6 @@ class StalledProvider:self._responses_chunks = responses_chunksself.close_calls = 0- def preflight_messages(- self,- _request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- del reasoning-- def preflight_responses(- self,- _request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- del reasoning-async def stream_messages(self,_request: MessagesRequest,diff --git a/tests/api/test_model_fallback.py b/tests/api/test_model_fallback.pyindex 15c444f3..082e4eb4 100644--- a/tests/api/test_model_fallback.py+++ b/tests/api/test_model_fallback.py@@ -144,7 +144,7 @@ def test_final_failure_uses_last_candidate_typed_error(("/v1/responses", responses_payload()),),)-def test_lazy_fallback_preflight_error_remains_ordinary(+def test_lazy_fallback_validation_error_remains_ordinary(path: str,payload: dict[str, object],) -> None:@@ -152,7 +152,7 @@ def test_lazy_fallback_preflight_error_remains_ordinary(failure=execution_failure("primary overloaded"))fallback = ControlledFallbackProvider(- preflight_error=InvalidRequestError("fallback configuration is invalid")+ validation_error=InvalidRequestError("fallback configuration is invalid"))with fallback_client(primary, fallback) as client:@@ -183,7 +183,6 @@ def test_postframe_failure_never_opens_fallback_for_streaming_messages() -> Noneassert response.status_code == 200events = parse_sse_text(response.text)assert [event.event for event in events] == ["message_start", "error"]- assert fallback.preflight_models == []assert fallback.stream_models == []@@ -204,7 +203,6 @@ def test_postframe_failure_never_opens_fallback_for_responses() -> None:"response.created","response.failed",]- assert fallback.preflight_models == []assert fallback.stream_models == []diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.pyindex 5b116a9e..58b64674 100644--- a/tests/api/test_openai_responses.py+++ b/tests/api/test_openai_responses.py@@ -35,7 +35,7 @@ _RESPONSE_ID = "resp_test"class FakeProvider:def __init__(self, chunks: list[str]) -> None:self.chunks = chunks- self.preflight_responses = MagicMock()+ self.startup_error: InvalidRequestError | None = Noneself.requests: list[OpenAIResponsesRequest] = []self.stream_kwargs: list[dict[str, object]] = []@@ -44,6 +44,8 @@ class FakeProvider:request_data: OpenAIResponsesRequest,**kwargs: object,) -> AsyncIterator[str]:+ if self.startup_error is not None:+ raise self.startup_errorself.requests.append(request_data)self.stream_kwargs.append(kwargs)for chunk in self.chunks:@@ -129,7 +131,7 @@ def test_create_response_stream_routes_native_request_through_provider(assert events[-1].data["response"]["output"][0]["content"][0]["text"] == ("Hello from provider")- assert provider.preflight_responses.called+ assert len(provider.requests) == 1routed = provider.requests[0]assert routed.model == _UPSTREAM_MODELassert routed.input == "Hello"@@ -163,9 +165,9 @@ def test_create_response_stream_preserves_output_limit_as_incomplete() -> None:assert incomplete["output"][0]["content"][0]["text"] == "partial output"-def test_create_response_preflight_rejection_stays_an_ordinary_http_error() -> None:+def test_create_response_startup_rejection_stays_an_ordinary_http_error() -> None:provider = FakeProvider(_responses_text_stream("unused"))- provider.preflight_responses.side_effect = InvalidRequestError("bad tool shape")+ provider.startup_error = InvalidRequestError("bad tool shape")app = create_test_app()with (@@ -540,7 +542,7 @@ def test_create_response_preserves_muse_code_request_shape() -> None:effort=ReasoningEffort.HIGH,)assert provider.stream_kwargs[0]["reasoning"] == expected_policy- assert provider.preflight_responses.call_args.kwargs["reasoning"] == expected_policy+ assert provider.stream_kwargs[0]["reasoning"] == expected_policydef test_create_response_preserves_custom_tool_request() -> None:@@ -700,7 +702,7 @@ def test_create_response_preserves_and_resolves_reasoning_effort(assert response.status_code == 200assert provider.requests[0].reasoning == reasoningassert provider.stream_kwargs[0]["reasoning"] == expected_policy- assert provider.preflight_responses.call_args.kwargs["reasoning"] == expected_policy+ assert provider.stream_kwargs[0]["reasoning"] == expected_policydef test_create_response_relays_encrypted_reasoning() -> None:@@ -732,7 +734,7 @@ def test_create_response_provider_rejects_unsupported_tool(responses_client: tuple[TestClient, FakeProvider],) -> None:client, provider = responses_client- provider.preflight_responses.side_effect = InvalidRequestError(+ provider.startup_error = InvalidRequestError("Unsupported Responses tool type: 'web_search_preview'")diff --git a/tests/api/test_ordinary_error_phases.py b/tests/api/test_ordinary_error_phases.pyindex cce786a1..9498830e 100644--- a/tests/api/test_ordinary_error_phases.py+++ b/tests/api/test_ordinary_error_phases.py@@ -1,4 +1,4 @@-"""Ordinary ingress, routing, readiness, and preflight error contracts."""+"""Ordinary ingress, routing, readiness, and validation error contracts."""from unittest.mock import AsyncMock, MagicMock, patch@@ -13,7 +13,9 @@ from free_claude_code.application.errors import (UnknownProviderError,)from free_claude_code.config.settings import Settings+from free_claude_code.providers.open_router import OpenRouterProviderfrom tests.api.support import create_test_app+from tests.providers.support import immediate_admission, make_provider_config_PRODUCT_REQUESTS = ((@@ -46,6 +48,48 @@ def _settings(**updates: object) -> Settings:)[email protected]("mode", ["messages_stream", "messages_nonstream", "responses"])+def test_conversion_error_returns_http_400_without_generation(mode):+ payload = {"model": "open_router/test-model"}+ if mode == "responses":+ payload["input"] = [+ {"type": "reasoning", "encrypted_content": "fcc:history:v2:unsupported"}+ ]+ path = "/v1/responses"+ else:+ payload["stream"] = mode == "messages_stream"+ payload["messages"] = [+ {+ "role": "assistant",+ "content": [+ {"type": "redacted_thinking", "data": "fcc:history:v2:unsupported"}+ ],+ }+ ]+ path = "/v1/messages"+ sdk = MagicMock()+ with patch(+ "free_claude_code.providers.openai_chat.client.AsyncOpenAI", return_value=sdk+ ):+ provider = OpenRouterProvider(+ make_provider_config(+ api_key="test", base_url="https://provider.invalid/v1"+ ),+ admission=immediate_admission(),+ )+ with (+ patch("free_claude_code.api.routes.resolve_provider", return_value=provider),+ TestClient(create_test_app(_settings())) as client,+ ):+ response = client.post(path, json=payload)+ assert response.status_code == 400+ assert response.headers["content-type"].startswith("application/json")+ assert response.json()["error"]["type"] == "invalid_request_error"+ assert "replay" in response.json()["error"]["message"]+ assert "x-should-retry" not in response.headers+ sdk.chat.completions.create.assert_not_called()++def _assert_ordinary_protocol_error(response: httpx.Response,*,@@ -189,19 +233,19 @@ def test_unknown_provider_is_protocol_specific_400_without_terminal_header(_PRODUCT_REQUESTS,ids=("messages", "responses"),)-def test_preflight_rejection_is_protocol_specific_400_without_terminal_header(+def test_startup_rejection_is_protocol_specific_400_without_terminal_header(wire_api: str,path: str,payload: dict[str, object],) -> None:message = "bad tool shape"provider = MagicMock()- preflight = (- provider.preflight_responses+ stream = (+ provider.stream_responsesif wire_api == "responses"- else provider.preflight_messages+ else provider.stream_messages)- preflight.side_effect = InvalidRequestError(message)+ stream.side_effect = InvalidRequestError(message)app = create_test_app(_settings())with (@@ -218,7 +262,7 @@ def test_preflight_rejection_is_protocol_specific_400_without_terminal_header(if wire_api == "responses"else provider.stream_messages)- stream.assert_not_called()+ stream.assert_called_once()_assert_ordinary_protocol_error(response,wire_api=wire_api,diff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.pyindex 44d32c5c..6ee07bce 100644--- a/tests/api/test_request_lifetime.py+++ b/tests/api/test_request_lifetime.py@@ -399,23 +399,6 @@ class _ControlledProvider:self.closed = asyncio.Event()self.request_ids: list[str] = []- def preflight_messages(- self,- _request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- del reasoning-- def preflight_responses(- self,- _request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- del reasoning-async def stream_messages(self,_request: MessagesRequest,diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.pyindex 8b43be78..b48d9743 100644--- a/tests/api/test_web_server_tools.py+++ b/tests/api/test_web_server_tools.py@@ -128,23 +128,6 @@ class ScriptedSelectionProvider:self.stream_kwargs: list[dict[str, object]] = []self.close_count = 0- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- return None-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- raise AssertionError("Web-search selection received a Responses request")-async def stream_responses(self,request: OpenAIResponsesRequest,diff --git a/tests/application/test_execution.py b/tests/application/test_execution.pyindex d39b1116..47b0f369 100644--- a/tests/application/test_execution.py+++ b/tests/application/test_execution.py@@ -25,27 +25,9 @@ from free_claude_code.core.reasoning import ReasoningCapability, ReasoningPolicyclass FakeProvider:def __init__(self) -> None:- self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []self.stream_calls: list[dict[str, object]] = []self.stream_close_calls = 0- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- self.preflight_calls.append((request, reasoning))-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- raise AssertionError("Messages test provider received a Responses request")-async def stream_messages(self,request: MessagesRequest,@@ -104,27 +86,9 @@ class FakeProvider:class ResponsesFakeProvider:def __init__(self) -> None:- self.preflight_calls: list[tuple[OpenAIResponsesRequest, ReasoningPolicy]] = []self.stream_calls: list[dict[str, object]] = []self.stream_close_calls = 0- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy,- ) -> None:- self.preflight_calls.append((request, reasoning))-- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- raise AssertionError("Responses test provider received a Messages request")-async def stream_messages(self,request: MessagesRequest,@@ -226,48 +190,36 @@ class ControlledProvider(FakeProvider):self.stream_close_calls += 1-class FailingPreflightProvider(FakeProvider):- def preflight_messages(+class FailingValidationProvider(FakeProvider):+ def stream_messages(self,request: MessagesRequest,+ input_tokens: int = 0,*,reasoning: ReasoningPolicy,model_info: ProviderModelInfo | None = None,- ) -> None:+ **kwargs: object,+ ) -> AsyncIterator[str]:raise ValueError("invalid provider request")-class ApplicationErrorPreflightProvider(FakeProvider):+class ApplicationErrorValidationProvider(FakeProvider):def __init__(self, error: InvalidRequestError) -> None:super().__init__()self._error = error- def preflight_messages(+ def stream_messages(self,request: MessagesRequest,+ input_tokens: int = 0,*,reasoning: ReasoningPolicy,model_info: ProviderModelInfo | None = None,- ) -> None:+ **kwargs: object,+ ) -> AsyncIterator[str]:raise self._error-class ExecutionFailurePreflightProvider(FakeProvider):- def __init__(self, failure: ExecutionFailure) -> None:- super().__init__()- self._failure = failure-- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy,- model_info: ProviderModelInfo | None = None,- ) -> None:- super().preflight_messages(request, reasoning=reasoning)- raise self._failure--class FailingStreamConstructionProvider(FakeProvider):def stream_messages(self,@@ -382,13 +334,10 @@ def _routed_request(@pytest.mark.asyncio-async def test_fallback_receives_its_own_cached_capability_in_preflight_and_stream():+async def test_fallback_receives_its_own_cached_capability_in_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):@@ -420,9 +369,7 @@ async def test_fallback_receives_its_own_cached_capability_in_preflight_and_stre]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),]@@ -482,7 +429,7 @@ async def test_executor_routes_native_responses_without_messages_conversion() ->request_id="req_responses_application",)- assert provider.preflight_calls == [(request, ReasoningPolicy.on())]+ assert provider.stream_calls == []assert [chunk async for chunk in stream] == ["event: response.completed\ndata: {}\n\n"]@@ -499,7 +446,9 @@ async def test_executor_routes_native_responses_without_messages_conversion() ->@pytest.mark.asyncio-async def test_executor_uses_structural_provider_port_and_preflights_eagerly() -> None:+async def test_executor_uses_structural_provider_port_and_defers_stream_startup() -> (+ None+):provider = FakeProvider()routed = _routed_request()request = routed.request@@ -515,7 +464,7 @@ async def test_executor_uses_structural_provider_port_and_preflights_eagerly() -request_id="req_application",)- assert provider.preflight_calls == [(request, ReasoningPolicy.on())]+ assert provider.stream_calls == []assert [chunk async for chunk in stream] == ["event: message_stop\ndata: {}\n\n"]assert provider.stream_calls == [{@@ -561,7 +510,6 @@ async def test_primary_success_never_resolves_fallback() -> None:assert [chunk async for chunk in stream] == ["event: message_stop\ndata: {}\n\n"]assert resolved_ids == ["provider"]- assert fallback.preflight_calls == []assert fallback.stream_calls == []@@ -601,9 +549,11 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primaryassert order == ["fallback-resolved"]assert primary.stream_close_calls == 1assert fallback.stream_close_calls == 1- assert fallback.preflight_calls[0][0].model == "fallback-model"+ fallback_request = fallback.stream_calls[0]["request"]+ assert isinstance(fallback_request, MessagesRequest)+ assert fallback_request.model == "fallback-model"assert fallback.stream_calls[0] == {- "request": fallback.preflight_calls[0][0],+ "request": fallback_request,"input_tokens": 17,"request_id": "req_fallback","response_model": "gateway-model",@@ -803,14 +753,14 @@ async def test_nonretryable_provider_failure_selects_fallback_before_first_frame@pytest.mark.asyncio-async def test_primary_canonical_preflight_failure_selects_fallback() -> None:+async def test_primary_canonical_startup_failure_selects_fallback() -> None:primary_failure = ExecutionFailure(kind=FailureKind.CONTEXT_WINDOW_EXCEEDED,status_code=400,message="primary context exceeded",retryable=False,)- primary = ExecutionFailurePreflightProvider(primary_failure)+ primary = ExecutionFailureStreamConstructionProvider(primary_failure)fallback = ControlledProvider(["fallback-frame"])providers = {"provider": primary, "fallback": fallback}executor = ProviderExecutor(@@ -821,12 +771,14 @@ async def test_primary_canonical_preflight_failure_selects_fallback() -> None:stream = executor.stream_messages(_routed_request(_target("fallback", "fallback-model")),raw_log_payload={},- request_id="req_preflight_fallback",+ request_id="req_startup_fallback",)assert [chunk async for chunk in stream] == ["fallback-frame"]assert primary.stream_calls == []- assert fallback.preflight_calls[0][0].model == "fallback-model"+ fallback_request = fallback.stream_calls[0]["request"]+ assert isinstance(fallback_request, MessagesRequest)+ assert fallback_request.model == "fallback-model"@pytest.mark.asyncio@@ -881,10 +833,10 @@ async def test_failure_after_first_frame_never_selects_fallback() -> None:@pytest.mark.asyncio-async def test_lazy_fallback_preflight_application_error_stops_unchanged() -> None:+async def test_lazy_fallback_startup_application_error_stops_unchanged() -> None:primary = ControlledProvider([_execution_failure("primary")])- preflight_error = InvalidRequestError("fallback is misconfigured")- fallback = ApplicationErrorPreflightProvider(preflight_error)+ startup_error = InvalidRequestError("fallback is misconfigured")+ fallback = ApplicationErrorValidationProvider(startup_error)providers = {"provider": primary, "fallback": fallback}executor = ProviderExecutor(providers.__getitem__,@@ -893,13 +845,13 @@ async def test_lazy_fallback_preflight_application_error_stops_unchanged() -> Nostream = executor.stream_messages(_routed_request(_target("fallback", "model")),raw_log_payload={},- request_id="req_preflight",+ request_id="req_startup",)with pytest.raises(InvalidRequestError) as exc_info:await anext(stream)- assert exc_info.value is preflight_error+ assert exc_info.value is startup_errorassert primary.stream_close_calls == 1assert fallback.stream_calls == []@@ -1001,8 +953,9 @@ async def test_stream_construction_failure_remains_deferred_to_iteration() -> Noassert resolved_ids == ["provider"]-def test_executor_preflight_failure_stays_before_token_count_and_stream() -> None:- provider = FailingPreflightProvider()+async def test_executor_validation_is_deferred_until_iteration() -> None:+ provider = FailingValidationProvider()token_counter = MagicMock(return_value=17)executor = ProviderExecutor(lambda _provider_id: provider,@@ -1010,14 +963,14 @@ def test_executor_preflight_failure_stays_before_token_count_and_stream() -> Nontoken_counter=token_counter,)+ stream = executor.stream_messages(+ _routed_request(),+ raw_log_payload={},+ request_id="req_application",+ )+ token_counter.assert_called_once()with pytest.raises(ValueError, match="invalid provider request"):- executor.stream_messages(- _routed_request(),- raw_log_payload={},- request_id="req_application",- )-- token_counter.assert_not_called()+ await anext(stream)assert provider.stream_calls == []diff --git a/tests/application/test_request_conversion.py b/tests/application/test_request_conversion.pynew file mode 100644index 00000000..649796f2--- /dev/null+++ b/tests/application/test_request_conversion.py@@ -0,0 +1,148 @@+"""Request startup retains the conversion it validates before generation."""++from dataclasses import replace+from unittest.mock import patch++import httpx2+import pytest+from openai import AsyncOpenAI++from free_claude_code.application.execution import ProviderExecutor+from free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.providers.openai_chat import (+ NO_REASONING,+ OpenAIChatProfile,+ OpenAIChatProvider,+ OpenAIChatRequestPolicy,+)+from tests.application.test_execution import _routed_request, _routed_responses_request+from tests.providers.support import immediate_admission, make_provider_config+from tests.providers.test_openai_chat_transport import _success+from tests.providers.test_openai_codex_provider import (+ OpenAICodexProvider,+ _complete_stream,+ _config,+ _FakeAuth,+)+from tests.providers.test_opencode import (+ _catalog_payload,+ _provider_with_wire_transports,+)++[email protected]("wire", ["messages", "responses"])+async def test_executor_converts_chat_request_once(wire):+ generation_calls = []++ def reply(request):+ generation_calls.append(request)+ return _success()++ async with AsyncOpenAI(+ api_key="test",+ base_url="https://provider.invalid/v1",+ max_retries=0,+ http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(reply)),+ ) as client:+ provider = OpenAIChatProvider(+ make_provider_config(+ api_key="test", base_url="https://provider.invalid/v1"+ ),+ profile=OpenAIChatProfile(+ OpenAIChatRequestPolicy("TEST", ReasoningReplayMode.DISABLED),+ NO_REASONING,+ ),+ admission=immediate_admission(),+ client=client,+ )+ executor = ProviderExecutor(lambda _: provider, progress_timeout_seconds=60)+ builder_name = (+ "_build_request_body"+ if wire == "messages"+ else "_build_responses_request_body"+ )+ routed = (+ _routed_request() if wire == "messages" else _routed_responses_request()+ )+ with patch.object(+ provider._chat, builder_name, wraps=getattr(provider._chat, builder_name)+ ) as build:+ stream = getattr(executor, f"stream_{wire}")(+ routed, raw_log_payload={}, request_id="conversion-once"+ )+ output = "".join([event async for event in stream])+ assert "hello" in output+ assert len(generation_calls) == 1+ assert build.call_count == 1++[email protected]("wire", ["messages", "responses"])[email protected]("egress", ["chat", "responses"])[email protected]("warm", [False, True])+async def test_executor_converts_selected_opencode_route_once(wire, egress, warm):+ provider, generation, catalog = _provider_with_wire_transports(_catalog_payload())+ transport = provider._chat if egress == "chat" else provider._responses+ builders = {+ ("chat", "messages"): "_build_request_body",+ ("chat", "responses"): "_build_responses_request_body",+ ("responses", "messages"): "_build_messages_body",+ ("responses", "responses"): "_build_native_body",+ }+ name = builders[egress, wire]+ routed = _routed_request() if wire == "messages" else _routed_responses_request()+ routed = replace(+ routed,+ request=routed.request.model_copy(update={"model": f"{egress}-selector"}),+ )+ try:+ if warm:+ await provider.list_model_infos()+ with patch.object(transport, name, wraps=getattr(transport, name)) as build:+ executor = ProviderExecutor(lambda _: provider, progress_timeout_seconds=60)+ stream = getattr(executor, f"stream_{wire}")(+ routed, raw_log_payload={}, request_id="opencode-conversion-once"+ )+ assert f"{egress}-ok" in "".join([event async for event in stream])+ assert build.call_count == 1+ assert len(generation) == len(catalog) == 1+ finally:+ await provider.cleanup()++[email protected]("wire", ["messages", "responses"])+async def test_executor_converts_subscription_request_once(wire):+ generation = []++ def reply(request):+ generation.append(request)+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ text=_complete_stream("hello"),+ )++ auth = _FakeAuth()+ provider = OpenAICodexProvider(+ _config(),+ auth=auth,+ admission=immediate_admission(),+ transport=httpx2.MockTransport(reply),+ )+ name = "_build_messages_body" if wire == "messages" else "_build_native_body"+ routed = _routed_request() if wire == "messages" else _routed_responses_request()+ try:+ with patch.object(+ provider._responses, name, wraps=getattr(provider._responses, name)+ ) as build:+ executor = ProviderExecutor(lambda _: provider, progress_timeout_seconds=60)+ stream = getattr(executor, f"stream_{wire}")(+ routed, raw_log_payload={}, request_id="subscription-conversion-once"+ )+ assert auth.access_calls == 0+ assert "hello" in "".join([event async for event in stream])+ assert build.call_count == len(generation) == auth.access_calls == 1+ finally:+ await provider.cleanup()diff --git a/tests/core/test_history_switching.py b/tests/core/test_history_switching.pyindex 3a9f091a..37c048c8 100644--- a/tests/core/test_history_switching.py+++ b/tests/core/test_history_switching.py@@ -377,7 +377,7 @@ def test_completed_native_hosted_tools_become_readable_chat_history():@pytest.mark.parametrize("wire", ["messages", "responses"])-def test_malformed_carrier_fails_preflight_before_inference(wire):+def test_malformed_carrier_fails_startup_before_inference(wire):from free_claude_code.application.errors import InvalidRequestErrorprovider = OpenRouterProvider(@@ -386,7 +386,7 @@ def test_malformed_carrier_fails_preflight_before_inference(wire):)with pytest.raises(InvalidRequestError, match="replay"):if wire == "messages":- provider.preflight_messages(+ provider.stream_messages(MessagesRequest.model_validate({"model": "m",@@ -405,7 +405,7 @@ def test_malformed_carrier_fails_preflight_before_inference(wire):))else:- provider.preflight_responses(+ provider.stream_responses(OpenAIResponsesRequest(model="m",input=[diff --git a/tests/providers/test_anthropic_messages_transport.py b/tests/providers/test_anthropic_messages_transport.pyindex ae8b82fd..24d39bfb 100644--- a/tests/providers/test_anthropic_messages_transport.py+++ b/tests/providers/test_anthropic_messages_transport.py@@ -595,12 +595,13 @@ async def test_auth_refresh_cannot_exceed_single_attempt_budget() -> None:@pytest.mark.asyncio-async def test_preflight_rejects_invalid_conversion_without_request_io() -> None:+async def test_startup_rejects_invalid_conversion_without_request_io() -> None:async with httpx.AsyncClient() as client:transport = _transport(client)with pytest.raises(InvalidRequestError):- transport.preflight_responses(+ transport.stream_responses(OpenAIResponsesRequest(model="native", input=[{"type": "input_file", "file_id": "remote"}]- )+ ),+ endpoint_context=Endpoint(),)diff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.pyindex 4e49951f..ab2c1358 100644--- a/tests/providers/test_deepseek.py+++ b/tests/providers/test_deepseek.py@@ -788,7 +788,7 @@ def test_passthrough_tool_use_and_result(deepseek_provider):assert body["messages"][1]["role"] == "tool"-def test_preflight_strips_user_image():+def test_startup_strips_user_image():"""Image blocks are silently stripped (DeepSeek lacks vision); request must not fail."""request = MessagesRequest(model="m",@@ -818,7 +818,7 @@ def test_preflight_strips_user_image():admission=immediate_admission(),)# Should not raise; image is stripped.- provider.preflight_messages(request, reasoning=REASONING_ON)+ provider.stream_messages(request, reasoning=REASONING_ON)body = provider._chat._build_request_body(request, reasoning=reasoning_for(request))content = body["messages"][0]["content"]assert "attachment omitted" in content.lower()@@ -855,8 +855,8 @@ def test_vision_model_forwards_user_image():),admission=immediate_admission(),)- # Must not raise on preflight (no InvalidRequestError for image blocks).- provider.preflight_messages(request, reasoning=REASONING_ON)+ # Must not raise on validation (no InvalidRequestError for image blocks).+ provider.stream_messages(request, reasoning=REASONING_ON)body = provider._chat._build_request_body(request, reasoning=reasoning_for(request))content = body["messages"][0]["content"]assert isinstance(content, list)@@ -904,7 +904,7 @@ def test_vision_model_strips_user_document():),admission=immediate_admission(),)- provider.preflight_messages(request, reasoning=REASONING_ON)+ provider.stream_messages(request, reasoning=REASONING_ON)body = provider._chat._build_request_body(request, reasoning=reasoning_for(request))content = body["messages"][0]["content"]assert content@@ -925,7 +925,7 @@ def test_vision_model_strips_user_document():assert "image or document inputs" in lowered-def test_preflight_rejects_mcp_servers():+def test_startup_rejects_mcp_servers():request = MessagesRequest(model="m",messages=[Message(role="user", content="x")],@@ -941,10 +941,10 @@ def test_preflight_rejects_mcp_servers():admission=immediate_admission(),)with pytest.raises(InvalidRequestError, match="mcp_servers"):- provider.preflight_messages(request)+ provider.stream_messages(request)-def test_preflight_rejects_listed_server_tools_in_tools_list():+def test_startup_rejects_listed_server_tools_in_tools_list():request = MessagesRequest(model="m",messages=[Message(role="user", content="x")],@@ -960,10 +960,10 @@ def test_preflight_rejects_listed_server_tools_in_tools_list():admission=immediate_admission(),)with pytest.raises(InvalidRequestError, match="web_search"):- provider.preflight_messages(request)+ provider.stream_messages(request)-def test_preflight_preserves_completed_server_tool_history():+def test_startup_preserves_completed_server_tool_history():request = MessagesRequest.model_validate({"model": "m",@@ -996,7 +996,7 @@ def test_preflight_preserves_completed_server_tool_history():),admission=immediate_admission(),)- provider.preflight_messages(request)+ provider.stream_messages(request)body = provider._chat._build_request_body(request)assert "[Earlier tool record]" in body["messages"][0]["content"]diff --git a/tests/providers/test_github_copilot_provider.py b/tests/providers/test_github_copilot_provider.pyindex 23c9e089..d5be913b 100644--- a/tests/providers/test_github_copilot_provider.py+++ b/tests/providers/test_github_copilot_provider.py@@ -5,6 +5,7 @@ import jsonfrom collections.abc import AsyncIteratorfrom dataclasses import replacefrom pathlib import Path+from unittest.mock import patchimport httpximport httpx2@@ -37,6 +38,9 @@ from free_claude_code.core.reasoning import (from free_claude_code.providers.anthropic_messages.request_policy import (MessagesModelCapabilities,)+from free_claude_code.providers.anthropic_messages.transport import (+ AnthropicMessagesTransport,+)from free_claude_code.providers.endpoint import HttpEndpointfrom free_claude_code.providers.github_copilot.auth import CopilotAuthManagerfrom free_claude_code.providers.github_copilot.provider import GitHubCopilotProvider@@ -45,6 +49,10 @@ from free_claude_code.providers.github_copilot.types import (CopilotEndpoint,CopilotModel,)+from free_claude_code.providers.openai_chat import OpenAIChatTransport+from free_claude_code.providers.openai_responses.transport import (+ OpenAIResponsesTransport,+)from tests.providers.copilot_support import FakeRuntime, FakeSessionfrom tests.providers.support import immediate_admission, make_provider_configfrom tests.providers.test_anthropic_messages_transport import _events as messages_events@@ -58,6 +66,48 @@ from tests.providers.test_openai_responses_transport import ()[email protected]("egress", list(CopilotEgress))[email protected]("responses", [False, True])+async def test_conversion_runs_once_under_current_account_lease(+ tmp_path, egress, responses+):+ harness = Harness(tmp_path, egress)+ cls, name = {+ (CopilotEgress.CHAT, False): (OpenAIChatTransport, "_build_request_body"),+ (CopilotEgress.CHAT, True): (+ OpenAIChatTransport,+ "_build_responses_request_body",+ ),+ (CopilotEgress.RESPONSES, False): (+ OpenAIResponsesTransport,+ "_build_messages_body",+ ),+ (CopilotEgress.RESPONSES, True): (+ OpenAIResponsesTransport,+ "_build_native_body",+ ),+ (CopilotEgress.MESSAGES, False): (AnthropicMessagesTransport, "_messages_body"),+ (CopilotEgress.MESSAGES, True): (AnthropicMessagesTransport, "_responses_body"),+ }[egress, responses]+ original = getattr(cls, name)++ def build(transport, *args, **kwargs):+ assert harness.runtime.session_calls == 1+ assert not harness.runtime.sessions[0].closed+ assert harness.provider._active == 1+ assert harness.seen == []+ return original(transport, *args, **kwargs)++ try:+ with patch.object(cls, name, autospec=True, side_effect=build) as conversion:+ assert "ok" in await collect(harness.stream(responses))+ assert conversion.call_count == len(harness.seen) == 1+ assert harness.provider._active == 0+ finally:+ await harness.close()++class Wire(httpx.AsyncByteStream, httpx2.AsyncByteStream):def __init__(self, content: bytes) -> None:self.content = contentdiff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex 53b16e80..b56c7771 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -1,16 +1,23 @@"""Tests for LM Studio (OpenAI-compatible chat completions) provider."""+import asynciofrom unittest.mock import AsyncMock, MagicMock, patchimport httpximport pytestfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.application.execution import ProviderExecutorfrom free_claude_code.config.provider_catalog import LMSTUDIO_DEFAULT_BASE-from free_claude_code.core.anthropic import get_token_count+from free_claude_code.core.anthropic import MessagesRequest, get_token_countfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ estimate_responses_input_tokens,+)from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.lmstudio import LMStudioProvider+from tests.application.test_execution import _routed_request, _routed_responses_requestfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -36,7 +43,12 @@ def lmstudio_config():@pytest.fixturedef lmstudio_provider(lmstudio_config):- return LMStudioProvider(lmstudio_config, admission=immediate_admission())+ provider = LMStudioProvider(lmstudio_config, admission=immediate_admission())+ with patch(+ "free_claude_code.providers.lmstudio.client.httpx.get",+ side_effect=httpx.ConnectError("offline test"),+ ):+ yield providerdef test_init(lmstudio_config):@@ -113,55 +125,135 @@ def test_build_request_body_never_replays_prior_thinking(lmstudio_provider):assert "prior reasoning" in str(body)-def test_preflight_builds_before_context_budget_and_preserves_policy(- lmstudio_provider,[email protected]("wire", ["messages", "responses"])+def test_startup_builds_before_context_budget_and_preserves_policy(+ lmstudio_provider, wire):- request = make_request()- calls: list[tuple[str, object]] = []+ request = (+ make_request()+ if wire == "messages"+ else OpenAIResponsesRequest(model="model", input="hello")+ )+ calls = []+ name = (+ "_build_request_body" if wire == "messages" else "_build_responses_request_body"+ )+ original = getattr(lmstudio_provider._chat, name)- def build(request_arg, *, reasoning, model_info):+ def build(request_arg, *, reasoning):assert request_arg is request- assert model_info is Nonecalls.append(("build", reasoning))- return {}+ return original(request_arg, reasoning=reasoning)- def check_context(estimate: int):+ def check_context(estimate):calls.append(("context", estimate))with (- patch.object(lmstudio_provider._chat, "_build_request_body", side_effect=build),+ patch.object(lmstudio_provider._chat, name, side_effect=build),patch.object(- lmstudio_provider,- "_preflight_context_budget",- side_effect=check_context,+ lmstudio_provider, "_validate_context_budget", side_effect=check_context),+ patch.object(+ lmstudio_provider._chat._admission, "start_execution"+ ) as admission,):- lmstudio_provider.preflight_messages(request, reasoning=REASONING_OFF)-- assert calls == [- ("build", REASONING_OFF),- ("context", get_token_count(request.messages, request.system, request.tools)),- ]+ getattr(lmstudio_provider, f"stream_{wire}")(request, reasoning=REASONING_OFF)+ estimate = (+ get_token_count(request.messages, request.system, request.tools)+ if isinstance(request, MessagesRequest)+ else estimate_responses_input_tokens(request)+ )+ assert calls == [("build", REASONING_OFF), ("context", estimate)]+ admission.assert_not_called()-def test_preflight_conversion_failure_skips_context_budget(lmstudio_provider):- request = make_request()[email protected]("wire", ["messages", "responses"])+def test_startup_conversion_failure_skips_context_budget(lmstudio_provider, wire):+ request = (+ make_request()+ if wire == "messages"+ else OpenAIResponsesRequest(model="model", input="hello")+ )conversion_error = InvalidRequestError("invalid request conversion")with (patch.object(lmstudio_provider._chat,- "_build_request_body",+ "_build_request_body"+ if wire == "messages"+ else "_build_responses_request_body",side_effect=conversion_error,),- patch.object(lmstudio_provider, "_preflight_context_budget") as context,+ patch.object(lmstudio_provider, "_validate_context_budget") as context,pytest.raises(InvalidRequestError, match="invalid request conversion"),):- lmstudio_provider.preflight_messages(request, reasoning=REASONING_ON)+ getattr(lmstudio_provider, f"stream_{wire}")(request, reasoning=REASONING_ON)context.assert_not_called()[email protected]("wire", ["messages", "responses"])+def test_context_rejection_never_starts_admission_or_generation(+ lmstudio_provider, wire+):+ request = (+ make_request()+ if wire == "messages"+ else OpenAIResponsesRequest(model="model", input="hello")+ )+ with (+ patch.object(lmstudio_provider, "_loaded_context_length", return_value=1),+ patch.object(+ lmstudio_provider._chat._admission, "start_execution"+ ) as admission,+ patch.object(+ lmstudio_provider._client.chat.completions, "create"+ ) as generation,+ pytest.raises(ExecutionFailure) as error,+ ):+ getattr(lmstudio_provider, f"stream_{wire}")(request)+ assert error.value.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED+ admission.assert_not_called()+ generation.assert_not_called()++[email protected]("wire", ["messages", "responses"])+async def test_primary_context_validation_counts_toward_progress_timeout(+ lmstudio_provider, wire+):+ loop = asyncio.get_running_loop()+ now = loop.time()++ def slow_lookup():+ nonlocal now+ now += 2+ return 100_000++ executor = ProviderExecutor(lambda _: lmstudio_provider, progress_timeout_seconds=1)+ routed = _routed_request() if wire == "messages" else _routed_responses_request()+ with (+ patch.object(loop, "time", side_effect=lambda: now),+ patch.object(+ lmstudio_provider, "_loaded_context_length", side_effect=slow_lookup+ ),+ patch.object(+ lmstudio_provider._chat._admission, "start_execution"+ ) as admission,+ patch.object(+ lmstudio_provider._client.chat.completions, "create"+ ) as generation,+ ):+ stream = getattr(executor, f"stream_{wire}")(+ routed, raw_log_payload={}, request_id="context-timeout"+ )+ with pytest.raises(ExecutionFailure) as error:+ await anext(stream)+ assert error.value.kind is FailureKind.TIMEOUT+ admission.assert_not_called()+ generation.assert_not_called()++@pytest.mark.asyncioasync def test_stream_messages_text(lmstudio_provider):"""Text content deltas are emitted through the shared OpenAI-chat provider."""@@ -242,29 +334,29 @@ async def test_cleanup(lmstudio_provider):await lmstudio_provider.cleanup()-# --- Context-budget preflight (new: guards against LM Studio's silent+# --- Context-budget validation (new: guards against LM Studio's silent# mid-stream truncation when a prompt exceeds the loaded model's context) ----def test_preflight_context_budget_noop_when_context_length_unknown(lmstudio_provider):- """No LM Studio /api/v0/models data available -> preflight is a no-op (fail open)."""+def test_validate_context_budget_noop_when_context_length_unknown(lmstudio_provider):+ """No LM Studio /api/v0/models data available -> validation is a no-op (fail open)."""with patch.object(lmstudio_provider, "_loaded_context_length", return_value=None):- lmstudio_provider._preflight_context_budget(1) # must not raise+ lmstudio_provider._validate_context_budget(1) # must not raise-def test_preflight_context_budget_allows_request_under_budget(lmstudio_provider):+def test_validate_context_budget_allows_request_under_budget(lmstudio_provider):with patch.object(lmstudio_provider, "_loaded_context_length", return_value=100_000):- lmstudio_provider._preflight_context_budget(1) # must not raise+ lmstudio_provider._validate_context_budget(1) # must not raise-def test_preflight_context_budget_rejects_request_over_90_percent(lmstudio_provider):+def test_validate_context_budget_rejects_request_over_90_percent(lmstudio_provider):with (patch.object(lmstudio_provider, "_loaded_context_length", return_value=1000),pytest.raises(ExecutionFailure) as exc_info,):- lmstudio_provider._preflight_context_budget(901)+ lmstudio_provider._validate_context_budget(901)failure = exc_info.valueassert failure.kind is FailureKind.CONTEXT_WINDOW_EXCEEDEDdiff --git a/tests/providers/test_model_discovery.py b/tests/providers/test_model_discovery.pyindex 7d2b9028..5e51b026 100644--- a/tests/providers/test_model_discovery.py+++ b/tests/providers/test_model_discovery.py@@ -354,23 +354,6 @@ class FakeProvider(BaseProvider):self.cleaned = Falseself.model_list_calls = 0- def preflight_messages(- self,- request: Any,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- model_info: ProviderModelInfo | None = None,- ) -> None:- return None-- def preflight_responses(- self,- request: Any,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- return None-async def cleanup(self) -> None:self.cleaned = Truediff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.pyindex caa8b6b3..133b76f3 100644--- a/tests/providers/test_nvidia_nim.py+++ b/tests/providers/test_nvidia_nim.py@@ -497,7 +497,7 @@ async def test_build_request_body_omits_reasoning_when_request_disables_thinkingassert "reasoning_budget" not in extra-def test_preflight_and_build_request_issue_206_post_tool_text(nim_provider):+def test_startup_and_build_request_issue_206_post_tool_text(nim_provider):"""Regression: assistant message with tool_use then text plus tool results (GitHub #206)."""tool_id = "toolu_issue_206"req = make_request(@@ -527,7 +527,7 @@ def test_preflight_and_build_request_issue_206_post_tool_text(nim_provider):),],)- nim_provider.preflight_messages(req, reasoning=REASONING_OFF)+ nim_provider.stream_messages(req, reasoning=REASONING_OFF)body = nim_provider._chat._build_request_body(req, reasoning=REASONING_OFF)assert "messages" in bodyassert any(m.get("role") == "tool" for m in body["messages"])diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.pyindex 1052c555..87f1801e 100644--- a/tests/providers/test_openai_codex_provider.py+++ b/tests/providers/test_openai_codex_provider.py@@ -440,17 +440,14 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> Noriginal_request = request.model_dump()reasoning = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)- provider.preflight_messages(request, reasoning=reasoning)- assert requests == []-- body = await _collect(- provider.stream_messages(- request,- request_id="req_client_controls",- response_model="claude-opus-4",- reasoning=reasoning,- )+ stream = provider.stream_messages(+ request,+ request_id="req_client_controls",+ response_model="claude-opus-4",+ reasoning=reasoning,)+ assert requests == []+ body = await _collect(stream)assert len(requests) == 1upstream = requests[0]@@ -487,15 +484,13 @@ async def test_provider_relays_native_responses_with_private_field_policy() -> Nrequest = _responses_request()original = request.model_dump()- provider.preflight_responses(request)- assert requests == []- body = await _collect(- provider.stream_responses(- request,- request_id="req_native_responses",- response_model="openai/gpt-test",- )+ stream = provider.stream_responses(+ request,+ request_id="req_native_responses",+ response_model="openai/gpt-test",)+ assert requests == []+ body = await _collect(stream)assert len(requests) == 1upstream = json.loads(requests[0].content)@@ -545,7 +540,7 @@ async def test_provider_relays_native_responses_with_private_field_policy() -> N),],)-async def test_provider_preflight_rejects_unrepresentable_client_controls(+async def test_provider_validation_rejects_unrepresentable_client_controls(field: str,value: object,error_path: str,@@ -567,7 +562,7 @@ async def test_provider_preflight_rejects_unrepresentable_client_controls(}with pytest.raises(InvalidRequestError, match=error_path):- provider.preflight_messages(MessagesRequest.model_validate(payload))+ provider.stream_messages(MessagesRequest.model_validate(payload))assert requests == []await provider.cleanup()diff --git a/tests/providers/test_openai_responses_transport.py b/tests/providers/test_openai_responses_transport.pyindex 103adbe9..ca4c4e29 100644--- a/tests/providers/test_openai_responses_transport.py+++ b/tests/providers/test_openai_responses_transport.py@@ -1141,14 +1141,20 @@ async def test_cancellation_closes_the_sdk_stream() -> None:@pytest.mark.asyncio-async def test_preflight_rejects_fields_responses_cannot_represent() -> None:+async def test_startup_rejects_fields_responses_cannot_represent() -> None:client = _client(lambda _request: httpx2.Response(500))transport = _transport(client)request = _request(stop_sequences=["done"])try:with pytest.raises(InvalidRequestError, match="stop_sequences"):- transport.preflight_messages(request, reasoning=REASONING_ON)+ transport.stream_messages(+ request,+ input_tokens=0,+ request_id=None,+ response_model=request.model,+ reasoning=REASONING_ON,+ )finally:await client.close()diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.pyindex 12951dd9..2c288f1f 100644--- a/tests/providers/test_opencode.py+++ b/tests/providers/test_opencode.py@@ -722,7 +722,6 @@ async def test_responses_tool_search_accepts_optional_codex_arguments() -> None:)try:await provider.list_model_infos()- provider.preflight_responses(request)body = "".join([chunk async for chunk in provider.stream_responses(request)])finally:await provider.cleanup()@@ -1216,18 +1215,16 @@ async def test_cold_route_specific_conversion_failure_precedes_generation() -> N@pytest.mark.asyncio-async def test_warm_preflight_rejects_unknown_and_route_specific_fields() -> None:+async def test_warm_startup_rejects_unknown_and_route_specific_fields() -> None:provider, generation_requests, _catalog_requests = _provider_with_wire_transports(_catalog_payload())try:await provider.list_model_infos()with pytest.raises(InvalidRequestError, match="does not advertise"):- provider.preflight_messages(_request("missing"))+ await _collect(provider, "missing")with pytest.raises(InvalidRequestError, match="stop_sequences"):- provider.preflight_messages(- _request("responses-selector", stop_sequences=["done"])- )+ await _collect(provider, "responses-selector", stop_sequences=["done"])finally:await provider.cleanup()diff --git a/tests/providers/test_preflight_contract.py b/tests/providers/test_stream_startup_contract.pysimilarity index 51%rename from tests/providers/test_preflight_contract.pyrename to tests/providers/test_stream_startup_contract.pyindex 561903a5..20ea4589 100644--- a/tests/providers/test_preflight_contract.py+++ b/tests/providers/test_stream_startup_contract.py@@ -1,15 +1,10 @@-"""The shared OpenAI-chat provider owns explicit request preflight."""+"""The shared OpenAI-chat provider owns request conversion during stream construction."""-from collections.abc import AsyncIterator, Mappingfrom unittest.mock import MagicMock-import pytest--from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import Message, MessagesRequestfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy-from free_claude_code.providers.base import BaseProviderfrom free_claude_code.providers.openai_chat import (NO_REASONING,OpenAIChatBehavior,@@ -40,40 +35,7 @@ class RecordingChatBehavior(OpenAIChatBehavior):return {}-class ProviderWithoutPreflight(BaseProvider):- async def cleanup(self) -> None:- return None-- async def list_model_infos(self) -> frozenset[ProviderModelInfo]:- return frozenset()-- async def stream_messages(- self,- request: MessagesRequest,- input_tokens: int = 0,- *,- request_id: str | None = None,- 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 ""---def test_provider_base_requires_an_explicit_preflight_implementation() -> None:- with pytest.raises(TypeError, match="preflight_messages"):- ProviderWithoutPreflight(- make_provider_config(api_key="test", base_url="https://test.invalid")- )---def test_openai_provider_owns_preflight() -> None:- assert OpenAIChatProvider.preflight_messages is not BaseProvider.preflight_messages---def test_provider_preflight_calls_builder_and_preserves_policy() -> None:+def test_provider_stream_constructor_calls_builder_and_preserves_policy() -> None:behavior = RecordingChatBehavior()provider = OpenAIChatProvider(make_provider_config(api_key="test", base_url="https://test.invalid"),@@ -86,6 +48,6 @@ def test_provider_preflight_calls_builder_and_preserves_policy() -> None:messages=[Message(role="user", content="hello")],)- provider.preflight_messages(request, reasoning=ReasoningPolicy.off())+ provider.stream_messages(request, reasoning=ReasoningPolicy.off())assert behavior.build_calls == [(request, ReasoningPolicy.off())]diff --git a/tests/runtime/test_application_runtime.py b/tests/runtime/test_application_runtime.pyindex 47cb67ac..6b2179cb 100644--- a/tests/runtime/test_application_runtime.py+++ b/tests/runtime/test_application_runtime.py@@ -65,23 +65,6 @@ class AdminModelProvider(BaseProvider):self._model_infos = model_infosself._error = error- def preflight_messages(- self,- request: MessagesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- model_info: ProviderModelInfo | None = None,- ) -> None:- return None-- def preflight_responses(- self,- request: OpenAIResponsesRequest,- *,- reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> None:- return None-async def cleanup(self) -> None:return Nonediff --git a/uv.lock b/uv.lockindex 497ab6e2..79590d58 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "6.2.20"+version = "6.2.21"source = { editable = "." }dependencies = [{ name = "aiohttp" },