Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

Canonicalize request ingress (#1542)

Ali Khokhare508efa201ca
diff --git a/e2e/conftest.py b/e2e/conftest.py
index a32e8a66..fe5e231f 100644
--- a/e2e/conftest.py
+++ b/e2e/conftest.py
@@ -16,8 +16,11 @@ from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config import env_migrations, paths
from free_claude_code.config.env_migrations import recognized_env_keys
from free_claude_code.config.loader import clear_settings_cache, get_settings
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ InferenceStreamLedger,
+)
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.base import BaseProvider, ProviderConfig
from free_claude_code.providers.runtime import ProviderRuntime
@@ -52,8 +55,9 @@ class _ModelListingProvider(BaseProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
return None
@@ -68,9 +72,10 @@ class _ModelListingProvider(BaseProvider):
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
diff --git a/pyproject.toml b/pyproject.toml
index ca921ecd..d25a09c6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "free-claude-code"
-version = "5.14.2"
+version = "5.14.3"
description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"
readme = "README.md"
requires-python = ">=3.14.0"
diff --git a/smoke/lib/config.py b/smoke/lib/config.py
index 55f61d55..ddd22d3c 100644
--- a/smoke/lib/config.py
+++ b/smoke/lib/config.py
@@ -71,7 +71,7 @@ PROVIDER_SMOKE_DEFAULT_MODELS: dict[str, str] = {
"zai_api": "zai_api/glm-4.7-flash",
"gemini": "gemini/models/gemini-3.1-flash-lite",
"vertex": "vertex/google/gemini-3.5-flash",
- "groq": "groq/llama-3.3-70b-versatile",
+ "groq": "groq/openai/gpt-oss-120b",
"cline_pass": "cline_pass/cline-pass/deepseek-v4-flash",
"xai": "xai/grok-4.5",
"qwencloud": "qwencloud/qwen3.7-plus",
diff --git a/src/free_claude_code/api/handlers/messages.py b/src/free_claude_code/api/handlers/messages.py
index 4547b52f..468b115a 100644
--- a/src/free_claude_code/api/handlers/messages.py
+++ b/src/free_claude_code/api/handlers/messages.py
@@ -39,7 +39,7 @@ from free_claude_code.api.web_tools.streaming import stream_web_server_tool_resp
from free_claude_code.application.errors import ApplicationError, InvalidRequestError
from free_claude_code.application.execution import ProviderExecutor, TokenCounter
from free_claude_code.application.ports import ProviderResolver
-from free_claude_code.application.routing import ModelRouter, RoutedMessagesRequest
+from free_claude_code.application.routing import ModelRouter, RoutedInferenceRequest
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import (
MessagesRequest,
@@ -49,12 +49,17 @@ from free_claude_code.core.anthropic import (
anthropic_error_type_for_failure,
anthropic_failure_payload,
anthropic_status_for_error_type,
- get_token_count,
iter_anthropic_sse,
+ messages_to_inference_request,
+ validate_messages_field_policy,
)
from free_claude_code.core.diagnostics import safe_exception_message
from free_claude_code.core.failures import ExecutionFailure, find_execution_failure
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ get_inference_token_count,
+)
from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
from free_claude_code.core.trace import trace_event
@@ -77,7 +82,7 @@ class _MessagesCompleteResult:
_MessagesResult = (
_MessagesEventResult | _MessagesWireStreamResult | _MessagesCompleteResult
)
-MessageIntercept = Callable[[RoutedMessagesRequest], _MessagesResult | None]
+MessageIntercept = Callable[[MessagesRequest], _MessagesResult | None]
class MessagesHandler:
@@ -89,7 +94,7 @@ class MessagesHandler:
provider_resolver: ProviderResolver,
*,
model_router: ModelRouter | None = None,
- token_counter: TokenCounter = get_token_count,
+ token_counter: TokenCounter = get_inference_token_count,
provider_executor: ProviderExecutor | None = None,
generation_id: int | None = None,
) -> None:
@@ -115,32 +120,47 @@ class MessagesHandler:
request_id = request_id or new_request_id()
try:
require_non_empty_messages(request_data.messages)
- routed = self._model_router.resolve_messages_request(request_data)
- routed = self._apply_message_routing_policies(routed)
+ self._validate_wire_request(request_data)
automatic_search = plan_automatic_web_search(
- routed.request,
+ request_data,
web_tools_enabled=self._settings.enable_web_server_tools,
)
if automatic_search is None:
- self._reject_unsupported_server_tools(routed)
- result = self._run_message_intercepts(routed)
- else:
- input_tokens = self._token_counter(
- routed.request.messages,
- routed.request.system,
- routed.request.tools,
- )
+ self._reject_unsupported_server_tools(request_data)
+ result = self._run_message_intercepts(request_data)
+ if result is not None:
+ return await self._to_public_response(
+ result,
+ stream=request_data.stream,
+ request_id=request_id,
+ )
+
+ canonical = self._canonical_request(
+ automatic_search.request
+ if automatic_search is not None
+ else request_data
+ )
+ routed = self._model_router.resolve_inference_request(canonical)
+ routed = self._apply_message_routing_policies(
+ routed,
+ classifier_stop_sequence=detect_safety_classifier_stop_sequence(
+ request_data
+ ),
+ )
+ if automatic_search is not None:
result = _MessagesWireStreamResult(
stream_automatic_web_search_response(
self._provider_executor,
routed,
automatic_search,
request_id=request_id,
- fallback_input_tokens=input_tokens,
+ fallback_input_tokens=self._token_counter(routed.request),
verbose_client_errors=self._settings.log_api_error_tracebacks,
log_raw_events=self._settings.log_raw_sse_events,
)
)
+ else:
+ result = None
if result is None:
logger.debug("No optimization matched, routing to provider")
result = _MessagesEventResult(
@@ -148,7 +168,7 @@ class MessagesHandler:
routed,
wire_api="messages",
raw_log_label="FULL_PAYLOAD",
- raw_log_payload=routed.request.model_dump(),
+ raw_log_payload=request_data.model_dump(),
request_id=request_id,
)
)
@@ -318,33 +338,43 @@ class MessagesHandler:
),
)
- def _reject_unsupported_server_tools(self, routed: RoutedMessagesRequest) -> None:
+ @staticmethod
+ def _validate_wire_request(request: MessagesRequest) -> None:
+ try:
+ validate_messages_field_policy(request)
+ except ValueError as exc:
+ raise InvalidRequestError(str(exc)) from exc
+
+ @staticmethod
+ def _canonical_request(request: MessagesRequest) -> InferenceRequest:
+ try:
+ return messages_to_inference_request(request)
+ except ValueError as exc:
+ raise InvalidRequestError(str(exc)) from exc
+
+ def _reject_unsupported_server_tools(self, request: MessagesRequest) -> None:
tool_err = unsupported_server_tool_error(
- routed.request,
+ request,
web_tools_enabled=self._settings.enable_web_server_tools,
)
if tool_err is not None:
raise InvalidRequestError(tool_err)
def _apply_message_routing_policies(
- self, routed: RoutedMessagesRequest
- ) -> RoutedMessagesRequest:
- classifier_stop_sequence = detect_safety_classifier_stop_sequence(
- routed.request
- )
+ self,
+ routed: RoutedInferenceRequest,
+ *,
+ classifier_stop_sequence: str | None,
+ ) -> RoutedInferenceRequest:
if classifier_stop_sequence is None:
return routed
reasoning_changed = routed.reasoning.control is not ReasoningControl.OFF
stop_sequences = routed.request.stop_sequences
- remaining_stop_sequences = (
- [
- stop_sequence
- for stop_sequence in stop_sequences
- if stop_sequence != classifier_stop_sequence
- ]
- if stop_sequences is not None
- else None
+ remaining_stop_sequences = tuple(
+ stop_sequence
+ for stop_sequence in stop_sequences
+ if stop_sequence != classifier_stop_sequence
)
stop_sequence_removed = remaining_stop_sequences != stop_sequences
trace_event(
@@ -361,9 +391,7 @@ class MessagesHandler:
request = routed.request
if stop_sequence_removed:
- request = request.model_copy(
- update={"stop_sequences": remaining_stop_sequences or None}
- )
+ request = request.with_stop_sequences(remaining_stop_sequences)
return replace(
routed,
request=request,
@@ -373,30 +401,32 @@ class MessagesHandler:
)
def _run_message_intercepts(
- self, routed: RoutedMessagesRequest
+ self, request: MessagesRequest
) -> _MessagesResult | None:
for intercept in self._message_intercepts:
- result = intercept(routed)
+ result = intercept(request)
if result is not None:
return result
return None
def _intercept_web_server_tool(
- self, routed: RoutedMessagesRequest
+ self, request: MessagesRequest
) -> _MessagesResult | None:
if not self._settings.enable_web_server_tools:
return None
- if not is_web_server_tool_request(routed.request):
+ if not is_web_server_tool_request(request):
return None
- input_tokens = self._token_counter(
- routed.request.messages, routed.request.system, routed.request.tools
+ token_request = request.model_copy(
+ update={"tools": None, "tool_choice": None},
+ deep=True,
)
+ input_tokens = self._token_counter(self._canonical_request(token_request))
trace_event(
stage="routing",
event="free_claude_code.api.optimization.web_server_tool",
source="api",
- model=routed.resolved.original_model,
+ model=request.model,
)
egress = WebFetchEgressPolicy(
allow_private_network_targets=self._settings.web_fetch_allow_private_networks,
@@ -406,21 +436,21 @@ class MessagesHandler:
)
return _MessagesWireStreamResult(
stream_web_server_tool_response(
- routed.request,
+ request,
input_tokens=input_tokens,
web_fetch_egress=egress,
- response_model=routed.resolved.original_model,
+ response_model=request.model,
verbose_client_errors=self._settings.log_api_error_tracebacks,
),
)
def _intercept_local_optimization(
- self, routed: RoutedMessagesRequest
+ self, request: MessagesRequest
) -> _MessagesResult | None:
optimized = try_optimizations(
- routed.request,
+ request,
self._settings,
- response_model=routed.resolved.original_model,
+ response_model=request.model,
)
if optimized is None:
return None
@@ -428,7 +458,7 @@ class MessagesHandler:
stage="routing",
event="free_claude_code.api.optimization.short_circuit",
source="api",
- model=routed.resolved.original_model,
+ model=request.model,
)
return _MessagesCompleteResult(optimized)
diff --git a/src/free_claude_code/api/handlers/responses.py b/src/free_claude_code/api/handlers/responses.py
index ac0eda59..d2e9380d 100644
--- a/src/free_claude_code/api/handlers/responses.py
+++ b/src/free_claude_code/api/handlers/responses.py
@@ -6,7 +6,6 @@ from free_claude_code.api.request_errors import (
http_status_for_unexpected_api_exception,
log_unexpected_api_exception,
ordinary_application_error_response,
- require_non_empty_messages,
)
from free_claude_code.api.request_ids import new_request_id
from free_claude_code.api.response_streams import (
@@ -19,15 +18,17 @@ from free_claude_code.application.execution import ProviderExecutor
from free_claude_code.application.ports import ProviderResolver
from free_claude_code.application.routing import ModelRouter
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import MessagesRequest
from free_claude_code.core.diagnostics import safe_exception_message
from free_claude_code.core.failures import ExecutionFailure, find_execution_failure
from free_claude_code.core.openai_responses import (
- OpenAIResponsesAdapter,
+ OPENAI_RESPONSES_SSE_HEADERS,
OpenAIResponsesRequest,
+ ResponsesConversionError,
iter_responses_sse_from_events,
+ openai_error_payload,
openai_error_type_for_failure,
openai_failure_payload,
+ responses_to_inference_request,
)
@@ -40,13 +41,11 @@ class ResponsesHandler:
provider_resolver: ProviderResolver,
*,
model_router: ModelRouter | None = None,
- responses_adapter: OpenAIResponsesAdapter | None = None,
provider_executor: ProviderExecutor | None = None,
generation_id: int | None = None,
) -> None:
self._settings = settings
self._model_router = model_router or ModelRouter(settings)
- self._responses_adapter = responses_adapter or OpenAIResponsesAdapter()
self._provider_executor = provider_executor or ProviderExecutor(
provider_resolver,
progress_timeout_seconds=settings.provider_progress_timeout,
@@ -66,12 +65,8 @@ class ResponsesHandler:
)
try:
- anthropic_payload = self._responses_adapter.to_anthropic_payload(
- request_data
- )
- response_request = MessagesRequest(**anthropic_payload)
- require_non_empty_messages(response_request.messages)
- routed = self._model_router.resolve_messages_request(response_request)
+ ingress = responses_to_inference_request(request_data)
+ routed = self._model_router.resolve_inference_request(ingress.request)
streamed = self._provider_executor.stream(
routed,
@@ -83,7 +78,7 @@ class ResponsesHandler:
return await openai_responses_sse_streaming_response(
iter_responses_sse_from_events(
streamed,
- request_data,
+ ingress.presentation,
on_post_start_terminal_failure=lambda exc: (
self._trace_post_start_terminal_failure(
exc,
@@ -91,12 +86,12 @@ class ResponsesHandler:
)
),
),
- headers=self._responses_adapter.sse_headers,
+ headers=OPENAI_RESPONSES_SSE_HEADERS,
pre_start_error_response=lambda exc: self._pre_start_error_response(
exc, request_id=request_id
),
)
- except OpenAIResponsesAdapter.ConversionError as exc:
+ except ResponsesConversionError as exc:
raise InvalidRequestError(str(exc)) from exc
except ApplicationError:
raise
@@ -113,7 +108,7 @@ class ResponsesHandler:
)
return JSONResponse(
status_code=http_status_for_unexpected_api_exception(exc),
- content=self._responses_adapter.error_payload(
+ content=openai_error_payload(
message=safe_exception_message(exc),
error_type="api_error",
),
@@ -147,7 +142,7 @@ class ResponsesHandler:
)
return terminal_execution_error_response(
status_code=status_code,
- content=self._responses_adapter.error_payload(
+ content=openai_error_payload(
message=safe_exception_message(exc),
error_type="api_error",
),
diff --git a/src/free_claude_code/api/handlers/token_count.py b/src/free_claude_code/api/handlers/token_count.py
index f2bea621..dc3d53ef 100644
--- a/src/free_claude_code/api/handlers/token_count.py
+++ b/src/free_claude_code/api/handlers/token_count.py
@@ -9,17 +9,20 @@ from free_claude_code.api.request_errors import (
require_non_empty_messages,
)
from free_claude_code.api.request_ids import new_request_id
-from free_claude_code.application.errors import ApplicationError
+from free_claude_code.application.errors import ApplicationError, InvalidRequestError
from free_claude_code.application.execution import TokenCounter
from free_claude_code.application.routing import ModelRouter
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import (
TokenCountRequest,
TokenCountResponse,
- anthropic_request_snapshot,
- get_token_count,
+ token_count_to_inference_request,
)
from free_claude_code.core.diagnostics import safe_exception_message
+from free_claude_code.core.inference import (
+ get_inference_token_count,
+ inference_request_snapshot,
+)
from free_claude_code.core.trace import trace_event
@@ -31,7 +34,7 @@ class TokenCountHandler:
settings: Settings,
*,
model_router: ModelRouter | None = None,
- token_counter: TokenCounter = get_token_count,
+ token_counter: TokenCounter = get_inference_token_count,
) -> None:
self._settings = settings
self._model_router = model_router or ModelRouter(settings)
@@ -45,10 +48,12 @@ class TokenCountHandler:
with logger.contextualize(request_id=request_id):
try:
require_non_empty_messages(request_data.messages)
- routed = self._model_router.resolve_token_count_request(request_data)
- tokens = self._token_counter(
- routed.request.messages, routed.request.system, routed.request.tools
- )
+ try:
+ canonical = token_count_to_inference_request(request_data)
+ except ValueError as exc:
+ raise InvalidRequestError(str(exc)) from exc
+ routed = self._model_router.resolve_token_count_request(canonical)
+ tokens = self._token_counter(routed.request)
trace_event(
stage="routing",
event="free_claude_code.api.route.resolved",
@@ -60,14 +65,13 @@ class TokenCountHandler:
provider_model_ref=routed.resolved.primary.provider_model_ref,
gateway_model=routed.resolved.original_model,
)
- request_snapshot = anthropic_request_snapshot(routed.request)
- request_snapshot["model"] = routed.resolved.original_model
+ request_snapshot = inference_request_snapshot(routed.request)
trace_event(
stage="ingress",
event="free_claude_code.api.count_tokens.completed",
source="api",
request_id=request_id,
- message_count=len(routed.request.messages),
+ message_count=routed.request.message_count,
input_tokens=tokens,
snapshot=request_snapshot,
)
diff --git a/src/free_claude_code/api/routes.py b/src/free_claude_code/api/routes.py
index e1db53bb..57bc7c6b 100644
--- a/src/free_claude_code/api/routes.py
+++ b/src/free_claude_code/api/routes.py
@@ -10,8 +10,8 @@ from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import (
MessagesRequest,
TokenCountRequest,
- get_token_count,
)
+from free_claude_code.core.inference import get_inference_token_count
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.trace import trace_event
@@ -51,7 +51,7 @@ async def _create_messages_response(
handler = MessagesHandler(
lease.settings,
provider_resolver=_provider_resolver(lease),
- token_counter=get_token_count,
+ token_counter=get_inference_token_count,
generation_id=lease.generation_id,
)
response = await handler.create(request_data, request_id=request_id)
@@ -154,7 +154,7 @@ async def count_tokens(
_auth=Depends(require_proxy_auth),
):
"""Count tokens for a request."""
- handler = TokenCountHandler(settings, token_counter=get_token_count)
+ handler = TokenCountHandler(settings, token_counter=get_inference_token_count)
return handler.count(request_data, request_id=get_request_id(request))
diff --git a/src/free_claude_code/api/web_tools/automatic_search.py b/src/free_claude_code/api/web_tools/automatic_search.py
index 6652ce16..1ee25e7f 100644
--- a/src/free_claude_code/api/web_tools/automatic_search.py
+++ b/src/free_claude_code/api/web_tools/automatic_search.py
@@ -2,11 +2,10 @@
import sys
from collections.abc import AsyncIterator, Mapping
-from dataclasses import replace
from urllib.parse import urlsplit
from free_claude_code.application.execution import ProviderExecutor
-from free_claude_code.application.routing import RoutedMessagesRequest
+from free_claude_code.application.routing import RoutedInferenceRequest
from free_claude_code.core.anthropic import (
aggregate_inference_events_to_message,
iter_anthropic_sse,
@@ -25,7 +24,7 @@ from .streaming import stream_selected_web_search_response
async def stream_automatic_web_search_response(
provider_executor: ProviderExecutor,
- routed: RoutedMessagesRequest,
+ routed: RoutedInferenceRequest,
plan: AutomaticWebSearchPlan,
*,
request_id: str,
@@ -34,7 +33,6 @@ async def stream_automatic_web_search_response(
log_raw_events: bool,
) -> AsyncIterator[str]:
"""Buffer one model decision, then replay it or execute one local search."""
- translated = replace(routed, request=plan.request)
trace_event(
stage="routing",
event="free_claude_code.api.web_search.automatic_recognized",
@@ -43,7 +41,7 @@ async def stream_automatic_web_search_response(
model=routed.resolved.original_model,
)
provider_stream = provider_executor.stream(
- translated,
+ routed,
wire_api="messages",
raw_log_label="FULL_PAYLOAD",
raw_log_payload=plan.request.model_dump(),
diff --git a/src/free_claude_code/application/execution.py b/src/free_claude_code/application/execution.py
index 42bf552b..ad105e08 100644
--- a/src/free_claude_code/application/execution.py
+++ b/src/free_claude_code/application/execution.py
@@ -8,15 +8,14 @@ from typing import Literal
from loguru import logger
-from free_claude_code.core.anthropic import (
- Message,
- SystemContent,
- Tool,
- anthropic_request_snapshot,
- get_token_count,
-)
from free_claude_code.core.failures import ExecutionFailure, FailureKind
-from free_claude_code.core.inference import InferenceEvent, inference_event_size
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ get_inference_token_count,
+ inference_event_size,
+ inference_request_snapshot,
+)
from free_claude_code.core.trace import (
close_stream_input,
trace_event,
@@ -24,24 +23,21 @@ from free_claude_code.core.trace import (
)
from .ports import ProviderResolver
-from .routing import ProviderModelTarget, RoutedMessagesRequest
+from .routing import ProviderModelTarget, RoutedInferenceRequest
-TokenCounter = Callable[
- [list[Message], str | list[SystemContent] | None, list[Tool] | None],
- int,
-]
+TokenCounter = Callable[[InferenceRequest], int]
WireApi = Literal["messages", "responses"]
class ProviderExecutor:
- """Resolve a provider and execute one routed Anthropic Messages stream."""
+ """Resolve a provider and execute one routed canonical inference stream."""
def __init__(
self,
provider_resolver: ProviderResolver,
*,
progress_timeout_seconds: float,
- token_counter: TokenCounter = get_token_count,
+ token_counter: TokenCounter = get_inference_token_count,
generation_id: int | None = None,
log_raw_payloads: bool = False,
) -> None:
@@ -143,7 +139,7 @@ class ProviderExecutor:
def stream(
self,
- routed: RoutedMessagesRequest,
+ routed: RoutedInferenceRequest,
*,
wire_api: WireApi,
raw_log_label: str,
@@ -153,9 +149,9 @@ class ProviderExecutor:
"""Preflight synchronously, then return the traced provider stream."""
primary = routed.resolved.primary
primary_provider = self._provider_resolver(primary.provider_id)
- primary_request = routed.request.model_copy(deep=True)
primary_provider.preflight_stream(
- primary_request,
+ routed.request,
+ provider_model=primary.provider_model,
reasoning=routed.reasoning,
)
candidates = (primary, *routed.resolved.fallbacks)
@@ -185,8 +181,7 @@ class ProviderExecutor:
route_trace["generation_id"] = self._generation_id
trace_event(**route_trace)
- request_snapshot = anthropic_request_snapshot(routed.request)
- request_snapshot["model"] = gateway_model
+ request_snapshot = inference_request_snapshot(routed.request)
trace_event(
stage="ingress",
event=(
@@ -195,7 +190,7 @@ class ProviderExecutor:
else "free_claude_code.api.request.received"
),
source="api",
- message_count=len(routed.request.messages),
+ message_count=routed.request.message_count,
snapshot=request_snapshot,
request_id=request_id,
)
@@ -203,11 +198,7 @@ class ProviderExecutor:
if self._log_raw_payloads:
logger.debug(f"{raw_log_label} [{{}}]: {{}}", request_id, raw_log_payload)
- input_tokens = self._token_counter(
- routed.request.messages,
- routed.request.system,
- routed.request.tools,
- )
+ input_tokens = self._token_counter(routed.request)
async def provider_body() -> AsyncIterator[InferenceEvent]:
loop = asyncio.get_running_loop()
@@ -218,17 +209,10 @@ class ProviderExecutor:
if index == 0
else self._provider_resolver(target.provider_id)
)
- candidate_request = (
- primary_request
- if index == 0
- else routed.request.model_copy(
- update={"model": target.provider_model},
- deep=True,
- )
- )
if index > 0:
provider.preflight_stream(
- candidate_request,
+ routed.request,
+ provider_model=target.provider_model,
reasoning=routed.reasoning,
)
@@ -237,7 +221,8 @@ class ProviderExecutor:
advance_failure: ExecutionFailure | None = None
try:
provider_stream = provider.stream_response(
- candidate_request,
+ routed.request,
+ provider_model=target.provider_model,
input_tokens=input_tokens,
request_id=request_id,
response_model=gateway_model,
diff --git a/src/free_claude_code/application/ports.py b/src/free_claude_code/application/ports.py
index 3e8b8196..d0aa03f7 100644
--- a/src/free_claude_code/application/ports.py
+++ b/src/free_claude_code/application/ports.py
@@ -5,8 +5,7 @@ from dataclasses import dataclass
from typing import Protocol
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import MessagesRequest
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import InferenceEvent, InferenceRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from .model_metadata import ProviderModelInfo
@@ -17,15 +16,17 @@ class ProviderPort(Protocol):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None: ...
def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
input_tokens: int,
request_id: str,
response_model: str,
diff --git a/src/free_claude_code/application/reasoning.py b/src/free_claude_code/application/reasoning.py
index 14a5411b..dd0708d4 100644
--- a/src/free_claude_code/application/reasoning.py
+++ b/src/free_claude_code/application/reasoning.py
@@ -1,9 +1,7 @@
"""Resolve client reasoning input and FCC configuration exactly once."""
-from collections.abc import Mapping
-
from free_claude_code.config.reasoning import ReasoningPreference
-from free_claude_code.core.anthropic.models import MessagesRequest, ThinkingConfig
+from free_claude_code.core.inference import ClientReasoningIntent
from free_claude_code.core.reasoning import (
ReasoningControl,
ReasoningEffort,
@@ -12,7 +10,7 @@ from free_claude_code.core.reasoning import (
def resolve_reasoning_policy(
- request: MessagesRequest,
+ intent: ClientReasoningIntent,
preference: ReasoningPreference,
) -> ReasoningPolicy:
"""Apply one resolved configuration preference to the client request."""
@@ -23,76 +21,23 @@ def resolve_reasoning_policy(
return ReasoningPolicy.off()
if preference is not ReasoningPreference.CLIENT:
return ReasoningPolicy.on(effort=ReasoningEffort(preference.value))
- return client_reasoning_policy(request)
+ return client_reasoning_policy(intent)
-def client_reasoning_policy(request: MessagesRequest) -> ReasoningPolicy:
+def client_reasoning_policy(intent: ClientReasoningIntent) -> ReasoningPolicy:
"""Return the lossless reasoning intent expressed by one client request."""
- budget_tokens = _positive_budget(request.thinking)
- thinking_control = _thinking_control(
- request.thinking,
- budget_tokens=budget_tokens,
- )
- effort, effort_disables = _output_effort(request.output_config)
-
- if effort_disables:
- return ReasoningPolicy.off()
- if thinking_control is ReasoningControl.OFF:
+ if intent.control is ReasoningControl.OFF:
return ReasoningPolicy(
control=ReasoningControl.OFF,
- effort=effort,
+ effort=intent.effort,
)
- if thinking_control is ReasoningControl.ON or budget_tokens is not None:
+ if intent.control is ReasoningControl.ON or intent.budget_tokens is not None:
return ReasoningPolicy.on(
- effort=effort,
- budget_tokens=budget_tokens,
+ effort=intent.effort,
+ budget_tokens=intent.budget_tokens,
)
return ReasoningPolicy(
control=ReasoningControl.DEFAULT,
- effort=effort,
+ effort=intent.effort,
)
-
-
-def _thinking_control(
- thinking: ThinkingConfig | None,
- *,
- budget_tokens: int | None,
-) -> ReasoningControl:
- if thinking is None:
- return ReasoningControl.DEFAULT
- if thinking.type == "disabled" or (
- "enabled" in thinking.model_fields_set and thinking.enabled is False
- ):
- return ReasoningControl.OFF
- if (
- thinking.type in {"adaptive", "enabled"}
- or ("enabled" in thinking.model_fields_set and thinking.enabled is True)
- or budget_tokens is not None
- ):
- return ReasoningControl.ON
- return ReasoningControl.DEFAULT
-
-
-def _output_effort(value: object) -> tuple[ReasoningEffort | None, bool]:
- if not isinstance(value, Mapping):
- return None, False
- raw = value.get("effort")
- if not isinstance(raw, str):
- return None, False
- normalized = raw.strip().lower()
- if normalized == "none":
- return None, True
- try:
- return ReasoningEffort(normalized), False
- except ValueError:
- return None, False
-
-
-def _positive_budget(thinking: ThinkingConfig | None) -> int | None:
- if thinking is None:
- return None
- value = thinking.budget_tokens
- if isinstance(value, int) and not isinstance(value, bool) and value > 0:
- return value
- return None
diff --git a/src/free_claude_code/application/routing.py b/src/free_claude_code/application/routing.py
index 37b6a85e..fe7a2a56 100644
--- a/src/free_claude_code/application/routing.py
+++ b/src/free_claude_code/application/routing.py
@@ -1,4 +1,4 @@
-"""Model routing for Claude-compatible requests."""
+"""Provider model routing for canonical inference requests."""
from dataclasses import dataclass
@@ -12,8 +12,8 @@ from free_claude_code.config.provider_catalog import (
)
from free_claude_code.config.reasoning import ReasoningPreference
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import MessagesRequest, TokenCountRequest
from free_claude_code.core.gateway_model_ids import decode_gateway_model_id
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from .reasoning import resolve_reasoning_policy
@@ -46,15 +46,15 @@ class ResolvedModelRoute:
@dataclass(frozen=True, slots=True)
-class RoutedMessagesRequest:
- request: MessagesRequest
+class RoutedInferenceRequest:
+ request: InferenceRequest
resolved: ResolvedModelRoute
reasoning: ReasoningPolicy
@dataclass(frozen=True, slots=True)
class RoutedTokenCountRequest:
- request: TokenCountRequest
+ request: InferenceRequest
resolved: ResolvedModelRoute
@@ -187,28 +187,23 @@ class ModelRouter:
None,
)
- def resolve_messages_request(
- self, request: MessagesRequest
- ) -> RoutedMessagesRequest:
+ def resolve_inference_request(
+ self, request: InferenceRequest
+ ) -> RoutedInferenceRequest:
"""Return an internal routed request context."""
resolved = self.resolve(request.model)
- routed = request.model_copy(deep=True)
- routed.model = resolved.primary.provider_model
- return RoutedMessagesRequest(
- request=routed,
+ return RoutedInferenceRequest(
+ request=request,
resolved=resolved,
reasoning=resolve_reasoning_policy(
- routed,
+ request.reasoning,
resolved.reasoning_preference,
),
)
def resolve_token_count_request(
- self, request: TokenCountRequest
+ self, request: InferenceRequest
) -> RoutedTokenCountRequest:
"""Return an internal token-count request context."""
resolved = self.resolve(request.model)
- routed = request.model_copy(
- update={"model": resolved.primary.provider_model}, deep=True
- )
- return RoutedTokenCountRequest(request=routed, resolved=resolved)
+ return RoutedTokenCountRequest(request=request, resolved=resolved)
diff --git a/src/free_claude_code/core/anthropic/__init__.py b/src/free_claude_code/core/anthropic/__init__.py
index b0a88fe1..d71ba752 100644
--- a/src/free_claude_code/core/anthropic/__init__.py
+++ b/src/free_claude_code/core/anthropic/__init__.py
@@ -1,19 +1,18 @@
"""Anthropic protocol helpers shared across API, providers, and integrations."""
from .content import extract_text_from_content, get_block_attr, get_block_type
-from .conversion import (
- AnthropicToOpenAIConverter,
- OpenAIConversionError,
- ReasoningReplayMode,
- build_base_request_body,
- is_synthetic_openai_tool_turn_boundary,
-)
from .errors import (
anthropic_error_payload,
anthropic_error_type_for_failure,
anthropic_failure_payload,
anthropic_status_for_error_type,
)
+from .ingress import (
+ AnthropicIngressError,
+ messages_to_inference_request,
+ token_count_to_inference_request,
+ validate_messages_field_policy,
+)
from .models import (
ContentBlockDocument,
ContentBlockImage,
@@ -35,27 +34,23 @@ from .models import (
Tool,
Usage,
)
-from .openai_tool_names import OpenAIToolNameCodec
from .presenter import (
AnthropicEventPresenter,
aggregate_inference_events_to_message,
iter_anthropic_sse,
)
-from .request_serialization import dump_messages_request, serialize_tool_result_content
-from .request_snapshot import anthropic_request_snapshot
from .sse_aggregation import aggregate_anthropic_sse_to_message
from .streaming import (
format_sse_event,
map_stop_reason,
)
from .thinking import ContentChunk, ContentType, ThinkTagParser
-from .tokens import get_token_count
-from .tools import FunctionTagToolParser, HeuristicToolParser
+from .tools import HeuristicToolParser
from .utils import set_if_not_none
__all__ = [
"AnthropicEventPresenter",
- "AnthropicToOpenAIConverter",
+ "AnthropicIngressError",
"ContentBlockDocument",
"ContentBlockImage",
"ContentBlockRedactedThinking",
@@ -68,14 +63,10 @@ __all__ = [
"ContentBlockWebSearchToolResult",
"ContentChunk",
"ContentType",
- "FunctionTagToolParser",
"HeuristicToolParser",
"Message",
"MessagesRequest",
"MessagesResponse",
- "OpenAIConversionError",
- "OpenAIToolNameCodec",
- "ReasoningReplayMode",
"SystemContent",
"ThinkTagParser",
"ThinkingConfig",
@@ -88,18 +79,15 @@ __all__ = [
"anthropic_error_payload",
"anthropic_error_type_for_failure",
"anthropic_failure_payload",
- "anthropic_request_snapshot",
"anthropic_status_for_error_type",
- "build_base_request_body",
- "dump_messages_request",
"extract_text_from_content",
"format_sse_event",
"get_block_attr",
"get_block_type",
- "get_token_count",
- "is_synthetic_openai_tool_turn_boundary",
"iter_anthropic_sse",
"map_stop_reason",
- "serialize_tool_result_content",
+ "messages_to_inference_request",
"set_if_not_none",
+ "token_count_to_inference_request",
+ "validate_messages_field_policy",
]
diff --git a/src/free_claude_code/core/anthropic/conversion.py b/src/free_claude_code/core/anthropic/conversion.py
deleted file mode 100644
index 24cc0bb2..00000000
--- a/src/free_claude_code/core/anthropic/conversion.py
+++ /dev/null
@@ -1,794 +0,0 @@
-"""Message and tool format converters."""
-
-import json
-from copy import deepcopy
-from dataclasses import dataclass, field
-from enum import StrEnum
-from typing import Any
-
-from .content import get_block_attr, get_block_type
-from .models import MessagesRequest
-from .request_serialization import serialize_tool_result_content
-from .utils import set_if_not_none
-
-
-class OpenAIConversionError(Exception):
- """Raised when Anthropic content cannot be converted to OpenAI chat without data loss."""
-
-
-class ReasoningReplayMode(StrEnum):
- """How assistant reasoning history is replayed to OpenAI-compatible providers."""
-
- DISABLED = "disabled"
- THINK_TAGS = "think_tags"
- REASONING_CONTENT = "reasoning_content"
- REASONING = "reasoning"
-
-
-def resolve_anthropic_tool_choice(
- tools: list[Any] | None,
- tool_choice: dict[str, Any] | None,
-) -> dict[str, Any] | None:
- """Materialize Anthropic's automatic choice when tools are available."""
- if tool_choice is not None:
- return tool_choice
- if tools:
- return {"type": "auto"}
- return None
-
-
-def _reasoning_replay_field(mode: ReasoningReplayMode) -> str | None:
- if mode in (
- ReasoningReplayMode.REASONING_CONTENT,
- ReasoningReplayMode.REASONING,
- ):
- return mode.value
- return None
-
-
-def _set_replayed_reasoning(
- message: dict[str, Any], reasoning: str, mode: ReasoningReplayMode
-) -> None:
- field_name = _reasoning_replay_field(mode)
- if field_name is not None:
- message[field_name] = reasoning
-
-
-def _openai_reject_native_only_top_level_fields(
- request_data: MessagesRequest,
-) -> None:
- """OpenAI chat providers may only convert known top-level request fields.
-
- First-class model fields (e.g. ``context_management``) are not forwarded to
- the OpenAI API but are allowed so clients do not hit spurious 400s.
- Unknown extra keys (``__pydantic_extra__``) are still rejected.
- """
- extra = request_data.model_extra
- if not extra:
- return
- raise OpenAIConversionError(
- "OpenAI chat conversion does not support these top-level request fields: "
- f"{sorted(str(k) for k in extra)}. Remove the unsupported fields."
- )
-
-
-def _tool_input_schema(tool: Any) -> dict[str, Any]:
- schema = getattr(tool, "input_schema", None)
- if isinstance(schema, dict):
- return schema
- return {"type": "object", "properties": {}}
-
-
-def _clean_reasoning_content(value: Any) -> str | None:
- if not isinstance(value, str):
- return None
- return value
-
-
-def _think_tag_content(reasoning: str) -> str:
- return f"<think>\n{reasoning}\n</think>"
-
-
-def _tool_call_from_tool_use(block: Any) -> dict[str, Any]:
- tool_input = get_block_attr(block, "input", {})
- tool_call: dict[str, Any] = {
- "id": get_block_attr(block, "id"),
- "type": "function",
- "function": {
- "name": get_block_attr(block, "name"),
- "arguments": json.dumps(tool_input)
- if isinstance(tool_input, dict)
- else str(tool_input),
- },
- }
- extra_content = get_block_attr(block, "extra_content", None)
- if isinstance(extra_content, dict) and extra_content:
- tool_call["extra_content"] = deepcopy(extra_content)
- return tool_call
-
-
-@dataclass
-class _PlainSegment:
- messages: list[dict[str, Any]]
-
-
-@dataclass
-class _ToolTurnSegment:
- assistant_message: dict[str, Any]
- required_tool_ids: list[str]
- deferred_blocks: list[Any] = field(default_factory=list)
- top_level_reasoning: str | None = None
- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS
- assistant_emitted: bool = False
-
-
-_TranscriptSegment = _PlainSegment | _ToolTurnSegment
-
-
-def _tool_call_ids(tool_calls: list[dict[str, Any]]) -> list[str]:
- ids: list[str] = []
- for tool_call in tool_calls:
- tool_id = tool_call.get("id")
- if tool_id is not None and str(tool_id).strip() != "":
- ids.append(str(tool_id))
- return ids
-
-
-def _index_first_tool_use(blocks: list[Any]) -> int | None:
- for i, block in enumerate(blocks):
- if get_block_type(block) == "tool_use":
- return i
- return None
-
-
-def _iter_tool_uses_in_order(blocks: list[Any]) -> list[dict[str, Any]]:
- return [
- _tool_call_from_tool_use(block)
- for block in blocks
- if get_block_type(block) == "tool_use"
- ]
-
-
-def _deferred_post_tool_blocks(
- content: list[Any], *, first_tool_index: int
-) -> list[Any]:
- return [
- b
- for i, b in enumerate(content)
- if i > first_tool_index and get_block_type(b) != "tool_use"
- ]
-
-
-def _assert_no_forbidden_assistant_block(block: Any) -> None:
- block_type = get_block_type(block)
- if block_type == "image":
- raise OpenAIConversionError(
- "Assistant image blocks are not supported for OpenAI chat conversion."
- )
- if block_type in (
- "server_tool_use",
- "web_search_tool_result",
- "web_fetch_tool_result",
- ):
- raise OpenAIConversionError(
- "OpenAI chat conversion does not support Anthropic server tool blocks "
- f"({block_type!r} in an assistant message). Remove the unsupported block."
- )
-
-
-def _openai_system_text(
- content: Any,
- *,
- context: str,
-) -> str | None:
- """Return OpenAI-compatible system text without silently dropping blocks."""
- if isinstance(content, str):
- return content
- if not isinstance(content, list):
- raise OpenAIConversionError(
- f"OpenAI chat conversion requires {context} content to be text."
- )
- if not content:
- return None
-
- text_parts: list[str] = []
- for block in content:
- block_type = get_block_type(block)
- if block_type != "text":
- raise OpenAIConversionError(
- f"OpenAI chat conversion cannot represent {context} content block "
- f"{block_type!r} without data loss."
- )
- text_parts.append(str(get_block_attr(block, "text", "")))
-
- return "\n\n".join(text_parts)
-
-
-def _openai_user_image_part(block: Any) -> dict[str, Any]:
- """Convert one Anthropic user image block without performing I/O."""
- source = get_block_attr(block, "source", {})
- source_type = get_block_attr(source, "type")
-
- if source_type == "base64":
- media_type = get_block_attr(source, "media_type")
- if not isinstance(media_type, str) or not media_type.strip():
- raise OpenAIConversionError(
- "Base64 image source requires a non-empty media_type."
- )
- data = get_block_attr(source, "data")
- if not isinstance(data, str) or not data.strip():
- raise OpenAIConversionError("Base64 image source requires non-empty data.")
- url = f"data:{media_type};base64,{data}"
- elif source_type == "url":
- url = get_block_attr(source, "url")
- if not isinstance(url, str) or not url.strip():
- raise OpenAIConversionError("URL image source requires a non-empty url.")
- else:
- raise OpenAIConversionError(
- f"Unsupported image source type {source_type!r}; expected 'base64' or 'url'."
- )
-
- return {"type": "image_url", "image_url": {"url": url}}
-
-
-def _openai_user_content_parts(content: Any) -> list[dict[str, Any]]:
- """Return an owned content-part list for one converted user message."""
- if isinstance(content, str):
- return [{"type": "text", "text": content}]
- if isinstance(content, list) and all(isinstance(part, dict) for part in content):
- return deepcopy(content)
- raise OpenAIConversionError(
- "OpenAI chat conversion produced unsupported user message content."
- )
-
-
-def _merge_openai_user_content(first: Any, second: Any) -> str | list[dict[str, Any]]:
- """Combine adjacent user content while preserving multimodal part order."""
- if isinstance(first, str) and isinstance(second, str):
- return f"{first}\n\n{second}"
-
- first_parts = _openai_user_content_parts(first)
- second_parts = _openai_user_content_parts(second)
- first_ends_in_text = bool(first_parts) and first_parts[-1].get("type") == "text"
- second_starts_with_text = (
- bool(second_parts) and second_parts[0].get("type") == "text"
- )
- if first_ends_in_text and second_starts_with_text:
- first_text = first_parts[-1].get("text", "")
- second_text = second_parts.pop(0).get("text", "")
- first_parts[-1]["text"] = f"{first_text}\n\n{second_text}"
- return [*first_parts, *second_parts]
-
-
-def _coalesce_openai_user_messages(
- messages: list[dict[str, Any]],
-) -> list[dict[str, Any]]:
- """Combine adjacent user messages after transcript ordering is complete."""
- result: list[dict[str, Any]] = []
- for message in messages:
- if (
- message.get("role") == "user"
- and result
- and result[-1].get("role") == "user"
- ):
- previous = result[-1]
- previous["content"] = _merge_openai_user_content(
- previous.get("content"), message.get("content")
- )
- continue
- result.append(message)
- return result
-
-
-class _SyntheticOpenAIToolTurnBoundary(dict[str, Any]):
- """Identify an FCC-inserted assistant boundary until wire serialization."""
-
- __slots__ = ()
-
-
-def is_synthetic_openai_tool_turn_boundary(message: object) -> bool:
- """Return whether FCC inserted this message to close an OpenAI tool turn."""
- return isinstance(message, _SyntheticOpenAIToolTurnBoundary)
-
-
-def _close_openai_tool_result_turns(
- messages: list[dict[str, Any]],
-) -> list[dict[str, Any]]:
- """Close completed tool rounds before subsequent user input."""
- result: list[dict[str, Any]] = []
- for message in messages:
- if (
- message.get("role") == "user"
- and result
- and result[-1].get("role") == "tool"
- ):
- # Some OpenAI-compatible chat templates reject a user role directly
- # after tool output. Non-empty whitespace closes the assistant turn
- # without inventing model content.
- result.append(
- _SyntheticOpenAIToolTurnBoundary(role="assistant", content=" ")
- )
- result.append(message)
- return result
-
-
-class _OpenAIChatHistoryLedger:
- """Assemble OpenAI chat history while respecting tool-result dependencies."""
-
- def __init__(self) -> None:
- self._output: list[dict[str, Any]] = []
- self._segments: list[_TranscriptSegment] = []
- self._tool_results: dict[str, dict[str, Any]] = {}
-
- def add_plain(self, messages: list[dict[str, Any]]) -> None:
- if messages:
- self._segments.append(_PlainSegment(messages))
- self._drain_ready_segments()
-
- def add_tool_turn(self, segment: _ToolTurnSegment) -> None:
- self._segments.append(segment)
- self._drain_ready_segments()
-
- def add_user_blocks(self, blocks: list[Any]) -> None:
- text_blocks: list[Any] = []
- for block in blocks:
- block_type = get_block_type(block)
- if block_type == "tool_result":
- self._add_text_blocks(text_blocks)
- self._record_tool_result(block)
- else:
- text_blocks.append(block)
- self._add_text_blocks(text_blocks)
- self._drain_ready_segments()
-
- def finish(self) -> list[dict[str, Any]]:
- self._drain_ready_segments()
- missing = self._missing_required_tool_ids()
- if missing:
- raise OpenAIConversionError(
- "OpenAI chat conversion cannot replay incomplete tool history; "
- f"missing tool_result blocks for tool_use ids: {missing}"
- )
- while self._segments:
- segment = self._segments.pop(0)
- if isinstance(segment, _PlainSegment):
- self._output.extend(segment.messages)
- continue
- self._emit_tool_turn(segment)
- return self._output
-
- def _add_text_blocks(self, blocks: list[Any]) -> None:
- if not blocks:
- return
- self.add_plain(AnthropicToOpenAIConverter._convert_user_message(blocks))
- blocks.clear()
-
- def _record_tool_result(self, block: Any) -> None:
- tuid = get_block_attr(block, "tool_use_id")
- tuid_s = str(tuid) if tuid is not None else ""
- if not tuid_s:
- self.add_plain(AnthropicToOpenAIConverter._convert_user_message([block]))
- return
- tool_content = get_block_attr(block, "content", "")
- serialized = serialize_tool_result_content(tool_content)
- tool_message = {
- "role": "tool",
- "tool_call_id": tuid,
- "content": serialized if serialized else "",
- }
- if self._has_pending_tool_id(tuid_s):
- self._tool_results[tuid_s] = tool_message
- else:
- self.add_plain([tool_message])
-
- def _drain_ready_segments(self) -> None:
- while self._segments:
- segment = self._segments[0]
- if isinstance(segment, _PlainSegment):
- self._output.extend(segment.messages)
- self._segments.pop(0)
- continue
-
- if not segment.assistant_emitted:
- self._output.append(segment.assistant_message)
- segment.assistant_emitted = True
-
- missing = [
- tool_id
- for tool_id in segment.required_tool_ids
- if tool_id not in self._tool_results
- ]
- if missing:
- break
-
- self._segments.pop(0)
- for tool_id in segment.required_tool_ids:
- self._output.append(self._tool_results.pop(tool_id))
- deferred_messages = (
- AnthropicToOpenAIConverter._deferred_post_tool_to_messages(segment)
- )
- self._output.extend(deferred_messages)
-
- def _emit_tool_turn(self, segment: _ToolTurnSegment) -> None:
- if not segment.assistant_emitted:
- self._output.append(segment.assistant_message)
- segment.assistant_emitted = True
- for tool_id in segment.required_tool_ids:
- tool_result = self._tool_results.pop(tool_id, None)
- if tool_result is not None:
- self._output.append(tool_result)
- self._output.extend(
- AnthropicToOpenAIConverter._deferred_post_tool_to_messages(segment)
- )
-
- def _missing_required_tool_ids(self) -> list[str]:
- missing: list[str] = []
- for segment in self._segments:
- if not isinstance(segment, _ToolTurnSegment):
- continue
- missing.extend(
- tool_id
- for tool_id in segment.required_tool_ids
- if tool_id not in self._tool_results
- )
- return missing
-
- def _has_pending_tool_id(self, tool_id: str) -> bool:
- return any(
- isinstance(segment, _ToolTurnSegment)
- and tool_id in segment.required_tool_ids
- for segment in self._segments
- )
-
-
-class AnthropicToOpenAIConverter:
- """Convert Anthropic message format to OpenAI-compatible format."""
-
- @staticmethod
- def convert_messages(
- messages: list[Any],
- *,
- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
- ) -> list[dict[str, Any]]:
- ledger = _OpenAIChatHistoryLedger()
-
- for msg in messages:
- role = msg.role
- content = msg.content
- reasoning_content = _clean_reasoning_content(
- getattr(msg, "reasoning_content", None)
- )
-
- if role == "user" and isinstance(content, list):
- ledger.add_user_blocks(content)
- continue
-
- segments = AnthropicToOpenAIConverter._convert_message_to_segments(
- role,
- content,
- reasoning_content=reasoning_content,
- reasoning_replay=reasoning_replay,
- )
- for segment in segments:
- if isinstance(segment, _PlainSegment):
- ledger.add_plain(segment.messages)
- else:
- ledger.add_tool_turn(segment)
-
- ordered_messages = ledger.finish()
- closed_messages = _close_openai_tool_result_turns(ordered_messages)
- return _coalesce_openai_user_messages(closed_messages)
-
- @staticmethod
- def _convert_message_to_segments(
- role: str,
- content: Any,
- *,
- reasoning_content: str | None,
- reasoning_replay: ReasoningReplayMode,
- ) -> list[_TranscriptSegment]:
- if role == "system":
- system_text = _openai_system_text(
- content,
- context="an inline Anthropic system message",
- )
- if system_text is None:
- raise OpenAIConversionError(
- "OpenAI chat conversion requires an inline Anthropic system "
- "message to contain text."
- )
- # Reserve the downstream system role for request.system at index zero.
- return [_PlainSegment([{"role": "user", "content": system_text}])]
- if role == "assistant" and isinstance(content, list):
- if (first_i := _index_first_tool_use(content)) is not None:
- for block in content:
- if get_block_type(block) == "tool_use":
- continue
- _assert_no_forbidden_assistant_block(block)
- return [
- AnthropicToOpenAIConverter._convert_assistant_message_with_split(
- content,
- first_tool_index=first_i,
- reasoning_content=reasoning_content,
- reasoning_replay=reasoning_replay,
- )
- ]
- for block in content:
- _assert_no_forbidden_assistant_block(block)
- return [
- _PlainSegment(
- AnthropicToOpenAIConverter._convert_assistant_message(
- content,
- reasoning_content=reasoning_content,
- reasoning_replay=reasoning_replay,
- )
- )
- ]
- if role == "user" and isinstance(content, list):
- return [
- _PlainSegment(AnthropicToOpenAIConverter._convert_user_message(content))
- ]
- if isinstance(content, str):
- converted = {"role": role, "content": content}
- if role == "assistant" and reasoning_content is not None:
- if _reasoning_replay_field(reasoning_replay) is not None:
- _set_replayed_reasoning(
- converted, reasoning_content, reasoning_replay
- )
- elif (
- reasoning_replay == ReasoningReplayMode.THINK_TAGS
- and reasoning_content
- ):
- content_parts = [_think_tag_content(reasoning_content)]
- if content:
- content_parts.append(content)
- converted["content"] = "\n\n".join(content_parts)
- return [_PlainSegment([converted])]
- if isinstance(content, list):
- return []
- return [_PlainSegment([{"role": role, "content": str(content)}])]
-
- @staticmethod
- def _convert_assistant_message_with_split(
- content: list[Any],
- *,
- first_tool_index: int,
- reasoning_content: str | None,
- reasoning_replay: ReasoningReplayMode,
- ) -> _ToolTurnSegment:
- pre = content[:first_tool_index]
- tool_calls = _iter_tool_uses_in_order(content)
- if not tool_calls:
- return _ToolTurnSegment(
- assistant_message=AnthropicToOpenAIConverter._convert_assistant_message(
- content,
- reasoning_content=reasoning_content,
- reasoning_replay=reasoning_replay,
- )[0],
- required_tool_ids=[],
- )
- deferred_blocks = _deferred_post_tool_blocks(
- content, first_tool_index=first_tool_index
- )
-
- pre_msg: dict[str, Any]
- if not pre:
- pre_msg = {
- "role": "assistant",
- "content": "",
- }
- if reasoning_content is not None:
- _set_replayed_reasoning(pre_msg, reasoning_content, reasoning_replay)
- else:
- pre_msg = AnthropicToOpenAIConverter._convert_assistant_message(
- pre,
- reasoning_content=reasoning_content,
- reasoning_replay=reasoning_replay,
- )[0]
- pre_msg["tool_calls"] = tool_calls
- if reasoning_replay is ReasoningReplayMode.REASONING_CONTENT:
- pre_msg.setdefault("reasoning_content", "")
- if tool_calls and pre_msg.get("content") == " ":
- pre_msg["content"] = ""
- return _ToolTurnSegment(
- assistant_message=pre_msg,
- required_tool_ids=_tool_call_ids(tool_calls),
- deferred_blocks=deferred_blocks,
- top_level_reasoning=reasoning_content,
- reasoning_replay=reasoning_replay,
- )
-
- @staticmethod
- def _convert_assistant_message(
- content: list[Any],
- *,
- reasoning_content: str | None = None,
- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
- ) -> list[dict[str, Any]]:
- content_parts: list[str] = []
- thinking_parts: list[str] = []
- thinking_seen = False
- tool_calls: list[dict[str, Any]] = []
- for block in content:
- block_type = get_block_type(block)
- if block_type == "text":
- content_parts.append(get_block_attr(block, "text", ""))
- elif block_type == "thinking":
- if reasoning_replay == ReasoningReplayMode.DISABLED:
- continue
- thinking = get_block_attr(block, "thinking", "")
- if reasoning_replay == ReasoningReplayMode.THINK_TAGS:
- content_parts.append(_think_tag_content(thinking))
- elif reasoning_content is None:
- thinking_seen = True
- thinking_parts.append(thinking)
- elif block_type == "redacted_thinking":
- # Opaque provider continuation data; do not materialize as model-visible text
- # or native reasoning fields for OpenAI chat upstreams.
- continue
- elif block_type == "tool_use":
- tool_calls.append(_tool_call_from_tool_use(block))
- else:
- _assert_no_forbidden_assistant_block(block)
-
- content_str = "\n\n".join(content_parts)
- if not content_str and not tool_calls:
- content_str = " "
-
- msg: dict[str, Any] = {
- "role": "assistant",
- "content": content_str,
- }
- if tool_calls:
- msg["tool_calls"] = tool_calls
- if _reasoning_replay_field(reasoning_replay) is not None:
- if reasoning_content is not None:
- _set_replayed_reasoning(msg, reasoning_content, reasoning_replay)
- elif thinking_seen:
- _set_replayed_reasoning(
- msg, "\n".join(thinking_parts), reasoning_replay
- )
-
- return [msg]
-
- @staticmethod
- def _deferred_post_tool_to_messages(
- pending: _ToolTurnSegment,
- ) -> list[dict[str, Any]]:
- if not pending.deferred_blocks:
- return []
- return AnthropicToOpenAIConverter._convert_assistant_message(
- pending.deferred_blocks,
- reasoning_content=pending.top_level_reasoning,
- reasoning_replay=pending.reasoning_replay,
- )
-
- @staticmethod
- def _convert_user_message(content: list[Any]) -> list[dict[str, Any]]:
- result: list[dict[str, Any]] = []
- content_parts: list[dict[str, Any]] = []
-
- def flush_content() -> None:
- if not content_parts:
- return
- if all(part["type"] == "text" for part in content_parts):
- message_content: str | list[dict[str, Any]] = "\n".join(
- part["text"] for part in content_parts
- )
- else:
- message_content = list(content_parts)
- result.append({"role": "user", "content": message_content})
- content_parts.clear()
-
- for block in content:
- block_type = get_block_type(block)
-
- if block_type == "text":
- content_parts.append(
- {"type": "text", "text": get_block_attr(block, "text", "")}
- )
- elif block_type == "image":
- content_parts.append(_openai_user_image_part(block))
- elif block_type == "tool_result":
- flush_content()
- tool_content = get_block_attr(block, "content", "")
- serialized = serialize_tool_result_content(tool_content)
- result.append(
- {
- "role": "tool",
- "tool_call_id": get_block_attr(block, "tool_use_id"),
- "content": serialized if serialized else "",
- }
- )
-
- flush_content()
- return result
-
- @staticmethod
- def convert_tools(tools: list[Any]) -> list[dict[str, Any]]:
- return [
- {
- "type": "function",
- "function": {
- "name": tool.name,
- "description": tool.description or "",
- "parameters": _tool_input_schema(tool),
- },
- }
- for tool in tools
- ]
-
- @staticmethod
- def convert_tool_choice(tool_choice: Any) -> Any:
- if not isinstance(tool_choice, dict):
- return tool_choice
-
- choice_type = tool_choice.get("type")
- if choice_type == "tool":
- name = tool_choice.get("name")
- if name:
- return {"type": "function", "function": {"name": name}}
- if choice_type == "any":
- return "required"
- if choice_type in {"auto", "none", "required"}:
- return choice_type
- if choice_type == "function" and isinstance(tool_choice.get("function"), dict):
- return tool_choice
-
- return tool_choice
-
- @staticmethod
- def convert_system_prompt(system: Any) -> dict[str, str] | None:
- if system is None:
- return None
- system_text = _openai_system_text(
- system,
- context="the top-level Anthropic system prompt",
- )
- if system_text is None:
- return None
- if isinstance(system, list):
- system_text = system_text.strip()
- return {"role": "system", "content": system_text}
-
-
-def build_base_request_body(
- request_data: MessagesRequest,
- *,
- default_max_tokens: int | None = None,
- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
-) -> dict[str, Any]:
- """Build the common parts of an OpenAI-format request body."""
- _openai_reject_native_only_top_level_fields(request_data)
- messages = AnthropicToOpenAIConverter.convert_messages(
- request_data.messages,
- reasoning_replay=reasoning_replay,
- )
-
- system = request_data.system
- if system:
- system_msg = AnthropicToOpenAIConverter.convert_system_prompt(system)
- if system_msg:
- messages.insert(0, system_msg)
-
- body: dict[str, Any] = {"model": request_data.model, "messages": messages}
-
- max_tokens = request_data.max_tokens
- set_if_not_none(body, "max_tokens", max_tokens or default_max_tokens)
- set_if_not_none(body, "temperature", request_data.temperature)
- set_if_not_none(body, "top_p", request_data.top_p)
-
- stop_sequences = request_data.stop_sequences
- if stop_sequences:
- body["stop"] = stop_sequences
-
- tools = request_data.tools
- if tools:
- body["tools"] = AnthropicToOpenAIConverter.convert_tools(tools)
- tool_choice = resolve_anthropic_tool_choice(tools, request_data.tool_choice)
- if tool_choice:
- body["tool_choice"] = AnthropicToOpenAIConverter.convert_tool_choice(
- tool_choice
- )
-
- return body
diff --git a/src/free_claude_code/core/anthropic/ingress.py b/src/free_claude_code/core/anthropic/ingress.py
new file mode 100644
index 00000000..b051884b
--- /dev/null
+++ b/src/free_claude_code/core/anthropic/ingress.py
@@ -0,0 +1,898 @@
+"""Anthropic Messages ingress conversion to canonical inference semantics."""
+
+from collections.abc import Mapping, Sequence
+from typing import cast
+
+from pydantic import BaseModel
+
+from free_claude_code.core.inference import (
+ Base64MediaSource,
+ CacheControl,
+ CacheControlType,
+ CacheTTL,
+ ClientReasoningIntent,
+ DocumentContent,
+ FileMediaSource,
+ FunctionTool,
+ ImageContent,
+ InferenceItem,
+ InferenceRequest,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MessageItem,
+ MessageRole,
+ OpenAIChatExtension,
+ ReasoningItem,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoice,
+ ToolChoiceMode,
+ ToolResultItem,
+ UrlMediaSource,
+)
+from free_claude_code.core.json_types import JsonValue
+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort
+from free_claude_code.core.replay_envelope import (
+ ReplayEnvelopeError,
+ decode_replay_envelope,
+)
+
+from .models import (
+ ContentBlockDocument,
+ ContentBlockImage,
+ ContentBlockRedactedThinking,
+ ContentBlockServerToolUse,
+ ContentBlockText,
+ ContentBlockThinking,
+ ContentBlockToolResult,
+ ContentBlockToolUse,
+ ContentBlockWebFetchToolResult,
+ ContentBlockWebSearchToolResult,
+ MessagesRequest,
+ SystemContent,
+ TokenCountRequest,
+ Tool,
+)
+
+_NOOP_CONTEXT_EDIT = {"type": "clear_thinking_20251015", "keep": "all"}
+_ALLOWED_BLOCK_EXTRAS = frozenset({"cache_control"})
+
+
+class AnthropicIngressError(ValueError):
+ """An Anthropic request cannot be represented without semantic loss."""
+
+
+def messages_to_inference_request(request: MessagesRequest) -> InferenceRequest:
+ """Validate and convert one Messages request exactly once."""
+
+ validate_messages_field_policy(request)
+ items = [*_system_items(request.system), *_message_items(request.messages)]
+ tools = tuple(
+ _function_tool(tool, index=index)
+ for index, tool in enumerate(request.tools or ())
+ )
+ tool_choice, parallel_tool_calls = _tool_choice(request.tool_choice)
+ extensions = (
+ (OpenAIChatExtension(_json_object(request.extra_body, path="extra_body")),)
+ if request.extra_body
+ else ()
+ )
+ metadata = (
+ _json_object(request.metadata, path="metadata")
+ if request.metadata is not None
+ else None
+ )
+ return InferenceRequest(
+ model=request.model,
+ items=tuple(items),
+ tools=tools,
+ tool_choice=tool_choice,
+ parallel_tool_calls=parallel_tool_calls,
+ max_output_tokens=request.max_tokens,
+ temperature=request.temperature,
+ top_p=request.top_p,
+ top_k=request.top_k,
+ stop_sequences=tuple(request.stop_sequences or ()),
+ reasoning=_reasoning_intent(request),
+ metadata=metadata,
+ extensions=extensions,
+ )
+
+
+def token_count_to_inference_request(request: TokenCountRequest) -> InferenceRequest:
+ """Convert the token-count product through the same canonical transcript."""
+
+ _validate_token_count_top_level(request)
+ items = [*_system_items(request.system), *_message_items(request.messages)]
+ tools = tuple(
+ _function_tool(tool, index=index)
+ for index, tool in enumerate(request.tools or ())
+ )
+ tool_choice, parallel_tool_calls = _tool_choice(request.tool_choice)
+ return InferenceRequest(
+ model=request.model,
+ items=tuple(items),
+ tools=tools,
+ tool_choice=tool_choice,
+ parallel_tool_calls=parallel_tool_calls,
+ reasoning=_reasoning_intent(request),
+ )
+
+
+def validate_messages_field_policy(request: MessagesRequest) -> None:
+ """Validate protocol-wide policy before local Messages short circuits."""
+
+ _validate_top_level(request)
+ _validate_system(request.system)
+ _validate_messages(request.messages)
+ for index, tool in enumerate(request.tools or ()):
+ _validate_wire_tool(tool, path=f"tools[{index}]")
+ _tool_choice(request.tool_choice)
+
+
+def _validate_top_level(request: MessagesRequest) -> None:
+ _reject_model_extras(request, path="request")
+ _validate_thinking(request.thinking)
+ _validate_common_controls(
+ context_management=request.context_management,
+ output_config=request.output_config,
+ mcp_servers=request.mcp_servers,
+ )
+
+
+def _validate_token_count_top_level(request: TokenCountRequest) -> None:
+ _reject_model_extras(request, path="request")
+ _validate_thinking(request.thinking)
+ _validate_common_controls(
+ context_management=request.context_management,
+ output_config=request.output_config,
+ mcp_servers=request.mcp_servers,
+ )
+ _validate_system(request.system)
+ _validate_messages(request.messages)
+ for index, tool in enumerate(request.tools or ()):
+ _validate_tool(tool, path=f"tools[{index}]")
+
+
+def _validate_common_controls(
+ *,
+ context_management: dict[str, object] | None,
+ output_config: dict[str, object] | None,
+ mcp_servers: list[dict[str, object]] | None,
+) -> None:
+ if not _is_noop_context_management(context_management):
+ raise AnthropicIngressError(
+ "context_management contains unsupported active semantics"
+ )
+ if output_config:
+ unsupported = sorted(str(key) for key in output_config if key != "effort")
+ if unsupported:
+ raise AnthropicIngressError(
+ f"output_config.{unsupported[0]} is not supported"
+ )
+ _reasoning_effort(output_config.get("effort"), path="output_config.effort")
+ if mcp_servers:
+ raise AnthropicIngressError("mcp_servers must be omitted or empty")
+
+
+def _is_noop_context_management(value: Mapping[str, object] | None) -> bool:
+ if not value:
+ return True
+ if set(value) != {"edits"}:
+ return False
+ edits = value.get("edits")
+ return isinstance(edits, list) and all(edit == _NOOP_CONTEXT_EDIT for edit in edits)
+
+
+def _validate_thinking(value: BaseModel | None) -> None:
+ if value is None:
+ return
+ extras = _block_extras(value)
+ unknown = set(extras) - {"display"}
+ if unknown:
+ raise AnthropicIngressError(
+ f"thinking.{sorted(str(key) for key in unknown)[0]} is not supported"
+ )
+ if "display" in extras and extras["display"] != "omitted":
+ raise AnthropicIngressError(
+ f"thinking.display has unsupported value {extras['display']!r}"
+ )
+ thinking_type = getattr(value, "type", None)
+ if thinking_type not in {None, "adaptive", "disabled", "enabled"}:
+ raise AnthropicIngressError(
+ f"thinking.type has unsupported value {thinking_type!r}"
+ )
+
+
+def _system_items(value: str | list[SystemContent] | None) -> list[InstructionItem]:
+ if value is None:
+ return []
+ if isinstance(value, str):
+ return [
+ InstructionItem(
+ text=value,
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ )
+ ]
+ return [
+ InstructionItem(
+ text=block.text,
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ cache_control=_cache_control(block, path=f"system[{index}]"),
+ )
+ for index, block in enumerate(value)
+ ]
+
+
+def _message_items(messages: Sequence[object]) -> list[InferenceItem]:
+ items: list[InferenceItem] = []
+ for index, raw_message in enumerate(messages):
+ role = getattr(raw_message, "role", None)
+ content = getattr(raw_message, "content", None)
+ reasoning_content = getattr(raw_message, "reasoning_content", None)
+ turn_id = f"turn_{index}"
+ path = f"messages[{index}]"
+ if role == "system":
+ items.extend(_inline_instruction_items(content, turn_id=turn_id, path=path))
+ continue
+ if role not in {"user", "assistant"}:
+ raise AnthropicIngressError(f"{path}.role is unsupported")
+ message_role = MessageRole(role)
+ if role == "assistant" and isinstance(reasoning_content, str):
+ items.append(ReasoningItem(turn_id=turn_id, reasoning=reasoning_content))
+ if isinstance(content, str):
+ items.append(
+ MessageItem(
+ turn_id=turn_id,
+ role=message_role,
+ content=(TextContent(content),),
+ )
+ )
+ continue
+ if not isinstance(content, list):
+ raise AnthropicIngressError(f"{path}.content must be text or a list")
+ for block_index, block in enumerate(content):
+ block_path = f"{path}.content[{block_index}]"
+ if isinstance(block, ContentBlockText):
+ items.append(
+ MessageItem(
+ turn_id=turn_id,
+ role=message_role,
+ content=(
+ TextContent(
+ block.text,
+ cache_control=_cache_control(block, path=block_path),
+ ),
+ ),
+ )
+ )
+ elif isinstance(block, ContentBlockImage):
+ if role != "user":
+ raise AnthropicIngressError(
+ f"{block_path} assistant images are not supported"
+ )
+ items.append(
+ MessageItem(
+ turn_id=turn_id,
+ role=message_role,
+ content=(
+ ImageContent(
+ _image_source(
+ block.source, path=f"{block_path}.source"
+ ),
+ cache_control=_cache_control(block, path=block_path),
+ ),
+ ),
+ )
+ )
+ elif isinstance(block, ContentBlockDocument):
+ if role != "user":
+ raise AnthropicIngressError(
+ f"{block_path} assistant documents are not supported"
+ )
+ items.append(
+ MessageItem(
+ turn_id=turn_id,
+ role=message_role,
+ content=(
+ DocumentContent(
+ _document_source(
+ block.source,
+ path=f"{block_path}.source",
+ ),
+ cache_control=_cache_control(block, path=block_path),
+ ),
+ ),
+ )
+ )
+ elif isinstance(block, ContentBlockThinking):
+ if role != "assistant":
+ raise AnthropicIngressError(
+ f"{block_path} thinking requires an assistant message"
+ )
+ _cache_control(block, path=block_path)
+ artifacts = _reasoning_carrier(
+ block.signature,
+ kind=ReplayArtifactKind.THINKING_SIGNATURE,
+ path=f"{block_path}.signature",
+ )
+ items.append(
+ ReasoningItem(
+ turn_id=turn_id,
+ reasoning=block.thinking,
+ artifacts=artifacts,
+ )
+ )
+ elif isinstance(block, ContentBlockRedactedThinking):
+ if role != "assistant":
+ raise AnthropicIngressError(
+ f"{block_path} redacted_thinking requires an assistant message"
+ )
+ _cache_control(block, path=block_path)
+ items.append(
+ ReasoningItem(
+ turn_id=turn_id,
+ reasoning="",
+ artifacts=_reasoning_carrier(
+ block.data,
+ kind=ReplayArtifactKind.REDACTED_THINKING,
+ path=f"{block_path}.data",
+ ),
+ )
+ )
+ elif isinstance(block, ContentBlockToolUse):
+ if role != "assistant":
+ raise AnthropicIngressError(
+ f"{block_path} tool_use requires an assistant message"
+ )
+ _cache_control(block, path=block_path)
+ items.append(
+ ToolCallItem(
+ turn_id=turn_id,
+ call_id=_non_empty(block.id, path=f"{block_path}.id"),
+ kind=ToolCallKind.FUNCTION,
+ name=_non_empty(block.name, path=f"{block_path}.name"),
+ input=_json_object(block.input, path=f"{block_path}.input"),
+ artifacts=_tool_artifacts(block, path=block_path),
+ )
+ )
+ elif isinstance(block, ContentBlockToolResult):
+ if role != "user":
+ raise AnthropicIngressError(
+ f"{block_path} tool_result requires a user message"
+ )
+ extras = _block_extras(block)
+ unknown = set(extras) - {"cache_control", "is_error"}
+ if unknown:
+ raise AnthropicIngressError(
+ f"{block_path}.{sorted(unknown)[0]} is not supported"
+ )
+ is_error = extras.get("is_error", False)
+ if not isinstance(is_error, bool):
+ raise AnthropicIngressError(
+ f"{block_path}.is_error must be boolean"
+ )
+ items.append(
+ ToolResultItem(
+ turn_id=turn_id,
+ call_id=_non_empty(
+ block.tool_use_id,
+ path=f"{block_path}.tool_use_id",
+ ),
+ content=_json_value(
+ block.content, path=f"{block_path}.content"
+ ),
+ is_error=is_error,
+ )
+ )
+ else:
+ block_type = getattr(block, "type", type(block).__name__)
+ raise AnthropicIngressError(
+ f"{block_path} type {block_type!r} is not supported for provider execution"
+ )
+ return items
+
+
+def _inline_instruction_items(
+ content: object,
+ *,
+ turn_id: str,
+ path: str,
+) -> list[InstructionItem]:
+ if isinstance(content, str):
+ return [
+ InstructionItem(
+ text=content,
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TRANSCRIPT,
+ turn_id=turn_id,
+ )
+ ]
+ if not isinstance(content, list):
+ raise AnthropicIngressError(f"{path}.content must contain only text")
+ items: list[InstructionItem] = []
+ for index, block in enumerate(content):
+ block_path = f"{path}.content[{index}]"
+ if not isinstance(block, ContentBlockText):
+ raise AnthropicIngressError(f"{block_path} must be a text block")
+ items.append(
+ InstructionItem(
+ text=block.text,
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TRANSCRIPT,
+ cache_control=_cache_control(block, path=block_path),
+ turn_id=turn_id,
+ )
+ )
+ return items
+
+
+def _function_tool(tool: Tool, *, index: int) -> FunctionTool:
+ path = f"tools[{index}]"
+ _validate_tool(tool, path=path)
+ schema = tool.input_schema or {"type": "object", "properties": {}}
+ extras = _block_extras(tool)
+ strict = extras.get("strict", False)
+ if not isinstance(strict, bool):
+ raise AnthropicIngressError(f"{path}.strict must be boolean")
+ return FunctionTool(
+ name=_non_empty(tool.name, path=f"{path}.name"),
+ description=tool.description,
+ input_schema=_json_object(schema, path=f"{path}.input_schema"),
+ strict=strict,
+ cache_control=_cache_control(tool, path=path),
+ )
+
+
+def _validate_tool(tool: Tool, *, path: str) -> None:
+ if tool.type is not None:
+ raise AnthropicIngressError(
+ f"{path}.type {tool.type!r} is provider-managed and cannot be forwarded"
+ )
+ unknown = set(_block_extras(tool)) - {"cache_control", "strict"}
+ if unknown:
+ raise AnthropicIngressError(f"{path}.{sorted(unknown)[0]} is not supported")
+ _cache_control(tool, path=path)
+
+
+def _validate_wire_tool(tool: Tool, *, path: str) -> None:
+ """Validate a tool before local server-tool routing is known."""
+
+ if tool.type is None:
+ _validate_tool(tool, path=path)
+ return
+ if tool.type.startswith(("web_search_", "web_fetch_")):
+ return
+ raise AnthropicIngressError(
+ f"{path}.type {tool.type!r} is provider-managed and cannot be forwarded"
+ )
+
+
+def _tool_choice(
+ value: dict[str, object] | None,
+) -> tuple[ToolChoice | None, bool | None]:
+ if value is None:
+ return None, None
+ if not isinstance(value, dict):
+ raise AnthropicIngressError("tool_choice must be an object")
+ choice_type = value.get("type")
+ allowed = {"type", "name", "disable_parallel_tool_use"}
+ unknown = set(value) - allowed
+ if unknown:
+ raise AnthropicIngressError(
+ f"tool_choice.{sorted(str(key) for key in unknown)[0]} is not supported"
+ )
+ disable_parallel = value.get("disable_parallel_tool_use")
+ if disable_parallel is not None and not isinstance(disable_parallel, bool):
+ raise AnthropicIngressError(
+ "tool_choice.disable_parallel_tool_use must be boolean"
+ )
+ parallel = None if disable_parallel is None else not disable_parallel
+ if choice_type == "auto":
+ return ToolChoice(ToolChoiceMode.AUTO), parallel
+ if choice_type in {"any", "required"}:
+ return ToolChoice(ToolChoiceMode.REQUIRED), parallel
+ if choice_type == "none":
+ return ToolChoice(ToolChoiceMode.NONE), parallel
+ if choice_type == "tool":
+ name = value.get("name")
+ if not isinstance(name, str) or not name:
+ raise AnthropicIngressError("tool_choice.name must be a non-empty string")
+ return (
+ ToolChoice(
+ ToolChoiceMode.SPECIFIC,
+ kind=ToolCallKind.FUNCTION,
+ name=name,
+ ),
+ parallel,
+ )
+ raise AnthropicIngressError(f"tool_choice.type {choice_type!r} is not supported")
+
+
+def _reasoning_intent(
+ request: MessagesRequest | TokenCountRequest,
+) -> ClientReasoningIntent:
+ thinking = request.thinking
+ budget = thinking.budget_tokens if thinking is not None else None
+ if budget is not None and (
+ not isinstance(budget, int) or isinstance(budget, bool) or budget <= 0
+ ):
+ raise AnthropicIngressError("thinking.budget_tokens must be a positive integer")
+ if thinking is None:
+ control = ReasoningControl.DEFAULT
+ elif thinking.type == "disabled" or (
+ "enabled" in thinking.model_fields_set and thinking.enabled is False
+ ):
+ control = ReasoningControl.OFF
+ elif (
+ thinking.type in {"adaptive", "enabled"}
+ or ("enabled" in thinking.model_fields_set and thinking.enabled is True)
+ or budget is not None
+ ):
+ control = ReasoningControl.ON
+ else:
+ control = ReasoningControl.DEFAULT
+ output_config = request.output_config or {}
+ effort = _reasoning_effort(
+ output_config.get("effort"),
+ path="output_config.effort",
+ )
+ if output_config.get("effort") == "none":
+ control = ReasoningControl.OFF
+ if control is ReasoningControl.OFF:
+ budget = None
+ if budget is not None:
+ control = ReasoningControl.ON
+ return ClientReasoningIntent(control=control, effort=effort, budget_tokens=budget)
+
+
+def _reasoning_effort(value: object, *, path: str) -> ReasoningEffort | None:
+ if value is None or value == "none":
+ return None
+ if not isinstance(value, str):
+ raise AnthropicIngressError(f"{path} must be a string")
+ try:
+ return ReasoningEffort(value.strip().lower())
+ except ValueError as exc:
+ raise AnthropicIngressError(f"{path} has unsupported value {value!r}") from exc
+
+
+def _image_source(value: object, *, path: str) -> UrlMediaSource | Base64MediaSource:
+ source = _mapping(value, path=path)
+ source_type = source.get("type")
+ if source_type == "url":
+ _require_exact_keys(source, allowed={"type", "url"}, path=path)
+ return UrlMediaSource(_required_mapping_str(source, "url", path=path))
+ if source_type == "base64":
+ _require_exact_keys(
+ source,
+ allowed={"type", "media_type", "data"},
+ path=path,
+ )
+ return Base64MediaSource(
+ media_type=_required_mapping_str(source, "media_type", path=path),
+ data=_required_mapping_str(source, "data", path=path),
+ )
+ raise AnthropicIngressError(
+ f"{path}.type must be 'url' or 'base64', got {source_type!r}"
+ )
+
+
+def _document_source(value: object, *, path: str):
+ source = _mapping(value, path=path)
+ source_type = source.get("type")
+ if source_type == "url":
+ _require_exact_keys(source, allowed={"type", "url"}, path=path)
+ return UrlMediaSource(_required_mapping_str(source, "url", path=path))
+ if source_type == "base64":
+ _require_exact_keys(
+ source,
+ allowed={"type", "media_type", "data"},
+ path=path,
+ )
+ return Base64MediaSource(
+ media_type=_required_mapping_str(source, "media_type", path=path),
+ data=_required_mapping_str(source, "data", path=path),
+ )
+ if source_type in {"file", "file_id"}:
+ _require_exact_keys(source, allowed={"type", "file_id"}, path=path)
+ return FileMediaSource(_required_mapping_str(source, "file_id", path=path))
+ raise AnthropicIngressError(
+ f"{path}.type must be 'url', 'base64', or 'file', got {source_type!r}"
+ )
+
+
+def _validate_system(value: str | list[SystemContent] | None) -> None:
+ if isinstance(value, list):
+ for index, block in enumerate(value):
+ _cache_control(block, path=f"system[{index}]")
+
+
+def _validate_messages(messages: Sequence[object]) -> None:
+ for index, raw_message in enumerate(messages):
+ role = getattr(raw_message, "role", None)
+ content = getattr(raw_message, "content", None)
+ path = f"messages[{index}]"
+ if isinstance(raw_message, BaseModel):
+ _reject_model_extras(raw_message, path=path)
+ if role == "system":
+ _validate_inline_instruction_content(content, path=path)
+ continue
+ if role not in {"user", "assistant"}:
+ raise AnthropicIngressError(f"{path}.role is unsupported")
+ if isinstance(content, str):
+ continue
+ if not isinstance(content, list):
+ raise AnthropicIngressError(f"{path}.content must be text or a list")
+ for block_index, block in enumerate(content):
+ block_path = f"{path}.content[{block_index}]"
+ if isinstance(block, ContentBlockText):
+ _cache_control(block, path=block_path)
+ elif isinstance(block, ContentBlockImage):
+ if role != "user":
+ raise AnthropicIngressError(
+ f"{block_path} assistant images are not supported"
+ )
+ _cache_control(block, path=block_path)
+ _image_source(block.source, path=f"{block_path}.source")
+ elif isinstance(block, ContentBlockDocument):
+ if role != "user":
+ raise AnthropicIngressError(
+ f"{block_path} assistant documents are not supported"
+ )
+ _cache_control(block, path=block_path)
+ _document_source(block.source, path=f"{block_path}.source")
+ elif isinstance(block, ContentBlockThinking):
+ if role != "assistant":
+ raise AnthropicIngressError(
+ f"{block_path} thinking requires an assistant message"
+ )
+ _cache_control(block, path=block_path)
+ _reasoning_carrier(
+ block.signature,
+ kind=ReplayArtifactKind.THINKING_SIGNATURE,
+ path=f"{block_path}.signature",
+ )
+ elif isinstance(block, ContentBlockRedactedThinking):
+ if role != "assistant":
+ raise AnthropicIngressError(
+ f"{block_path} redacted_thinking requires an assistant message"
+ )
+ _cache_control(block, path=block_path)
+ _reasoning_carrier(
+ block.data,
+ kind=ReplayArtifactKind.REDACTED_THINKING,
+ path=f"{block_path}.data",
+ )
+ elif isinstance(block, ContentBlockToolUse):
+ if role != "assistant":
+ raise AnthropicIngressError(
+ f"{block_path} tool_use requires an assistant message"
+ )
+ _cache_control(block, path=block_path)
+ _non_empty(block.id, path=f"{block_path}.id")
+ _non_empty(block.name, path=f"{block_path}.name")
+ _json_object(block.input, path=f"{block_path}.input")
+ _tool_artifacts(block, path=block_path)
+ elif isinstance(block, ContentBlockToolResult):
+ if role != "user":
+ raise AnthropicIngressError(
+ f"{block_path} tool_result requires a user message"
+ )
+ extras = _block_extras(block)
+ unknown = set(extras) - {"cache_control", "is_error"}
+ if unknown:
+ raise AnthropicIngressError(
+ f"{block_path}.{sorted(unknown)[0]} is not supported"
+ )
+ is_error = extras.get("is_error", False)
+ if not isinstance(is_error, bool):
+ raise AnthropicIngressError(
+ f"{block_path}.is_error must be boolean"
+ )
+ _non_empty(
+ block.tool_use_id,
+ path=f"{block_path}.tool_use_id",
+ )
+ _json_value(block.content, path=f"{block_path}.content")
+ elif isinstance(
+ block,
+ ContentBlockServerToolUse
+ | ContentBlockWebSearchToolResult
+ | ContentBlockWebFetchToolResult,
+ ):
+ continue
+ else:
+ block_type = getattr(block, "type", type(block).__name__)
+ raise AnthropicIngressError(
+ f"{block_path} type {block_type!r} is not supported"
+ )
+
+
+def _validate_inline_instruction_content(content: object, *, path: str) -> None:
+ if isinstance(content, str):
+ return
+ if not isinstance(content, list):
+ raise AnthropicIngressError(f"{path}.content must contain only text")
+ for index, block in enumerate(content):
+ block_path = f"{path}.content[{index}]"
+ if not isinstance(block, ContentBlockText):
+ raise AnthropicIngressError(f"{block_path} must be a text block")
+ _cache_control(block, path=block_path)
+
+
+def _cache_control(block: BaseModel, *, path: str) -> CacheControl | None:
+ extras = _block_extras(block)
+ allowed = set(_ALLOWED_BLOCK_EXTRAS)
+ if isinstance(block, ContentBlockToolUse):
+ allowed.add("extra_content")
+ if isinstance(block, Tool):
+ allowed.add("strict")
+ unknown = set(extras) - allowed
+ if unknown:
+ raise AnthropicIngressError(f"{path}.{sorted(unknown)[0]} is not supported")
+ value = extras.get("cache_control")
+ if value is None:
+ return None
+ mapping = _mapping(value, path=f"{path}.cache_control")
+ if set(mapping) - {"type", "ttl"}:
+ key = sorted(str(key) for key in set(mapping) - {"type", "ttl"})[0]
+ raise AnthropicIngressError(f"{path}.cache_control.{key} is not supported")
+ if mapping.get("type") != "ephemeral":
+ raise AnthropicIngressError(f"{path}.cache_control.type must be 'ephemeral'")
+ raw_ttl = mapping.get("ttl")
+ if raw_ttl is None:
+ ttl = None
+ else:
+ try:
+ ttl = CacheTTL(raw_ttl)
+ except (TypeError, ValueError) as exc:
+ raise AnthropicIngressError(
+ f"{path}.cache_control.ttl must be '5m' or '1h'"
+ ) from exc
+ return CacheControl(CacheControlType.EPHEMERAL, ttl)
+
+
+def _reasoning_carrier(
+ value: str | None,
+ *,
+ kind: ReplayArtifactKind,
+ path: str,
+) -> tuple[ReplayArtifact, ...]:
+ if not value:
+ return ()
+ try:
+ decoded = decode_replay_envelope(
+ value,
+ attachment=ReplayAttachment.REASONING,
+ )
+ except ReplayEnvelopeError as exc:
+ raise AnthropicIngressError(f"{path}: {exc}") from exc
+ if decoded is not None:
+ return decoded
+ return (
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.ANTHROPIC,
+ kind=kind,
+ attachment=ReplayAttachment.REASONING,
+ payload=value,
+ ),
+ )
+
+
+def _tool_artifacts(
+ block: ContentBlockToolUse,
+ *,
+ path: str,
+) -> tuple[ReplayArtifact, ...]:
+ extra_content = _block_extras(block).get("extra_content")
+ if extra_content is None:
+ return ()
+ mapping = _mapping(extra_content, path=f"{path}.extra_content")
+ envelope = mapping.get("fcc_replay")
+ if envelope is not None:
+ if set(mapping) != {"fcc_replay"} or not isinstance(envelope, str):
+ raise AnthropicIngressError(
+ f"{path}.extra_content.fcc_replay must be the only non-empty string carrier"
+ )
+ try:
+ decoded = decode_replay_envelope(
+ envelope,
+ attachment=ReplayAttachment.TOOL_CALL,
+ )
+ except ReplayEnvelopeError as exc:
+ raise AnthropicIngressError(
+ f"{path}.extra_content.fcc_replay: {exc}"
+ ) from exc
+ if decoded is None:
+ raise AnthropicIngressError(
+ f"{path}.extra_content.fcc_replay must contain an FCC replay envelope"
+ )
+ return decoded
+ return (
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,
+ kind=ReplayArtifactKind.TOOL_EXTRA_CONTENT,
+ attachment=ReplayAttachment.TOOL_CALL,
+ payload=_json_object(mapping, path=f"{path}.extra_content"),
+ ),
+ )
+
+
+def _block_extras(block: BaseModel) -> Mapping[str, object]:
+ return cast(Mapping[str, object], block.model_extra or {})
+
+
+def _reject_model_extras(model: BaseModel, *, path: str) -> None:
+ extras = model.model_extra or {}
+ if extras:
+ key = sorted(str(key) for key in extras)[0]
+ raise AnthropicIngressError(f"{path}.{key} is not supported")
+
+
+def _mapping(value: object, *, path: str) -> Mapping[str, object]:
+ if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
+ raise AnthropicIngressError(f"{path} must be an object")
+ return cast(Mapping[str, object], value)
+
+
+def _require_exact_keys(
+ mapping: Mapping[str, object],
+ *,
+ allowed: set[str],
+ path: str,
+) -> None:
+ unknown = set(mapping) - allowed
+ if unknown:
+ raise AnthropicIngressError(
+ f"{path}.{sorted(str(key) for key in unknown)[0]} is not supported"
+ )
+
+
+def _required_mapping_str(mapping: Mapping[str, object], key: str, *, path: str) -> str:
+ value = mapping.get(key)
+ if not isinstance(value, str) or not value.strip():
+ raise AnthropicIngressError(f"{path}.{key} must be a non-empty string")
+ return value
+
+
+def _non_empty(value: str, *, path: str) -> str:
+ if not value.strip():
+ raise AnthropicIngressError(f"{path} must be a non-empty string")
+ return value
+
+
+def _json_object(value: object, *, path: str) -> dict[str, JsonValue]:
+ mapping = _mapping(value, path=path)
+ return {
+ str(key): _json_value(item, path=f"{path}.{key}")
+ for key, item in mapping.items()
+ }
+
+
+def _json_value(value: object, *, path: str) -> JsonValue:
+ if value is None or isinstance(value, bool | int | float | str):
+ return value
+ if isinstance(value, BaseModel):
+ return _json_value(value.model_dump(mode="python"), path=path)
+ if isinstance(value, Mapping):
+ if not all(isinstance(key, str) for key in value):
+ raise AnthropicIngressError(f"{path} object keys must be strings")
+ return {
+ str(key): _json_value(item, path=f"{path}.{key}")
+ for key, item in value.items()
+ }
+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+ return [
+ _json_value(item, path=f"{path}[{index}]")
+ for index, item in enumerate(value)
+ ]
+ raise AnthropicIngressError(f"{path} must contain JSON-compatible values")
diff --git a/src/free_claude_code/core/anthropic/models.py b/src/free_claude_code/core/anthropic/models.py
index 684f8cb0..d31d361c 100644
--- a/src/free_claude_code/core/anthropic/models.py
+++ b/src/free_claude_code/core/anthropic/models.py
@@ -79,6 +79,8 @@ class SystemContent(_AnthropicBlockBase):
class Message(BaseModel):
+ model_config = ConfigDict(extra="allow")
+
role: Literal["user", "assistant", "system"]
content: (
str
@@ -106,6 +108,8 @@ class Tool(_AnthropicBlockBase):
class ThinkingConfig(BaseModel):
+ model_config = ConfigDict(extra="allow")
+
enabled: bool | None = True
type: str | None = None
budget_tokens: int | None = None
@@ -115,8 +119,6 @@ class MessagesRequest(BaseModel):
model_config = ConfigDict(extra="allow")
model: str
- original_model: str | None = Field(default=None, exclude=True)
- resolved_provider_model: str | None = Field(default=None, exclude=True)
max_tokens: int | None = None
messages: list[Message]
system: str | list[SystemContent] | None = None
@@ -140,8 +142,6 @@ class TokenCountRequest(BaseModel):
model_config = ConfigDict(extra="allow")
model: str
- original_model: str | None = Field(default=None, exclude=True)
- resolved_provider_model: str | None = Field(default=None, exclude=True)
messages: list[Message]
system: str | list[SystemContent] | None = None
tools: list[Tool] | None = None
diff --git a/src/free_claude_code/core/anthropic/openai_tool_names.py b/src/free_claude_code/core/anthropic/openai_tool_names.py
deleted file mode 100644
index 9f1a2e5c..00000000
--- a/src/free_claude_code/core/anthropic/openai_tool_names.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""Reversible tool names for Anthropic-to-OpenAI protocol conversion."""
-
-import hashlib
-import re
-from collections.abc import Iterable
-from dataclasses import dataclass
-
-from .content import get_block_attr, get_block_type
-from .models import MessagesRequest
-
-OPENAI_TOOL_NAME_MAX_LENGTH = 64
-_ALIAS_DIGEST_LENGTH = 16
-_PORTABLE_TOOL_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
-_INVALID_TOOL_NAME_CHARACTERS = re.compile(r"[^A-Za-z0-9_-]+")
-
-
-@dataclass(frozen=True, slots=True)
-class OpenAIToolNameCodec:
- """Map non-portable client tool names to deterministic OpenAI aliases."""
-
- _original_to_alias: dict[str, str]
- _alias_to_original: dict[str, str]
- _unchanged_names: frozenset[str]
-
- @classmethod
- def from_request(cls, request: MessagesRequest) -> OpenAIToolNameCodec:
- """Build the codec from every tool identity carried by one request."""
- return cls.from_names(_request_tool_names(request))
-
- @classmethod
- def from_names(cls, names: Iterable[str]) -> OpenAIToolNameCodec:
- """Build order-independent aliases for the supplied non-empty names."""
- unique_names = {name for name in names if name}
- portable_names = {
- name for name in unique_names if _PORTABLE_TOOL_NAME.fullmatch(name)
- }
- reserved = set(portable_names)
- original_to_alias: dict[str, str] = {}
- alias_to_original: dict[str, str] = {}
-
- for name in sorted(unique_names - portable_names):
- alias = _unique_alias(name, reserved)
- reserved.add(alias)
- original_to_alias[name] = alias
- alias_to_original[alias] = name
-
- return cls(
- original_to_alias,
- alias_to_original,
- frozenset(portable_names),
- )
-
- @property
- def has_aliases(self) -> bool:
- """Return whether this request needs any tool-name translation."""
- return bool(self._original_to_alias)
-
- def encode(self, name: str) -> str:
- """Return the OpenAI wire name for one client name."""
- return self._original_to_alias.get(name, name)
-
- def decode(self, name: str) -> str:
- """Return the original client name for one known wire alias."""
- return self._alias_to_original.get(name, name)
-
- def is_alias(self, value: str) -> bool:
- """Return whether value is one complete alias generated for this request."""
- return value in self._alias_to_original
-
- def is_unchanged_name(self, value: str) -> bool:
- """Return whether value is one complete name sent upstream unchanged."""
- return value in self._unchanged_names
-
- def is_alias_prefix(self, value: str) -> bool:
- """Return whether value is an incomplete prefix of a generated alias."""
- return bool(value) and any(
- alias != value and alias.startswith(value)
- for alias in self._alias_to_original
- )
-
-
-def _request_tool_names(request: MessagesRequest) -> Iterable[str]:
- for tool in request.tools or ():
- yield tool.name
-
- tool_choice = request.tool_choice
- if isinstance(tool_choice, dict):
- choice_type = tool_choice.get("type")
- if choice_type == "tool":
- name = tool_choice.get("name")
- if isinstance(name, str):
- yield name
- elif choice_type == "function":
- function = tool_choice.get("function")
- if isinstance(function, dict):
- name = function.get("name")
- if isinstance(name, str):
- yield name
-
- for message in request.messages:
- if message.role != "assistant" or not isinstance(message.content, list):
- continue
- for block in message.content:
- if get_block_type(block) != "tool_use":
- continue
- name = get_block_attr(block, "name")
- if isinstance(name, str):
- yield name
-
-
-def _unique_alias(name: str, reserved: set[str]) -> str:
- readable = _INVALID_TOOL_NAME_CHARACTERS.sub("_", name).strip("_-") or "tool"
- max_readable_length = OPENAI_TOOL_NAME_MAX_LENGTH - _ALIAS_DIGEST_LENGTH - 1
- readable = readable[:max_readable_length].rstrip("_-") or "tool"
- attempt = 0
- while True:
- digest_input = name if attempt == 0 else f"{name}\0{attempt}"
- digest = hashlib.sha256(digest_input.encode("utf-8")).hexdigest()[
- :_ALIAS_DIGEST_LENGTH
- ]
- alias = f"{readable}_{digest}"
- if alias not in reserved:
- return alias
- attempt += 1
diff --git a/src/free_claude_code/core/anthropic/presenter.py b/src/free_claude_code/core/anthropic/presenter.py
index f66ea5c3..f130c771 100644
--- a/src/free_claude_code/core/anthropic/presenter.py
+++ b/src/free_claude_code/core/anthropic/presenter.py
@@ -26,9 +26,9 @@ from free_claude_code.core.inference import (
ToolCallCompleted,
ToolCallStarted,
UsageUpdated,
- replay_payload_text,
)
from free_claude_code.core.json_types import JsonObject, JsonValue
+from free_claude_code.core.replay_envelope import encode_replay_envelope
from free_claude_code.core.trace import close_stream_input
from .streaming.emitter import AnthropicSseEmitter
@@ -39,7 +39,6 @@ class _WireBlock:
index: int | None
block_type: str
open: bool
- emitted_artifacts: int = 0
class AnthropicEventPresenter:
@@ -146,7 +145,6 @@ class AnthropicEventPresenter:
for artifact in event.artifacts
):
chunks.append(self._start_reasoning_wire_block(block))
- chunks.extend(self._emit_reasoning_artifacts(block, event.artifacts))
return chunks
def _reasoning_delta(self, event: ReasoningDelta) -> list[str]:
@@ -173,10 +171,16 @@ class AnthropicEventPresenter:
def _reasoning_completed(self, event: ReasoningBlockCompleted) -> list[str]:
block = self._require_block(event.block_id, "reasoning")
chunks: list[str] = []
- if block.open:
+ if event.artifacts:
+ if block.open or event.reasoning:
+ if not block.open:
+ chunks.append(self._start_reasoning_wire_block(block))
+ chunks.append(self._signature_delta(block, event.artifacts))
+ chunks.append(self._stop_wire_block(block))
+ else:
+ chunks.extend(self._redacted_reasoning_block(event.artifacts))
+ elif block.open:
chunks.append(self._stop_wire_block(block))
- remaining = event.artifacts[block.emitted_artifacts :]
- chunks.extend(self._emit_reasoning_artifacts(block, remaining))
block.open = False
return chunks
@@ -241,58 +245,44 @@ class AnthropicEventPresenter:
self._emitter.event("message_stop", {"type": "message_stop"}),
]
- def _emit_reasoning_artifacts(
+ def _signature_delta(
self,
block: _WireBlock,
artifacts: tuple[ReplayArtifact, ...],
+ ) -> str:
+ return self._emitter.event(
+ "content_block_delta",
+ {
+ "type": "content_block_delta",
+ "index": _required_index(block),
+ "delta": {
+ "type": "signature_delta",
+ "signature": encode_replay_envelope(artifacts),
+ },
+ },
+ )
+
+ def _redacted_reasoning_block(
+ self, artifacts: tuple[ReplayArtifact, ...]
) -> list[str]:
- chunks: list[str] = []
- for artifact in artifacts:
- if artifact.kind is ReplayArtifactKind.THINKING_SIGNATURE:
- if not block.open:
- chunks.append(self._start_reasoning_wire_block(block))
- chunks.append(
- self._emitter.event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": _required_index(block),
- "delta": {
- "type": "signature_delta",
- "signature": replay_payload_text(artifact),
- },
- },
- )
- )
- elif artifact.kind in {
- ReplayArtifactKind.REDACTED_THINKING,
- ReplayArtifactKind.ENCRYPTED_REASONING,
- ReplayArtifactKind.REASONING_DETAILS,
- }:
- if block.open:
- chunks.append(self._stop_wire_block(block))
- index = self._allocate_index()
- chunks.extend(
- [
- self._emitter.event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": index,
- "content_block": {
- "type": "redacted_thinking",
- "data": replay_payload_text(artifact),
- },
- },
- ),
- self._emitter.event(
- "content_block_stop",
- {"type": "content_block_stop", "index": index},
- ),
- ]
- )
- block.emitted_artifacts += 1
- return chunks
+ index = self._allocate_index()
+ return [
+ self._emitter.event(
+ "content_block_start",
+ {
+ "type": "content_block_start",
+ "index": index,
+ "content_block": {
+ "type": "redacted_thinking",
+ "data": encode_replay_envelope(artifacts),
+ },
+ },
+ ),
+ self._emitter.event(
+ "content_block_stop",
+ {"type": "content_block_stop", "index": index},
+ ),
+ ]
def _start_reasoning_wire_block(self, block: _WireBlock) -> str:
block.index = self._allocate_index()
@@ -390,7 +380,8 @@ async def aggregate_inference_events_to_message(
"signature": _reasoning_signature(event.artifacts),
}
content.append(block)
- content.extend(_redacted_reasoning_blocks(event.artifacts))
+ elif event.artifacts:
+ content.extend(_redacted_reasoning_blocks(event.artifacts))
elif isinstance(event, ToolCallCompleted):
tool_input: JsonValue = {}
if event.arguments.strip():
@@ -472,43 +463,22 @@ def _usage_value(measurement: TokenMeasurement | None) -> int:
def _tool_extra_content(
artifacts: tuple[ReplayArtifact, ...],
) -> JsonObject | None:
- result: JsonObject = {}
- for artifact in artifacts:
- if artifact.kind is ReplayArtifactKind.THOUGHT_SIGNATURE:
- result["google"] = {"thought_signature": replay_payload_text(artifact)}
- elif artifact.kind is ReplayArtifactKind.TOOL_EXTRA_CONTENT and isinstance(
- artifact.payload, Mapping
- ):
- result.update(
- {
- str(key): _json_value(value)
- for key, value in artifact.payload.items()
- }
- )
- return result or None
+ return {"fcc_replay": encode_replay_envelope(artifacts)} if artifacts else None
def _reasoning_signature(artifacts: tuple[ReplayArtifact, ...]) -> str:
- for artifact in artifacts:
- if artifact.kind is ReplayArtifactKind.THINKING_SIGNATURE:
- return replay_payload_text(artifact)
- return ""
+ return encode_replay_envelope(artifacts) if artifacts else ""
def _redacted_reasoning_blocks(
artifacts: tuple[ReplayArtifact, ...],
) -> list[JsonValue]:
+ if not artifacts:
+ return []
return [
{
"type": "redacted_thinking",
- "data": replay_payload_text(artifact),
- }
- for artifact in artifacts
- if artifact.kind
- in {
- ReplayArtifactKind.REDACTED_THINKING,
- ReplayArtifactKind.ENCRYPTED_REASONING,
- ReplayArtifactKind.REASONING_DETAILS,
+ "data": encode_replay_envelope(artifacts),
}
]
diff --git a/src/free_claude_code/core/anthropic/request_serialization.py b/src/free_claude_code/core/anthropic/request_serialization.py
deleted file mode 100644
index 7b3aba68..00000000
--- a/src/free_claude_code/core/anthropic/request_serialization.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""Shared Anthropic request serialization helpers."""
-
-import json
-from typing import Any
-
-from .models import MessagesRequest
-
-_MESSAGES_REQUEST_FIELDS = (
- "model",
- "messages",
- "system",
- "max_tokens",
- "stop_sequences",
- "stream",
- "temperature",
- "top_p",
- "top_k",
- "metadata",
- "tools",
- "tool_choice",
- "thinking",
- "context_management",
- "output_config",
- "mcp_servers",
- "extra_body",
-)
-
-
-def dump_messages_request(request: MessagesRequest) -> dict[str, Any]:
- """Return JSON-ready public Messages fields without FCC routing state."""
- raw = request.model_dump(exclude_none=True)
- return {
- field: raw[field]
- for field in _MESSAGES_REQUEST_FIELDS
- if field in raw and raw[field] is not None
- }
-
-
-def serialize_tool_result_content(content: Any) -> str:
- """Serialize Anthropic ``tool_result.content`` into provider-safe text."""
- if content is None:
- return ""
- if isinstance(content, str):
- return content
- if isinstance(content, dict):
- return json.dumps(content, ensure_ascii=False)
- if isinstance(content, list):
- parts: list[str] = []
- for item in content:
- if isinstance(item, dict) and item.get("type") == "text":
- parts.append(str(item.get("text", "")))
- elif isinstance(item, dict):
- parts.append(json.dumps(item, ensure_ascii=False))
- else:
- parts.append(str(item))
- return "\n".join(parts)
- return str(content)
diff --git a/src/free_claude_code/core/anthropic/request_snapshot.py b/src/free_claude_code/core/anthropic/request_snapshot.py
deleted file mode 100644
index 36bb85bb..00000000
--- a/src/free_claude_code/core/anthropic/request_snapshot.py
+++ /dev/null
@@ -1,35 +0,0 @@
-"""Trace-safe snapshots of Anthropic protocol requests."""
-
-from typing import Any
-
-from free_claude_code.core.trace import sanitize_trace_value
-
-from .models import MessagesRequest, TokenCountRequest
-
-
-def anthropic_request_snapshot(
- request: MessagesRequest | TokenCountRequest,
-) -> dict[str, Any]:
- """Return the traceable public fields of an Anthropic request."""
- data = request.model_dump(mode="python")
- snapshot = {
- key: data[key]
- for key in (
- "model",
- "messages",
- "system",
- "tools",
- "tool_choice",
- "max_tokens",
- "thinking",
- "temperature",
- "top_p",
- "top_k",
- "stop_sequences",
- "metadata",
- "stream",
- )
- if key in data and data[key] is not None
- }
- sanitized = sanitize_trace_value(snapshot)
- return sanitized if isinstance(sanitized, dict) else {}
diff --git a/src/free_claude_code/core/anthropic/streaming/__init__.py b/src/free_claude_code/core/anthropic/streaming/__init__.py
index 10be1b1b..ccc71770 100644
--- a/src/free_claude_code/core/anthropic/streaming/__init__.py
+++ b/src/free_claude_code/core/anthropic/streaming/__init__.py
@@ -8,30 +8,12 @@ from .emitter import (
format_sse_event,
map_stop_reason,
)
-from .recovery import (
- ToolSchema,
- accept_tool_json_repair,
- continuation_suffix,
- make_response_recovery_body,
- make_text_recovery_body,
- make_tool_repair_body,
- parse_complete_tool_input,
- tool_schemas_by_name,
-)
__all__ = [
"ANTHROPIC_SSE_RESPONSE_HEADERS",
"AnthropicSseEmitter",
- "ToolSchema",
- "accept_tool_json_repair",
"anthropic_terminal_error_frame",
"anthropic_terminal_failure_frame",
- "continuation_suffix",
"format_sse_event",
- "make_response_recovery_body",
- "make_text_recovery_body",
- "make_tool_repair_body",
"map_stop_reason",
- "parse_complete_tool_input",
- "tool_schemas_by_name",
]
diff --git a/src/free_claude_code/core/anthropic/tokens.py b/src/free_claude_code/core/anthropic/tokens.py
deleted file mode 100644
index 72ec3443..00000000
--- a/src/free_claude_code/core/anthropic/tokens.py
+++ /dev/null
@@ -1,111 +0,0 @@
-"""Token estimation for Anthropic-compatible requests."""
-
-import json
-
-from loguru import logger
-
-from free_claude_code.core.token_estimation import estimate_text_tokens
-
-from .content import get_block_attr
-from .models import Message, SystemContent, Tool
-
-
-def get_token_count(
- messages: list[Message],
- system: str | list[SystemContent] | None = None,
- tools: list[Tool] | None = None,
-) -> int:
- """Estimate token count for a request."""
- total_tokens = 0
-
- if system:
- if isinstance(system, str):
- total_tokens += estimate_text_tokens(system)
- elif isinstance(system, list):
- for block in system:
- text = get_block_attr(block, "text", "")
- if text:
- total_tokens += estimate_text_tokens(str(text))
- total_tokens += 4
-
- for msg in messages:
- if isinstance(msg.content, str):
- total_tokens += estimate_text_tokens(msg.content)
- elif isinstance(msg.content, list):
- for block in msg.content:
- b_type = get_block_attr(block, "type") or None
-
- if b_type == "text":
- text = get_block_attr(block, "text", "")
- total_tokens += estimate_text_tokens(str(text))
- elif b_type == "thinking":
- thinking = get_block_attr(block, "thinking", "")
- total_tokens += estimate_text_tokens(str(thinking))
- elif b_type == "tool_use":
- name = get_block_attr(block, "name", "")
- inp = get_block_attr(block, "input", {})
- block_id = get_block_attr(block, "id", "")
- total_tokens += estimate_text_tokens(str(name))
- total_tokens += estimate_text_tokens(json.dumps(inp))
- total_tokens += estimate_text_tokens(str(block_id))
- total_tokens += 15
- elif b_type == "image":
- source = get_block_attr(block, "source")
- if isinstance(source, dict):
- data = source.get("data") or source.get("base64") or ""
- if data:
- total_tokens += max(85, len(data) // 3000)
- else:
- total_tokens += 765
- else:
- total_tokens += 765
- elif b_type == "tool_result":
- content = get_block_attr(block, "content", "")
- tool_use_id = get_block_attr(block, "tool_use_id", "")
- if isinstance(content, str):
- total_tokens += estimate_text_tokens(content)
- else:
- total_tokens += estimate_text_tokens(json.dumps(content))
- total_tokens += estimate_text_tokens(str(tool_use_id))
- total_tokens += 8
- elif b_type in (
- "server_tool_use",
- "web_search_tool_result",
- "web_fetch_tool_result",
- ):
- if hasattr(block, "model_dump"):
- blob: object = block.model_dump()
- else:
- blob = block
- try:
- total_tokens += estimate_text_tokens(
- json.dumps(blob, default=str, ensure_ascii=False)
- )
- except (TypeError, ValueError, OverflowError) as e:
- logger.debug(
- "Block encode fallback b_type={} err={}", b_type, e
- )
- total_tokens += estimate_text_tokens(str(blob))
- total_tokens += 12
- else:
- logger.debug(
- "Unexpected block type %r, falling back to json/str encoding",
- b_type,
- )
- try:
- total_tokens += estimate_text_tokens(json.dumps(block))
- except TypeError, ValueError:
- total_tokens += estimate_text_tokens(str(block))
-
- if tools:
- for tool in tools:
- tool_str = (
- tool.name + (tool.description or "") + json.dumps(tool.input_schema)
- )
- total_tokens += estimate_text_tokens(tool_str)
-
- total_tokens += len(messages) * 4
- if tools:
- total_tokens += len(tools) * 5
-
- return max(1, total_tokens)
diff --git a/src/free_claude_code/core/anthropic/tools.py b/src/free_claude_code/core/anthropic/tools.py
index 7513e07e..c09beb54 100644
--- a/src/free_claude_code/core/anthropic/tools.py
+++ b/src/free_claude_code/core/anthropic/tools.py
@@ -3,264 +3,14 @@
import json
import re
import uuid
-from collections.abc import Mapping
-from dataclasses import dataclass
from enum import Enum
from typing import Any
from loguru import logger
-from .models import MessagesRequest
-from .openai_tool_names import OpenAIToolNameCodec
-from .tool_schema import arguments_match_schema, coerce_text_argument
-
_CONTROL_TOKEN_RE = re.compile(r"<\|[^|>]{1,80}\|>")
_CONTROL_TOKEN_START = "<|"
_CONTROL_TOKEN_END = "|>"
-_FUNCTION_TAG_BLOCK_START = "<tool_call>"
-_FUNCTION_TAG_BLOCK_END = "</tool_call>"
-_FUNCTION_TAG_START = "<function="
-_FUNCTION_TAG_END = "</function>"
-_PARAMETER_TAG_START = "<parameter="
-_PARAMETER_TAG_END = "</parameter>"
-_MAX_FUNCTION_TAG_CANDIDATE_CHARS = 4 * 1024 * 1024
-
-
-@dataclass(frozen=True, slots=True)
-class _RawFunctionTagCall:
- name: str
- arguments: dict[str, str]
-
-
-class _FunctionTagState(Enum):
- SEARCHING = 1
- CANDIDATE = 2
- DISABLED = 3
- FINISHED = 4
-
-
-class FunctionTagToolParser:
- """Parse an exact terminal function-tag envelope into tool use."""
-
- def __init__(self, request: MessagesRequest):
- self._tool_names = OpenAIToolNameCodec.from_request(request)
- self._schemas: dict[str, dict[str, Any]] = {}
- for tool in request.tools or ():
- if tool.name:
- self._schemas[tool.name] = (
- tool.input_schema
- if tool.input_schema is not None
- else {"type": "object"}
- )
- tool_choice = request.tool_choice
- tool_choice_type = (
- tool_choice.get("type") if isinstance(tool_choice, dict) else None
- )
- self._state = (
- _FunctionTagState.SEARCHING
- if self._schemas and tool_choice_type != "none"
- else _FunctionTagState.DISABLED
- )
- self._parts: list[str] = []
- self._length = 0
- self._marker_tail = ""
-
- def feed(self, text: str) -> str:
- """Hold a possible reserved response and return text safe to expose."""
- if not text:
- return ""
- if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:
- return text
-
- if self._state is _FunctionTagState.CANDIDATE:
- self._parts.append(text)
- self._length += len(text)
- if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:
- return self.disable()
- return ""
-
- candidate = "".join((self._marker_tail, text))
- marker_index = candidate.find(_FUNCTION_TAG_BLOCK_START)
- if marker_index >= 0:
- visible = candidate[:marker_index]
- control = candidate[marker_index:]
- self._state = _FunctionTagState.CANDIDATE
- self._marker_tail = ""
- self._parts.append(control)
- self._length = len(control)
- if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:
- return "".join((visible, self.disable()))
- return visible
-
- held_length = _partial_function_tag_marker_suffix_length(candidate)
- if held_length:
- self._marker_tail = candidate[-held_length:]
- return candidate[:-held_length]
- self._marker_tail = ""
- return candidate
-
- def disable(self) -> str:
- """Disable textual recovery and release any held candidate unchanged."""
- if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:
- return ""
- self._state = _FunctionTagState.DISABLED
- text = "".join((self._marker_tail, *self._parts))
- self._marker_tail = ""
- self._parts.clear()
- self._length = 0
- return text
-
- def finish(self) -> tuple[str, tuple[dict[str, Any], ...]]:
- """Finalize one response atomically as visible text or validated tools."""
- if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:
- return "", ()
- if self._state is _FunctionTagState.SEARCHING:
- self._state = _FunctionTagState.FINISHED
- text = self._marker_tail
- self._marker_tail = ""
- return text, ()
- self._state = _FunctionTagState.FINISHED
- raw = "".join(self._parts)
- self._parts.clear()
- self._length = 0
- try:
- calls = _parse_function_tag_calls(raw)
- tool_uses = self._validated_tool_uses(calls)
- except ValueError:
- return raw, ()
- return "", tool_uses
-
- def _validated_tool_uses(
- self, calls: tuple[_RawFunctionTagCall, ...]
- ) -> tuple[dict[str, Any], ...]:
- tool_uses: list[dict[str, Any]] = []
- for call in calls:
- name = self._tool_names.decode(call.name)
- schema = self._schemas.get(name)
- if schema is None:
- raise ValueError
- properties = schema.get("properties")
- property_schemas = properties if isinstance(properties, Mapping) else {}
- additional = schema.get("additionalProperties")
- arguments: dict[str, Any] = {}
- for parameter_name, value in call.arguments.items():
- parameter_schema = property_schemas.get(parameter_name)
- if not isinstance(parameter_schema, Mapping):
- parameter_schema = (
- additional if isinstance(additional, Mapping) else {}
- )
- arguments[parameter_name] = coerce_text_argument(
- value,
- parameter_schema,
- )
- if not arguments_match_schema(arguments, schema):
- raise ValueError
- tool_uses.append(
- {
- "type": "tool_use",
- "id": f"toolu_function_tag_{uuid.uuid4().hex[:8]}",
- "name": name,
- "input": arguments,
- }
- )
- return tuple(tool_uses)
-
-
-def _parse_function_tag_calls(text: str) -> tuple[_RawFunctionTagCall, ...]:
- cursor = 0
- calls: list[_RawFunctionTagCall] = []
- while True:
- cursor = _skip_function_tag_whitespace(text, cursor)
- if cursor == len(text):
- break
- if not text.startswith(_FUNCTION_TAG_BLOCK_START, cursor):
- raise ValueError
-
- block_start = cursor + len(_FUNCTION_TAG_BLOCK_START)
- block_end = text.find(_FUNCTION_TAG_BLOCK_END, block_start)
- if block_end < 0:
- raise ValueError
- name, arguments = _parse_function_tag_block(text[block_start:block_end])
- calls.append(_RawFunctionTagCall(name=name, arguments=arguments))
- cursor = block_end + len(_FUNCTION_TAG_BLOCK_END)
-
- if not calls:
- raise ValueError
- return tuple(calls)
-
-
-def _parse_function_tag_block(block: str) -> tuple[str, dict[str, str]]:
- cursor = _skip_function_tag_whitespace(block, 0)
- if not block.startswith(_FUNCTION_TAG_START, cursor):
- raise ValueError
- name_end = block.find(">", cursor + len(_FUNCTION_TAG_START))
- if name_end < 0:
- raise ValueError
- name = block[cursor + len(_FUNCTION_TAG_START) : name_end]
- if not _valid_function_tag_name(name):
- raise ValueError
-
- arguments: dict[str, str] = {}
- cursor = name_end + 1
- while True:
- cursor = _skip_function_tag_whitespace(block, cursor)
- if block.startswith(_FUNCTION_TAG_END, cursor):
- cursor += len(_FUNCTION_TAG_END)
- break
- if cursor == len(block) or not block.startswith(_PARAMETER_TAG_START, cursor):
- raise ValueError
-
- parameter_name_end = block.find(">", cursor + len(_PARAMETER_TAG_START))
- if parameter_name_end < 0:
- raise ValueError
- parameter_name = block[cursor + len(_PARAMETER_TAG_START) : parameter_name_end]
- if not _valid_function_tag_name(parameter_name) or parameter_name in arguments:
- raise ValueError
-
- value_start = parameter_name_end + 1
- value_end = block.find(_PARAMETER_TAG_END, value_start)
- if value_end < 0:
- raise ValueError
- arguments[parameter_name] = _unwrap_function_tag_newlines(
- block[value_start:value_end]
- )
- cursor = value_end + len(_PARAMETER_TAG_END)
-
- if block[cursor:].strip():
- raise ValueError
- return name, arguments
-
-
-def _skip_function_tag_whitespace(text: str, cursor: int) -> int:
- while cursor < len(text) and text[cursor].isspace():
- cursor += 1
- return cursor
-
-
-def _valid_function_tag_name(value: str) -> bool:
- return bool(value) and not any(
- character.isspace() or character in "<>" for character in value
- )
-
-
-def _unwrap_function_tag_newlines(value: str) -> str:
- if value.startswith("\r\n"):
- value = value[2:]
- elif value.startswith("\n"):
- value = value[1:]
- if value.endswith("\r\n"):
- return value[:-2]
- if value.endswith("\n"):
- return value[:-1]
- return value
-
-
-def _partial_function_tag_marker_suffix_length(text: str) -> int:
- max_length = min(len(text), len(_FUNCTION_TAG_BLOCK_START) - 1)
- for length in range(max_length, 0, -1):
- if _FUNCTION_TAG_BLOCK_START.startswith(text[-length:]):
- return length
- return 0
class ParserState(Enum):
diff --git a/src/free_claude_code/core/inference/__init__.py b/src/free_claude_code/core/inference/__init__.py
index eaf3934a..7144390f 100644
--- a/src/free_claude_code/core/inference/__init__.py
+++ b/src/free_claude_code/core/inference/__init__.py
@@ -11,6 +11,7 @@ from .events import (
ReplayArtifactKind,
ReplayArtifactOrigin,
ReplayAttachment,
+ ReplayCompatibilityScope,
ResponseCompleted,
ResponseStarted,
TextBlockCompleted,
@@ -32,34 +33,113 @@ from .ledger import (
InferenceStreamLedger,
ToolCallState,
)
+from .request import (
+ Base64MediaSource,
+ CacheControl,
+ CacheControlType,
+ CacheTTL,
+ ClientReasoningIntent,
+ CustomTool,
+ CustomToolFormat,
+ CustomToolFormatType,
+ DocumentContent,
+ FileMediaSource,
+ FunctionTool,
+ ImageContent,
+ InferenceExtension,
+ InferenceItem,
+ InferenceRequest,
+ InferenceTool,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MediaSource,
+ MessageContent,
+ MessageItem,
+ MessageRole,
+ OpenAIChatExtension,
+ ReasoningItem,
+ RefusalContent,
+ TextContent,
+ ToolCallItem,
+ ToolChoice,
+ ToolChoiceMode,
+ ToolResultItem,
+ UrlMediaSource,
+ freeze_json,
+ freeze_json_object,
+ inference_request_snapshot,
+ thaw_json,
+ thaw_json_object,
+)
+from .tokens import get_inference_token_count
__all__ = [
+ "Base64MediaSource",
+ "CacheControl",
+ "CacheControlType",
+ "CacheTTL",
+ "ClientReasoningIntent",
+ "CustomTool",
+ "CustomToolFormat",
+ "CustomToolFormatType",
+ "DocumentContent",
+ "FileMediaSource",
"FinishReason",
+ "FunctionTool",
+ "ImageContent",
"InferenceBlockLedger",
"InferenceBlockState",
"InferenceEvent",
+ "InferenceExtension",
+ "InferenceItem",
+ "InferenceRequest",
"InferenceStreamLedger",
+ "InferenceTool",
"InferenceUsage",
+ "InstructionItem",
+ "InstructionOrigin",
+ "InstructionPlacement",
+ "MediaSource",
+ "MessageContent",
+ "MessageItem",
+ "MessageRole",
+ "OpenAIChatExtension",
"ReasoningBlockCompleted",
"ReasoningBlockStarted",
"ReasoningDelta",
+ "ReasoningItem",
+ "RefusalContent",
"ReplayArtifact",
"ReplayArtifactKind",
"ReplayArtifactOrigin",
"ReplayAttachment",
+ "ReplayCompatibilityScope",
"ResponseCompleted",
"ResponseStarted",
"TextBlockCompleted",
"TextBlockStarted",
+ "TextContent",
"TextDelta",
"TokenMeasurement",
"ToolCallArgumentsDelta",
"ToolCallCompleted",
+ "ToolCallItem",
"ToolCallKind",
"ToolCallStarted",
"ToolCallState",
+ "ToolChoice",
+ "ToolChoiceMode",
+ "ToolResultItem",
+ "UrlMediaSource",
"UsageSource",
"UsageUpdated",
+ "freeze_json",
+ "freeze_json_object",
+ "get_inference_token_count",
"inference_event_size",
+ "inference_request_snapshot",
"replay_payload_text",
+ "thaw_json",
+ "thaw_json_object",
]
diff --git a/src/free_claude_code/core/inference/events.py b/src/free_claude_code/core/inference/events.py
index f12c6071..a6769d5f 100644
--- a/src/free_claude_code/core/inference/events.py
+++ b/src/free_claude_code/core/inference/events.py
@@ -81,6 +81,17 @@ class ReplayAttachment(StrEnum):
TOOL_CALL = "tool_call"
+@dataclass(frozen=True, slots=True)
+class ReplayCompatibilityScope:
+ """Opaque route identity required for safe upstream replay."""
+
+ value: str
+
+ def __post_init__(self) -> None:
+ if not self.value.strip():
+ raise ValueError("replay compatibility scope must be non-empty")
+
+
@dataclass(frozen=True, slots=True)
class ReplayArtifact:
"""Opaque provider replay material with a typed owner and scope."""
@@ -89,6 +100,7 @@ class ReplayArtifact:
kind: ReplayArtifactKind
attachment: ReplayAttachment
payload: JsonValue
+ scope: ReplayCompatibilityScope | None = None
class ToolCallKind(StrEnum):
@@ -316,6 +328,7 @@ def _artifacts(artifacts: tuple[ReplayArtifact, ...]) -> JsonValue:
artifact.origin.value,
artifact.kind.value,
artifact.attachment.value,
+ artifact.scope.value if artifact.scope is not None else None,
_json_projection(artifact.payload),
]
for artifact in artifacts
diff --git a/src/free_claude_code/core/inference/ledger.py b/src/free_claude_code/core/inference/ledger.py
index 51df919a..1cbe3556 100644
--- a/src/free_claude_code/core/inference/ledger.py
+++ b/src/free_claude_code/core/inference/ledger.py
@@ -1,14 +1,9 @@
"""Semantic state for one provider-neutral inference stream."""
-import hashlib
-import json
import uuid
from collections.abc import Iterator
from dataclasses import dataclass, field
-from loguru import logger
-
-from free_claude_code.core.json_types import JsonValue
from free_claude_code.core.token_estimation import estimate_text_tokens
from .events import (
@@ -19,6 +14,7 @@ from .events import (
ReasoningBlockStarted,
ReasoningDelta,
ReplayArtifact,
+ ReplayAttachment,
ResponseCompleted,
ResponseStarted,
TextBlockCompleted,
@@ -50,8 +46,6 @@ class ToolCallState:
namespace: str | None = None
artifacts: tuple[ReplayArtifact, ...] = ()
started: bool = False
- task_arg_buffer: str = ""
- task_args_emitted: bool = False
pre_start_args: str = ""
@@ -99,62 +93,22 @@ class InferenceBlockLedger:
state = self.ensure_tool_state(index)
state.artifacts = _merge_artifacts(state.artifacts, artifacts)
- def register_tool_name(self, index: int, name: str) -> None:
+ def register_tool_identity(
+ self,
+ index: int,
+ name: str,
+ *,
+ kind: ToolCallKind,
+ namespace: str | None,
+ ) -> None:
state = self.ensure_tool_state(index)
previous = state.name
if not previous or name.startswith(previous):
state.name = name
elif not previous.startswith(name):
state.name = "".join((previous, name))
-
- def buffer_task_args(self, index: int, args: str) -> dict[str, JsonValue] | None:
- state = self.tool_states.get(index)
- if state is None or state.task_args_emitted:
- return None
-
- state.task_arg_buffer += args
- try:
- parsed: JsonValue = json.loads(state.task_arg_buffer)
- except json.JSONDecodeError, TypeError, ValueError:
- return None
- if not isinstance(parsed, dict):
- return None
-
- normalized = {str(key): value for key, value in parsed.items()}
- _normalize_task_run_in_background(normalized)
- state.task_args_emitted = True
- state.task_arg_buffer = ""
- return normalized
-
- def flush_task_arg_buffers(self) -> list[tuple[int, str]]:
- results: list[tuple[int, str]] = []
- for tool_index, state in list(self.tool_states.items()):
- if not state.task_arg_buffer or state.task_args_emitted:
- continue
-
- output = "{}"
- try:
- parsed: JsonValue = json.loads(state.task_arg_buffer)
- if isinstance(parsed, dict):
- normalized = {str(key): value for key, value in parsed.items()}
- _normalize_task_run_in_background(normalized)
- output = json.dumps(normalized)
- except (json.JSONDecodeError, TypeError, ValueError) as exc:
- digest = hashlib.sha256(
- state.task_arg_buffer.encode("utf-8", errors="replace")
- ).hexdigest()[:16]
- logger.warning(
- "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",
- state.call_id or "unknown",
- len(state.task_arg_buffer),
- digest,
- exc,
- )
-
- state.task_args_emitted = True
- state.task_arg_buffer = ""
- results.append((tool_index, output))
- return results
+ state.kind = kind
+ state.namespace = namespace
class InferenceStreamLedger:
@@ -191,6 +145,7 @@ class InferenceStreamLedger:
self, *, artifacts: tuple[ReplayArtifact, ...] = ()
) -> ReasoningBlockStarted:
self._require_response_open()
+ _require_artifact_attachment(artifacts, ReplayAttachment.REASONING)
block_id = _new_identity("block")
item_id = _new_identity("item")
self.blocks.reasoning_block_id = block_id
@@ -265,6 +220,7 @@ class InferenceStreamLedger:
artifacts: tuple[ReplayArtifact, ...] = (),
) -> ToolCallStarted:
self._require_response_open()
+ _require_artifact_attachment(artifacts, ReplayAttachment.TOOL_CALL)
block_id = _new_identity("block")
item_id = _new_identity("item")
state = self.blocks.ensure_tool_state(tool_index)
@@ -300,6 +256,7 @@ class InferenceStreamLedger:
def set_tool_artifacts(
self, tool_index: int, artifacts: tuple[ReplayArtifact, ...]
) -> None:
+ _require_artifact_attachment(artifacts, ReplayAttachment.TOOL_CALL)
self.blocks.set_tool_artifacts(tool_index, artifacts)
state = self.blocks.tool_states[tool_index]
if not state.block_id:
@@ -498,6 +455,10 @@ def _merge_artifacts(
return (*existing, *(artifact for artifact in incoming if artifact not in existing))
-def _normalize_task_run_in_background(args: dict[str, JsonValue]) -> None:
- if args.get("run_in_background") is not False:
- args["run_in_background"] = False
+def _require_artifact_attachment(
+ artifacts: tuple[ReplayArtifact, ...], expected: ReplayAttachment
+) -> None:
+ if any(artifact.attachment is not expected for artifact in artifacts):
+ raise ValueError(
+ f"replay artifacts on {expected.value} output must use that attachment"
+ )
diff --git a/src/free_claude_code/core/inference/request.py b/src/free_claude_code/core/inference/request.py
new file mode 100644
index 00000000..25251e0a
--- /dev/null
+++ b/src/free_claude_code/core/inference/request.py
@@ -0,0 +1,431 @@
+"""Provider-neutral inference request values."""
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, replace
+from enum import StrEnum
+from types import MappingProxyType
+
+from free_claude_code.core.json_types import JsonValue
+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort
+
+from .events import ReplayArtifact, ToolCallKind
+
+
+class CacheControlType(StrEnum):
+ """Supported client prompt-cache breakpoint kind."""
+
+ EPHEMERAL = "ephemeral"
+
+
+class CacheTTL(StrEnum):
+ """Supported Anthropic prompt-cache durations."""
+
+ FIVE_MINUTES = "5m"
+ ONE_HOUR = "1h"
+
+
+@dataclass(frozen=True, slots=True)
+class CacheControl:
+ """One typed prompt-cache breakpoint."""
+
+ type: CacheControlType = CacheControlType.EPHEMERAL
+ ttl: CacheTTL | None = None
+
+
+class InstructionOrigin(StrEnum):
+ """Client role that supplied an instruction."""
+
+ SYSTEM = "system"
+ DEVELOPER = "developer"
+
+
+class InstructionPlacement(StrEnum):
+ """Whether an instruction was top-level or part of the transcript."""
+
+ TOP_LEVEL = "top_level"
+ TRANSCRIPT = "transcript"
+
+
+class MessageRole(StrEnum):
+ """Canonical conversational message roles."""
+
+ USER = "user"
+ ASSISTANT = "assistant"
+
+
+@dataclass(frozen=True, slots=True)
+class UrlMediaSource:
+ """A media resource referenced by URL."""
+
+ url: str
+
+ def __post_init__(self) -> None:
+ if not self.url.strip():
+ raise ValueError("media URL must be non-empty")
+
+
+@dataclass(frozen=True, slots=True)
+class Base64MediaSource:
+ """Inline base64 media with an explicit MIME type."""
+
+ media_type: str
+ data: str
+
+ def __post_init__(self) -> None:
+ if not self.media_type.strip():
+ raise ValueError("base64 media_type must be non-empty")
+ if not self.data.strip():
+ raise ValueError("base64 media data must be non-empty")
+
+
+@dataclass(frozen=True, slots=True)
+class FileMediaSource:
+ """A protocol-owned uploaded file reference."""
+
+ file_id: str
+
+ def __post_init__(self) -> None:
+ if not self.file_id.strip():
+ raise ValueError("file_id must be non-empty")
+
+
+type MediaSource = UrlMediaSource | Base64MediaSource | FileMediaSource
+
+
+@dataclass(frozen=True, slots=True)
+class TextContent:
+ """Visible text content."""
+
+ text: str
+ cache_control: CacheControl | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ImageContent:
+ """User image content."""
+
+ source: UrlMediaSource | Base64MediaSource
+ cache_control: CacheControl | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class DocumentContent:
+ """User document content retained for transport preflight."""
+
+ source: MediaSource
+ cache_control: CacheControl | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class RefusalContent:
+ """A prior assistant refusal preserved as such."""
+
+ refusal: str
+
+
+type MessageContent = TextContent | ImageContent | DocumentContent | RefusalContent
+
+
+@dataclass(frozen=True, slots=True)
+class InstructionItem:
+ """One ordered instruction."""
+
+ text: str
+ origin: InstructionOrigin
+ placement: InstructionPlacement
+ cache_control: CacheControl | None = None
+ turn_id: str | None = None
+
+ def __post_init__(self) -> None:
+ if (self.placement is InstructionPlacement.TRANSCRIPT) != (
+ self.turn_id is not None
+ ):
+ raise ValueError("only transcript instructions require a turn_id")
+
+
+@dataclass(frozen=True, slots=True)
+class MessageItem:
+ """One conversational turn's visible content."""
+
+ turn_id: str
+ role: MessageRole
+ content: tuple[MessageContent, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ReasoningItem:
+ """Visible reasoning and its opaque continuation artifacts."""
+
+ turn_id: str
+ reasoning: str
+ artifacts: tuple[ReplayArtifact, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class ToolCallItem:
+ """One prior assistant tool invocation."""
+
+ turn_id: str
+ call_id: str
+ kind: ToolCallKind
+ name: str
+ input: JsonValue
+ namespace: str | None = None
+ artifacts: tuple[ReplayArtifact, ...] = ()
+
+ def __post_init__(self) -> None:
+ object.__setattr__(self, "input", freeze_json(self.input))
+
+
+@dataclass(frozen=True, slots=True)
+class ToolResultItem:
+ """One user-supplied result for a prior tool invocation."""
+
+ turn_id: str
+ call_id: str
+ content: JsonValue
+ is_error: bool = False
+
+ def __post_init__(self) -> None:
+ object.__setattr__(self, "content", freeze_json(self.content))
+
+
+type InferenceItem = (
+ InstructionItem | MessageItem | ReasoningItem | ToolCallItem | ToolResultItem
+)
+
+
+@dataclass(frozen=True, slots=True)
+class FunctionTool:
+ """A JSON-schema function tool."""
+
+ name: str
+ description: str | None
+ input_schema: Mapping[str, JsonValue]
+ strict: bool = False
+ namespace: str | None = None
+ cache_control: CacheControl | None = None
+
+ def __post_init__(self) -> None:
+ object.__setattr__(self, "input_schema", freeze_json_object(self.input_schema))
+
+
+class CustomToolFormatType(StrEnum):
+ """Supported free-form tool input formats."""
+
+ TEXT = "text"
+ GRAMMAR = "grammar"
+
+
+@dataclass(frozen=True, slots=True)
+class CustomToolFormat:
+ """Typed custom-tool input format."""
+
+ type: CustomToolFormatType
+ syntax: str | None = None
+ definition: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class CustomTool:
+ """A free-form/custom tool."""
+
+ name: str
+ description: str | None
+ format: CustomToolFormat
+ namespace: str | None = None
+ cache_control: CacheControl | None = None
+
+
+type InferenceTool = FunctionTool | CustomTool
+
+
+class ToolChoiceMode(StrEnum):
+ """Canonical tool selection modes."""
+
+ AUTO = "auto"
+ NONE = "none"
+ REQUIRED = "required"
+ SPECIFIC = "specific"
+
+
+@dataclass(frozen=True, slots=True)
+class ToolChoice:
+ """Tool-selection intent with an optional typed target."""
+
+ mode: ToolChoiceMode
+ kind: ToolCallKind | None = None
+ name: str | None = None
+ namespace: str | None = None
+
+ def __post_init__(self) -> None:
+ specific = self.mode is ToolChoiceMode.SPECIFIC
+ if specific != (self.kind is not None and self.name is not None):
+ raise ValueError("specific tool choice requires kind and name")
+ if not specific and self.namespace is not None:
+ raise ValueError("only a specific tool choice may name a namespace")
+
+
+@dataclass(frozen=True, slots=True)
+class ClientReasoningIntent:
+ """Unresolved reasoning intent supplied by the client."""
+
+ control: ReasoningControl = ReasoningControl.DEFAULT
+ effort: ReasoningEffort | None = None
+ budget_tokens: int | None = None
+
+ def __post_init__(self) -> None:
+ if self.budget_tokens is not None and (
+ not isinstance(self.budget_tokens, int)
+ or isinstance(self.budget_tokens, bool)
+ or self.budget_tokens <= 0
+ ):
+ raise ValueError("reasoning budget must be a positive integer")
+ if self.budget_tokens is not None and self.control is not ReasoningControl.ON:
+ raise ValueError("a reasoning budget requires reasoning control to be on")
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIChatExtension:
+ """Explicit caller extension for OpenAI-compatible Chat transports."""
+
+ extra_body: Mapping[str, JsonValue]
+
+ def __post_init__(self) -> None:
+ object.__setattr__(self, "extra_body", freeze_json_object(self.extra_body))
+
+
+type InferenceExtension = OpenAIChatExtension
+
+
+@dataclass(frozen=True, slots=True)
+class InferenceRequest:
+ """Immutable provider-neutral request passed below protocol ingress."""
+
+ model: str
+ items: tuple[InferenceItem, ...]
+ tools: tuple[InferenceTool, ...] = ()
+ tool_choice: ToolChoice | None = None
+ parallel_tool_calls: bool | None = None
+ max_output_tokens: int | None = None
+ temperature: float | None = None
+ top_p: float | None = None
+ top_k: int | None = None
+ stop_sequences: tuple[str, ...] = ()
+ reasoning: ClientReasoningIntent = ClientReasoningIntent()
+ metadata: Mapping[str, JsonValue] | None = None
+ extensions: tuple[InferenceExtension, ...] = ()
+
+ def __post_init__(self) -> None:
+ if not self.model.strip():
+ raise ValueError("model must be non-empty")
+ if self.max_output_tokens is not None and (
+ not isinstance(self.max_output_tokens, int)
+ or isinstance(self.max_output_tokens, bool)
+ or self.max_output_tokens <= 0
+ ):
+ raise ValueError("max_output_tokens must be a positive integer")
+ if self.metadata is not None:
+ object.__setattr__(self, "metadata", freeze_json_object(self.metadata))
+ if sum(isinstance(value, OpenAIChatExtension) for value in self.extensions) > 1:
+ raise ValueError("only one OpenAI Chat extension is allowed")
+
+ @property
+ def message_count(self) -> int:
+ """Return the number of distinct transcript turns."""
+
+ turn_ids: set[str] = set()
+ for item in self.items:
+ if isinstance(item, InstructionItem):
+ if item.turn_id is not None:
+ turn_ids.add(item.turn_id)
+ elif isinstance(
+ item,
+ MessageItem | ReasoningItem | ToolCallItem | ToolResultItem,
+ ):
+ turn_ids.add(item.turn_id)
+ return len(turn_ids)
+
+ @property
+ def openai_chat_extension(self) -> OpenAIChatExtension | None:
+ """Return the one explicit Chat extension, if supplied."""
+
+ return next(
+ (
+ extension
+ for extension in self.extensions
+ if isinstance(extension, OpenAIChatExtension)
+ ),
+ None,
+ )
+
+ def with_stop_sequences(self, stop_sequences: tuple[str, ...]) -> InferenceRequest:
+ """Return a request with an application-owned stop-policy adjustment."""
+
+ return replace(self, stop_sequences=stop_sequences)
+
+
+def freeze_json(value: JsonValue) -> JsonValue:
+ """Return a recursively immutable, owned JSON value."""
+
+ if isinstance(value, Mapping):
+ return MappingProxyType(
+ {str(key): freeze_json(item) for key, item in value.items()}
+ )
+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+ return tuple(freeze_json(item) for item in value)
+ return value
+
+
+def freeze_json_object(value: Mapping[str, JsonValue]) -> Mapping[str, JsonValue]:
+ """Return a recursively immutable, owned JSON object."""
+
+ frozen = freeze_json(value)
+ if not isinstance(frozen, Mapping):
+ raise TypeError("expected a JSON object")
+ return frozen
+
+
+def thaw_json(value: JsonValue) -> JsonValue:
+ """Return a mutable JSON-ready copy of a canonical value."""
+
+ if isinstance(value, Mapping):
+ return {str(key): thaw_json(item) for key, item in value.items()}
+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+ return [thaw_json(item) for item in value]
+ return value
+
+
+def thaw_json_object(value: Mapping[str, JsonValue]) -> dict[str, JsonValue]:
+ """Return a mutable JSON-ready copy of a canonical object."""
+
+ return {str(key): thaw_json(item) for key, item in value.items()}
+
+
+def inference_request_snapshot(request: InferenceRequest) -> dict[str, object]:
+ """Return trace-safe request structure without prompts or replay payloads."""
+
+ return {
+ "model": request.model,
+ "item_count": len(request.items),
+ "message_count": request.message_count,
+ "tool_count": len(request.tools),
+ "tool_choice": (
+ request.tool_choice.mode.value if request.tool_choice is not None else None
+ ),
+ "parallel_tool_calls": request.parallel_tool_calls,
+ "max_output_tokens": request.max_output_tokens,
+ "temperature": request.temperature,
+ "top_p": request.top_p,
+ "top_k": request.top_k,
+ "stop_sequence_count": len(request.stop_sequences),
+ "reasoning_control": request.reasoning.control.value,
+ "reasoning_effort": (
+ request.reasoning.effort.value
+ if request.reasoning.effort is not None
+ else None
+ ),
+ "reasoning_budget_tokens": request.reasoning.budget_tokens,
+ "has_metadata": request.metadata is not None,
+ "extension_count": len(request.extensions),
+ }
diff --git a/src/free_claude_code/core/inference/tokens.py b/src/free_claude_code/core/inference/tokens.py
new file mode 100644
index 00000000..b21c6430
--- /dev/null
+++ b/src/free_claude_code/core/inference/tokens.py
@@ -0,0 +1,125 @@
+"""Token estimation over the canonical inference request."""
+
+import json
+from collections.abc import Mapping, Sequence
+
+from free_claude_code.core.json_types import JsonValue
+from free_claude_code.core.token_estimation import estimate_text_tokens
+
+from .request import (
+ Base64MediaSource,
+ DocumentContent,
+ FunctionTool,
+ ImageContent,
+ InferenceRequest,
+ InstructionItem,
+ InstructionPlacement,
+ MessageItem,
+ ReasoningItem,
+ RefusalContent,
+ TextContent,
+ ToolCallItem,
+ ToolResultItem,
+ UrlMediaSource,
+ thaw_json,
+)
+
+
+def get_inference_token_count(request: InferenceRequest) -> int:
+ """Estimate input tokens from the one canonical transcript interpretation."""
+
+ total = 0
+ has_top_level_instruction = False
+ for item in request.items:
+ if isinstance(item, InstructionItem):
+ total += estimate_text_tokens(item.text)
+ has_top_level_instruction |= (
+ item.placement is InstructionPlacement.TOP_LEVEL
+ )
+ elif isinstance(item, MessageItem):
+ total += sum(_content_tokens(part) for part in item.content)
+ elif isinstance(item, ReasoningItem):
+ total += estimate_text_tokens(item.reasoning)
+ elif isinstance(item, ToolCallItem):
+ total += estimate_text_tokens(item.name)
+ total += estimate_text_tokens(_json_text(item.input))
+ total += estimate_text_tokens(item.call_id)
+ total += 15
+ elif isinstance(item, ToolResultItem):
+ total += estimate_text_tokens(_tool_result_text(item.content))
+ total += estimate_text_tokens(item.call_id)
+ total += 8
+
+ if has_top_level_instruction:
+ total += 4
+ total += request.message_count * 4
+
+ for tool in request.tools:
+ if isinstance(tool, FunctionTool):
+ schema = _json_text(tool.input_schema)
+ else:
+ schema = " ".join(
+ value
+ for value in (
+ tool.format.type.value,
+ tool.format.syntax,
+ tool.format.definition,
+ )
+ if value
+ )
+ total += estimate_text_tokens(tool.name + (tool.description or "") + schema)
+ if request.tools:
+ total += len(request.tools) * 5
+ return max(1, total)
+
+
+def _content_tokens(content: object) -> int:
+ if isinstance(content, TextContent):
+ return estimate_text_tokens(content.text)
+ if isinstance(content, RefusalContent):
+ return estimate_text_tokens(content.refusal)
+ if isinstance(content, ImageContent):
+ return _media_tokens(content.source)
+ if isinstance(content, DocumentContent):
+ source = content.source
+ if isinstance(source, Base64MediaSource):
+ return max(85, len(source.data) // 3000)
+ if isinstance(source, UrlMediaSource):
+ return 765
+ return estimate_text_tokens(source.file_id)
+ raise TypeError(f"unsupported canonical content: {type(content).__name__}")
+
+
+def _media_tokens(source: UrlMediaSource | Base64MediaSource) -> int:
+ if isinstance(source, Base64MediaSource):
+ return max(85, len(source.data) // 3000)
+ return 765
+
+
+def _tool_result_text(value: JsonValue) -> str:
+ if value is None:
+ return ""
+ if isinstance(value, str):
+ return value
+ if isinstance(value, Mapping):
+ return _json_text(value)
+ if isinstance(value, Sequence):
+ parts: list[str] = []
+ for item in value:
+ if isinstance(item, Mapping) and item.get("type") == "text":
+ text = item.get("text")
+ parts.append(text if isinstance(text, str) else str(text or ""))
+ elif isinstance(item, Mapping | Sequence) and not isinstance(item, str):
+ parts.append(_json_text(item))
+ else:
+ parts.append(str(item))
+ return "\n".join(parts)
+ return str(value)
+
+
+def _json_text(value: JsonValue | Mapping[str, JsonValue]) -> str:
+ return json.dumps(
+ thaw_json(value),
+ ensure_ascii=False,
+ separators=(",", ":"),
+ )
diff --git a/src/free_claude_code/core/openai_responses/__init__.py b/src/free_claude_code/core/openai_responses/__init__.py
index adf6b99a..4e25b4fb 100644
--- a/src/free_claude_code/core/openai_responses/__init__.py
+++ b/src/free_claude_code/core/openai_responses/__init__.py
@@ -1,30 +1,34 @@
"""OpenAI Responses protocol adapter."""
-from .adapter import OpenAIResponsesAdapter
from .errors import (
ResponsesConversionError,
openai_error_payload,
openai_error_type_for_failure,
openai_failure_payload,
)
-from .models import OpenAIResponsesRequest
+from .events import OPENAI_RESPONSES_SSE_HEADERS
+from .ingress import (
+ ResponsesIngressResult,
+ responses_to_inference_request,
+ validate_responses_field_policy,
+)
+from .models import OpenAIResponsesRequest, ResponsesPresentationSnapshot
from .presenter import (
ResponsesEventPresenter,
iter_responses_sse_from_events,
)
-from .provider_events import ResponsesEventDecoder, ResponsesStreamFailure
-from .provider_input import build_responses_provider_request
__all__ = [
- "OpenAIResponsesAdapter",
+ "OPENAI_RESPONSES_SSE_HEADERS",
"OpenAIResponsesRequest",
"ResponsesConversionError",
- "ResponsesEventDecoder",
"ResponsesEventPresenter",
- "ResponsesStreamFailure",
- "build_responses_provider_request",
+ "ResponsesIngressResult",
+ "ResponsesPresentationSnapshot",
"iter_responses_sse_from_events",
"openai_error_payload",
"openai_error_type_for_failure",
"openai_failure_payload",
+ "responses_to_inference_request",
+ "validate_responses_field_policy",
]
diff --git a/src/free_claude_code/core/openai_responses/adapter.py b/src/free_claude_code/core/openai_responses/adapter.py
deleted file mode 100644
index 60b0f2cb..00000000
--- a/src/free_claude_code/core/openai_responses/adapter.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"""Facade for OpenAI Responses protocol adaptation."""
-
-from typing import Any, ClassVar
-
-from .errors import ResponsesConversionError, openai_error_payload
-from .events import OPENAI_RESPONSES_SSE_HEADERS
-from .input import convert_request_to_anthropic_payload
-from .models import OpenAIResponsesRequest
-
-
-class OpenAIResponsesAdapter:
- """Convert the current Responses request bridge and public error envelopes."""
-
- ConversionError: ClassVar[type[ResponsesConversionError]] = ResponsesConversionError
- sse_headers: ClassVar[dict[str, str]] = OPENAI_RESPONSES_SSE_HEADERS
-
- def to_anthropic_payload(self, request: OpenAIResponsesRequest) -> dict[str, Any]:
- return convert_request_to_anthropic_payload(request)
-
- def error_payload(self, *, message: str, error_type: str) -> dict[str, Any]:
- return openai_error_payload(message=message, error_type=error_type)
diff --git a/src/free_claude_code/core/openai_responses/ingress.py b/src/free_claude_code/core/openai_responses/ingress.py
new file mode 100644
index 00000000..08c06f7f
--- /dev/null
+++ b/src/free_claude_code/core/openai_responses/ingress.py
@@ -0,0 +1,778 @@
+"""OpenAI Responses ingress conversion to canonical inference semantics."""
+
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from typing import cast
+
+from free_claude_code.core.inference import (
+ ClientReasoningIntent,
+ CustomTool,
+ CustomToolFormat,
+ CustomToolFormatType,
+ FunctionTool,
+ InferenceItem,
+ InferenceRequest,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MessageContent,
+ MessageItem,
+ MessageRole,
+ ReasoningItem,
+ RefusalContent,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoice,
+ ToolChoiceMode,
+ ToolResultItem,
+)
+from free_claude_code.core.json_types import JsonValue
+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort
+from free_claude_code.core.replay_envelope import (
+ ReplayEnvelopeError,
+ decode_replay_envelope,
+)
+from free_claude_code.core.trace import trace_event
+
+from .errors import ResponsesConversionError
+from .ids import new_call_id
+from .models import OpenAIResponsesRequest, ResponsesPresentationSnapshot
+
+_AMBIENT_HOSTED_TOOL_TYPES = frozenset(
+ {"web_search", "image_generation", "tool_search"}
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ResponsesIngressResult:
+ """Canonical request plus the minimal validated public echo state."""
+
+ request: InferenceRequest
+ presentation: ResponsesPresentationSnapshot
+
+
+@dataclass(slots=True)
+class _PendingReasoning:
+ text_parts: list[str] = field(default_factory=list)
+ artifacts: list[ReplayArtifact] = field(default_factory=list)
+
+ def add(self, item: Mapping[str, object], *, path: str) -> None:
+ self.text_parts.extend(_reasoning_text_parts(item, path=path))
+ encrypted = item.get("encrypted_content")
+ if encrypted is None:
+ return
+ if not isinstance(encrypted, str):
+ raise ResponsesConversionError(f"{path}.encrypted_content must be a string")
+ try:
+ decoded = decode_replay_envelope(
+ encrypted,
+ attachment=ReplayAttachment.REASONING,
+ )
+ except ReplayEnvelopeError as exc:
+ raise ResponsesConversionError(f"{path}.encrypted_content: {exc}") from exc
+ if decoded is not None:
+ self.artifacts.extend(decoded)
+ elif encrypted:
+ self.artifacts.append(
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI,
+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,
+ attachment=ReplayAttachment.REASONING,
+ payload=encrypted,
+ )
+ )
+
+ @property
+ def pending(self) -> bool:
+ return bool(self.text_parts or self.artifacts)
+
+ def take(self, *, turn_id: str) -> ReasoningItem | None:
+ if not self.pending:
+ return None
+ item = ReasoningItem(
+ turn_id=turn_id,
+ reasoning="\n".join(self.text_parts),
+ artifacts=tuple(self.artifacts),
+ )
+ self.text_parts.clear()
+ self.artifacts.clear()
+ return item
+
+
+@dataclass(slots=True)
+class _TranscriptBuilder:
+ items: list[InferenceItem] = field(default_factory=list)
+ system: list[InstructionItem] = field(default_factory=list)
+ pending_reasoning: _PendingReasoning = field(default_factory=_PendingReasoning)
+ quarantined_call_ids: set[str] = field(default_factory=set)
+ _next_turn: int = 0
+ _last_assistant_tool_turn: str | None = None
+ _last_user_tool_turn: str | None = None
+
+ def new_turn(self) -> str:
+ turn_id = f"turn_{self._next_turn}"
+ self._next_turn += 1
+ return turn_id
+
+ def break_tool_groups(self) -> None:
+ self._last_assistant_tool_turn = None
+ self._last_user_tool_turn = None
+
+ def flush_reasoning(self) -> None:
+ if self.pending_reasoning.pending:
+ item = self.pending_reasoning.take(turn_id=self.new_turn())
+ if item is not None:
+ self.items.append(item)
+ self.break_tool_groups()
+
+ def assistant_tool_turn(self) -> str:
+ if self._last_assistant_tool_turn is None:
+ self._last_assistant_tool_turn = self.new_turn()
+ self._last_user_tool_turn = None
+ return self._last_assistant_tool_turn
+
+ def user_tool_turn(self) -> str:
+ if self._last_user_tool_turn is None:
+ self._last_user_tool_turn = self.new_turn()
+ self._last_assistant_tool_turn = None
+ return self._last_user_tool_turn
+
+
+def responses_to_inference_request(
+ wire: OpenAIResponsesRequest,
+) -> ResponsesIngressResult:
+ """Validate and convert one public Responses request exactly once."""
+
+ _validate_top_level(wire)
+ builder = _TranscriptBuilder()
+ if wire.instructions is not None:
+ builder.system.append(
+ InstructionItem(
+ text=wire.instructions,
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ )
+ )
+ for index, item in enumerate(_input_items(wire.input)):
+ _append_item(item, builder=builder, path=f"input[{index}]")
+ builder.flush_reasoning()
+ if not builder.items:
+ raise ResponsesConversionError("Responses request input must contain a message")
+
+ tool_choice = _tool_choice(wire.tool_choice)
+ tools = _tools(wire.tools, raw_choice=wire.tool_choice)
+ if (
+ tool_choice is not None
+ and tool_choice.mode is ToolChoiceMode.REQUIRED
+ and not tools
+ ):
+ raise ResponsesConversionError(
+ "tool_choice 'required' needs at least one executable function or custom tool"
+ )
+ metadata = (
+ _json_object(wire.metadata, path="metadata")
+ if wire.metadata is not None
+ else None
+ )
+ request = InferenceRequest(
+ model=_required_str(wire.model, path="model"),
+ items=(*builder.system, *builder.items),
+ tools=tools,
+ tool_choice=tool_choice,
+ parallel_tool_calls=wire.parallel_tool_calls,
+ max_output_tokens=wire.max_output_tokens,
+ temperature=wire.temperature,
+ top_p=wire.top_p,
+ reasoning=_reasoning_intent(wire.reasoning),
+ metadata=metadata,
+ )
+ return ResponsesIngressResult(
+ request=request,
+ presentation=ResponsesPresentationSnapshot(
+ model=request.model,
+ parallel_tool_calls=(
+ True if wire.parallel_tool_calls is None else wire.parallel_tool_calls
+ ),
+ tool_choice=_presentation_tool_choice(wire.tool_choice),
+ temperature=wire.temperature,
+ top_p=wire.top_p,
+ max_output_tokens=wire.max_output_tokens,
+ ),
+ )
+
+
+def validate_responses_field_policy(wire: OpenAIResponsesRequest) -> None:
+ """Apply protocol-wide rejection before routing or provider I/O."""
+
+ _validate_top_level(wire)
+ _tool_choice(wire.tool_choice)
+ _tools(wire.tools, raw_choice=wire.tool_choice)
+
+
+def _validate_top_level(wire: OpenAIResponsesRequest) -> None:
+ if wire.model_extra:
+ key = sorted(str(key) for key in wire.model_extra)[0]
+ raise ResponsesConversionError(f"request.{key} is not supported")
+ if wire.stream is False:
+ raise ResponsesConversionError(
+ "stream=false is not supported; omit stream or set stream=true"
+ )
+ if wire.store is True:
+ raise ResponsesConversionError("store=true is not supported")
+ if wire.previous_response_id is not None:
+ raise ResponsesConversionError("previous_response_id must be null or omitted")
+ _validate_include(wire.include)
+ _validate_prompt_cache_key(wire.prompt_cache_key)
+ _reasoning_intent(wire.reasoning)
+
+
+def _validate_include(value: object) -> None:
+ if value is None:
+ return
+ if value != ["reasoning.encrypted_content"]:
+ raise ResponsesConversionError(
+ "include must be exactly ['reasoning.encrypted_content'] when provided"
+ )
+
+
+def _validate_prompt_cache_key(value: object) -> None:
+ if value is None:
+ return
+ if not isinstance(value, str) or not value.strip():
+ raise ResponsesConversionError(
+ "prompt_cache_key must be a non-empty string when provided"
+ )
+
+
+def _reasoning_intent(value: Mapping[str, object] | None) -> ClientReasoningIntent:
+ if value is None:
+ return ClientReasoningIntent()
+ unknown = set(value) - {"effort", "summary"}
+ if unknown:
+ raise ResponsesConversionError(
+ f"reasoning.{sorted(str(key) for key in unknown)[0]} is not supported"
+ )
+ summary = value.get("summary")
+ if summary is not None and summary != "auto":
+ raise ResponsesConversionError("reasoning.summary must be null or 'auto'")
+ raw_effort = value.get("effort")
+ if raw_effort is None:
+ return ClientReasoningIntent()
+ if not isinstance(raw_effort, str) or not raw_effort.strip():
+ raise ResponsesConversionError("reasoning.effort must be a non-empty string")
+ normalized = raw_effort.strip().lower()
+ if normalized == "none":
+ return ClientReasoningIntent(control=ReasoningControl.OFF)
+ try:
+ effort = ReasoningEffort(normalized)
+ except ValueError as exc:
+ raise ResponsesConversionError(
+ f"reasoning.effort has unsupported value {raw_effort!r}"
+ ) from exc
+ return ClientReasoningIntent(control=ReasoningControl.ON, effort=effort)
+
+
+def _input_items(value: object) -> list[object]:
+ if value is None:
+ return []
+ if isinstance(value, list):
+ return value
+ return [value]
+
+
+def _append_item(
+ value: object,
+ *,
+ builder: _TranscriptBuilder,
+ path: str,
+) -> None:
+ if isinstance(value, str):
+ builder.flush_reasoning()
+ turn_id = builder.new_turn()
+ builder.items.append(
+ MessageItem(turn_id, MessageRole.USER, (TextContent(value),))
+ )
+ return
+ item = _mapping(value, path=path)
+ item_type = item.get("type")
+ if item_type in {None, "message"} or "role" in item:
+ role = _required_str(item.get("role", "user"), path=f"{path}.role")
+ _append_message(
+ role,
+ item.get("content", ""),
+ builder=builder,
+ path=path,
+ )
+ return
+ if item_type == "reasoning":
+ builder.pending_reasoning.add(item, path=path)
+ return
+ if item_type in {"function_call", "custom_tool_call"}:
+ _append_tool_call(item, item_type=item_type, builder=builder, path=path)
+ return
+ if item_type in {"function_call_output", "custom_tool_call_output"}:
+ _append_tool_result(item, item_type=item_type, builder=builder, path=path)
+ return
+ if item_type in {"input_text", "output_text", "text"}:
+ builder.flush_reasoning()
+ turn_id = builder.new_turn()
+ builder.items.append(
+ MessageItem(
+ turn_id,
+ MessageRole.USER,
+ (TextContent(_text_from_part(item, path=path)),),
+ )
+ )
+ return
+ raise ResponsesConversionError(f"{path}.type {item_type!r} is not supported")
+
+
+def _append_message(
+ role: str,
+ content: object,
+ *,
+ builder: _TranscriptBuilder,
+ path: str,
+) -> None:
+ if role in {"system", "developer"}:
+ builder.flush_reasoning()
+ text = _instruction_text(content, path=f"{path}.content")
+ if text:
+ turn_id = builder.new_turn()
+ builder.items.append(
+ InstructionItem(
+ text=text,
+ origin=(
+ InstructionOrigin.DEVELOPER
+ if role == "developer"
+ else InstructionOrigin.SYSTEM
+ ),
+ placement=InstructionPlacement.TRANSCRIPT,
+ turn_id=turn_id,
+ )
+ )
+ builder.break_tool_groups()
+ return
+ if role not in {"user", "assistant"}:
+ raise ResponsesConversionError(f"{path}.role {role!r} is not supported")
+ if role == "user":
+ builder.flush_reasoning()
+ turn_id = builder.new_turn()
+ if role == "assistant" and (
+ reasoning := builder.pending_reasoning.take(turn_id=turn_id)
+ ):
+ builder.items.append(reasoning)
+ parts = _message_content(content, path=f"{path}.content")
+ builder.items.append(MessageItem(turn_id, MessageRole(role), parts))
+ builder.break_tool_groups()
+
+
+def _append_tool_call(
+ item: Mapping[str, object],
+ *,
+ item_type: object,
+ builder: _TranscriptBuilder,
+ path: str,
+) -> None:
+ call_id = _call_id(item)
+ namespace = _optional_str(item.get("namespace"), path=f"{path}.namespace")
+ name = _required_str(item.get("name"), path=f"{path}.name")
+ if item_type == "function_call":
+ try:
+ tool_input = _function_arguments(
+ item.get("arguments"), path=f"{path}.arguments"
+ )
+ except ResponsesConversionError as exc:
+ builder.quarantined_call_ids.add(call_id)
+ trace_event(
+ stage="responses",
+ event="responses.input.function_call_quarantined",
+ source="openai_responses",
+ call_id=call_id,
+ error_type=type(exc).__name__,
+ )
+ return
+ kind = ToolCallKind.FUNCTION
+ else:
+ tool_input = _custom_input(item.get("input"), path=f"{path}.input")
+ kind = ToolCallKind.CUSTOM
+ turn_id = builder.assistant_tool_turn()
+ if reasoning := builder.pending_reasoning.take(turn_id=turn_id):
+ builder.items.append(reasoning)
+ builder.items.append(
+ ToolCallItem(
+ turn_id=turn_id,
+ call_id=call_id,
+ kind=kind,
+ name=name,
+ namespace=namespace,
+ input=tool_input,
+ )
+ )
+
+
+def _append_tool_result(
+ item: Mapping[str, object],
+ *,
+ item_type: object,
+ builder: _TranscriptBuilder,
+ path: str,
+) -> None:
+ call_id = _call_id(item)
+ if item_type == "function_call_output" and call_id in builder.quarantined_call_ids:
+ return
+ if builder.pending_reasoning.pending:
+ turn_id = builder._last_assistant_tool_turn or builder.new_turn()
+ if reasoning := builder.pending_reasoning.take(turn_id=turn_id):
+ builder.items.append(reasoning)
+ turn_id = builder.user_tool_turn()
+ builder.items.append(
+ ToolResultItem(
+ turn_id=turn_id,
+ call_id=call_id,
+ content=_json_value(item.get("output", ""), path=f"{path}.output"),
+ )
+ )
+
+
+def _message_content(value: object, *, path: str) -> tuple[MessageContent, ...]:
+ if isinstance(value, str):
+ return (TextContent(value),)
+ if isinstance(value, Mapping):
+ return (_content_part(_mapping(value, path=path), path=path),)
+ if not isinstance(value, list):
+ raise ResponsesConversionError(f"{path} must be text or a list")
+ parts: list[MessageContent] = []
+ for index, raw_part in enumerate(value):
+ part_path = f"{path}[{index}]"
+ if isinstance(raw_part, str):
+ parts.append(TextContent(raw_part))
+ else:
+ parts.append(
+ _content_part(_mapping(raw_part, path=part_path), path=part_path)
+ )
+ return tuple(parts)
+
+
+def _content_part(part: Mapping[str, object], *, path: str) -> MessageContent:
+ part_type = part.get("type")
+ if part_type in {"input_text", "output_text", "text"}:
+ return TextContent(_text_from_part(part, path=path))
+ if part_type == "refusal":
+ return RefusalContent(
+ _required_str(part.get("refusal"), path=f"{path}.refusal")
+ )
+ raise ResponsesConversionError(f"{path}.type {part_type!r} is not supported")
+
+
+def _instruction_text(value: object, *, path: str) -> str:
+ parts = _message_content(value, path=path)
+ text: list[str] = []
+ for index, part in enumerate(parts):
+ if not isinstance(part, TextContent):
+ raise ResponsesConversionError(
+ f"{path}[{index}] instruction content must be text"
+ )
+ text.append(part.text)
+ return "\n\n".join(text)
+
+
+def _reasoning_text_parts(item: Mapping[str, object], *, path: str) -> list[str]:
+ content = _typed_text_list(
+ item.get("content"),
+ item_type="reasoning_text",
+ path=f"{path}.content",
+ )
+ if content:
+ return content
+ return _typed_text_list(
+ item.get("summary"),
+ item_type="summary_text",
+ path=f"{path}.summary",
+ )
+
+
+def _typed_text_list(value: object, *, item_type: str, path: str) -> list[str]:
+ if value is None:
+ return []
+ if not isinstance(value, list):
+ raise ResponsesConversionError(f"{path} must be a list")
+ parts: list[str] = []
+ for index, raw_part in enumerate(value):
+ part = _mapping(raw_part, path=f"{path}[{index}]")
+ if part.get("type") != item_type:
+ raise ResponsesConversionError(
+ f"{path}[{index}].type must be {item_type!r}"
+ )
+ parts.append(_required_str(part.get("text"), path=f"{path}[{index}].text"))
+ return parts
+
+
+def _tools(
+ value: list[dict[str, object]] | None,
+ *,
+ raw_choice: object,
+) -> tuple[FunctionTool | CustomTool, ...]:
+ if value is None:
+ return ()
+ tools: list[FunctionTool | CustomTool] = []
+ ambient_allowed = raw_choice is None or raw_choice == "auto"
+ for index, raw_tool in enumerate(value):
+ path = f"tools[{index}]"
+ tool = _mapping(raw_tool, path=path)
+ tool_type = tool.get("type")
+ if tool_type in _AMBIENT_HOSTED_TOOL_TYPES:
+ if ambient_allowed:
+ continue
+ if raw_choice == "none":
+ continue
+ continue
+ if tool_type == "function":
+ tools.append(_function_tool(tool, namespace=None, path=path))
+ elif tool_type == "custom":
+ tools.append(_custom_tool(tool, namespace=None, path=path))
+ elif tool_type == "namespace":
+ tools.extend(_namespace_tools(tool, path=path))
+ else:
+ raise ResponsesConversionError(
+ f"{path}.type {tool_type!r} is not supported"
+ )
+ return tuple(tools)
+
+
+def _function_tool(
+ tool: Mapping[str, object],
+ *,
+ namespace: str | None,
+ path: str,
+) -> FunctionTool:
+ nested = tool.get("function")
+ source = _mapping(nested, path=f"{path}.function") if nested is not None else tool
+ name = _required_str(source.get("name"), path=f"{path}.name")
+ raw_schema = source.get("parameters", {"type": "object", "properties": {}})
+ schema = _json_object(raw_schema, path=f"{path}.parameters")
+ strict = source.get("strict", False)
+ if not isinstance(strict, bool):
+ raise ResponsesConversionError(f"{path}.strict must be boolean")
+ return FunctionTool(
+ name=name,
+ description=_optional_str(
+ source.get("description"), path=f"{path}.description"
+ ),
+ input_schema=schema,
+ strict=strict,
+ namespace=namespace,
+ )
+
+
+def _custom_tool(
+ tool: Mapping[str, object],
+ *,
+ namespace: str | None,
+ path: str,
+) -> CustomTool:
+ nested = tool.get("custom")
+ source = _mapping(nested, path=f"{path}.custom") if nested is not None else tool
+ name = _required_str(source.get("name"), path=f"{path}.name")
+ raw_format = source.get("format")
+ if raw_format is None:
+ custom_format = CustomToolFormat(CustomToolFormatType.TEXT)
+ else:
+ format_value = _mapping(raw_format, path=f"{path}.format")
+ format_type = format_value.get("type")
+ if format_type == "text":
+ custom_format = CustomToolFormat(CustomToolFormatType.TEXT)
+ elif format_type == "grammar":
+ custom_format = CustomToolFormat(
+ CustomToolFormatType.GRAMMAR,
+ syntax=_optional_str(
+ format_value.get("syntax"),
+ path=f"{path}.format.syntax",
+ ),
+ definition=_optional_str(
+ format_value.get("definition"),
+ path=f"{path}.format.definition",
+ ),
+ )
+ else:
+ raise ResponsesConversionError(
+ f"{path}.format.type {format_type!r} is not supported"
+ )
+ return CustomTool(
+ name=name,
+ description=_optional_str(
+ source.get("description"), path=f"{path}.description"
+ ),
+ format=custom_format,
+ namespace=namespace,
+ )
+
+
+def _namespace_tools(
+ tool: Mapping[str, object], *, path: str
+) -> list[FunctionTool | CustomTool]:
+ namespace = _required_str(tool.get("name"), path=f"{path}.name")
+ nested = tool.get("tools")
+ if not isinstance(nested, list):
+ raise ResponsesConversionError(f"{path}.tools must be a list")
+ result: list[FunctionTool | CustomTool] = []
+ for index, raw_tool in enumerate(nested):
+ nested_path = f"{path}.tools[{index}]"
+ nested_tool = _mapping(raw_tool, path=nested_path)
+ if nested_tool.get("type") == "function":
+ result.append(
+ _function_tool(nested_tool, namespace=namespace, path=nested_path)
+ )
+ elif nested_tool.get("type") == "custom":
+ result.append(
+ _custom_tool(nested_tool, namespace=namespace, path=nested_path)
+ )
+ else:
+ raise ResponsesConversionError(
+ f"{nested_path}.type {nested_tool.get('type')!r} is not supported"
+ )
+ return result
+
+
+def _tool_choice(value: object) -> ToolChoice | None:
+ if value is None or value == "auto":
+ return None if value is None else ToolChoice(ToolChoiceMode.AUTO)
+ if value == "none":
+ return ToolChoice(ToolChoiceMode.NONE)
+ if value == "required":
+ return ToolChoice(ToolChoiceMode.REQUIRED)
+ choice = _mapping(value, path="tool_choice")
+ choice_type = choice.get("type")
+ if choice_type in _AMBIENT_HOSTED_TOOL_TYPES:
+ raise ResponsesConversionError(
+ f"tool_choice.type {choice_type!r} cannot be selected explicitly"
+ )
+ if choice_type in {"auto"}:
+ return ToolChoice(ToolChoiceMode.AUTO)
+ if choice_type in {"any", "required"}:
+ return ToolChoice(ToolChoiceMode.REQUIRED)
+ if choice_type in {"function", "custom", "tool"}:
+ nested = choice.get(str(choice_type))
+ source = (
+ _mapping(nested, path=f"tool_choice.{choice_type}")
+ if nested is not None
+ else choice
+ )
+ name = _required_str(source.get("name"), path="tool_choice.name")
+ namespace = _optional_str(
+ source.get("namespace", choice.get("namespace")),
+ path="tool_choice.namespace",
+ )
+ return ToolChoice(
+ ToolChoiceMode.SPECIFIC,
+ kind=(
+ ToolCallKind.CUSTOM
+ if choice_type == "custom"
+ else ToolCallKind.FUNCTION
+ ),
+ name=name,
+ namespace=namespace,
+ )
+ raise ResponsesConversionError(f"tool_choice.type {choice_type!r} is not supported")
+
+
+def _presentation_tool_choice(value: object) -> object:
+ if value is None:
+ return "auto"
+ return _json_value(value, path="tool_choice")
+
+
+def _function_arguments(value: object, *, path: str) -> dict[str, JsonValue]:
+ if value is None or value == "":
+ return {}
+ if isinstance(value, Mapping):
+ return _json_object(value, path=path)
+ if not isinstance(value, str):
+ raise ResponsesConversionError(f"{path} must be JSON")
+ try:
+ parsed = json.loads(value)
+ except json.JSONDecodeError as exc:
+ raise ResponsesConversionError(f"{path} is invalid JSON: {exc.msg}") from exc
+ if not isinstance(parsed, dict):
+ raise ResponsesConversionError(f"{path} must decode to an object")
+ return _json_object(parsed, path=path)
+
+
+def _custom_input(value: object, *, path: str) -> str:
+ if value is None:
+ return ""
+ if isinstance(value, str):
+ return value
+ return json.dumps(
+ _json_value(value, path=path),
+ ensure_ascii=False,
+ separators=(",", ":"),
+ )
+
+
+def _call_id(item: Mapping[str, object]) -> str:
+ for key in ("call_id", "id"):
+ value = item.get(key)
+ if isinstance(value, str) and value:
+ return value
+ return new_call_id()
+
+
+def _text_from_part(part: Mapping[str, object], *, path: str) -> str:
+ for key in ("text", "input_text", "output_text"):
+ value = part.get(key)
+ if isinstance(value, str):
+ return value
+ raise ResponsesConversionError(f"{path} requires a text value")
+
+
+def _mapping(value: object, *, path: str) -> Mapping[str, object]:
+ if not isinstance(value, Mapping) or not all(isinstance(key, str) for key in value):
+ raise ResponsesConversionError(f"{path} must be an object")
+ return cast(Mapping[str, object], value)
+
+
+def _required_str(value: object, *, path: str) -> str:
+ if isinstance(value, str) and value:
+ return value
+ raise ResponsesConversionError(f"{path} must be a non-empty string")
+
+
+def _optional_str(value: object, *, path: str) -> str | None:
+ if value is None:
+ return None
+ if not isinstance(value, str):
+ raise ResponsesConversionError(f"{path} must be a string")
+ return value
+
+
+def _json_object(value: object, *, path: str) -> dict[str, JsonValue]:
+ mapping = _mapping(value, path=path)
+ return {
+ str(key): _json_value(item, path=f"{path}.{key}")
+ for key, item in mapping.items()
+ }
+
+
+def _json_value(value: object, *, path: str) -> JsonValue:
+ if value is None or isinstance(value, bool | int | float | str):
+ return value
+ if isinstance(value, Mapping):
+ if not all(isinstance(key, str) for key in value):
+ raise ResponsesConversionError(f"{path} object keys must be strings")
+ return {
+ str(key): _json_value(item, path=f"{path}.{key}")
+ for key, item in value.items()
+ }
+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+ return [
+ _json_value(item, path=f"{path}[{index}]")
+ for index, item in enumerate(value)
+ ]
+ raise ResponsesConversionError(f"{path} must contain JSON-compatible values")
diff --git a/src/free_claude_code/core/openai_responses/input.py b/src/free_claude_code/core/openai_responses/input.py
deleted file mode 100644
index d824c567..00000000
--- a/src/free_claude_code/core/openai_responses/input.py
+++ /dev/null
@@ -1,415 +0,0 @@
-"""Convert OpenAI Responses requests into Anthropic Messages payloads."""
-
-from collections.abc import Mapping
-from dataclasses import dataclass, field
-from typing import Any
-
-from free_claude_code.core.trace import trace_event
-
-from .errors import ResponsesConversionError
-from .models import OpenAIResponsesRequest
-from .reasoning import (
- combine_reasoning,
- encrypted_reasoning_from_item,
- reasoning_text_from_item,
- responses_reasoning_to_output_config,
-)
-from .tools import (
- call_id_from_item,
- convert_tool_choice,
- convert_tools,
- custom_tool_input_to_anthropic,
- optional_str,
- parse_arguments,
- required_str,
- responses_tool_name_to_anthropic_name,
-)
-
-
-@dataclass(slots=True)
-class _PendingReasoning:
- text: str | None = None
- encrypted: list[str] = field(default_factory=list)
-
- def add_item(self, item: Mapping[str, Any]) -> None:
- self.text = combine_reasoning(self.text, reasoning_text_from_item(item))
- if encrypted := encrypted_reasoning_from_item(item):
- self.encrypted.append(encrypted)
-
- def take(self) -> tuple[str | None, list[dict[str, str]]]:
- text = self.text
- blocks = [
- {"type": "redacted_thinking", "data": encrypted}
- for encrypted in self.encrypted
- ]
- self.text = None
- self.encrypted.clear()
- return text, blocks
-
-
-def convert_request_to_anthropic_payload(
- request: OpenAIResponsesRequest,
-) -> dict[str, Any]:
- """Convert an OpenAI Responses request into an Anthropic Messages payload."""
-
- system_parts: list[str] = []
- if instructions := request.instructions:
- system_parts.append(instructions)
-
- messages: list[dict[str, Any]] = []
- pending_reasoning = _PendingReasoning()
- quarantined_function_call_ids: set[str] = set()
- for item in _iter_input_items(request.input):
- _append_input_item(
- item,
- messages=messages,
- system_parts=system_parts,
- pending_reasoning=pending_reasoning,
- quarantined_function_call_ids=quarantined_function_call_ids,
- )
- _append_pending_reasoning(messages, pending_reasoning)
-
- if not messages:
- raise ResponsesConversionError("Responses request input must contain a message")
-
- payload: dict[str, Any] = {
- "model": required_str(request.model, "model"),
- "messages": messages,
- "stream": True,
- }
- if system_parts:
- payload["system"] = "\n\n".join(system_parts)
- if request.temperature is not None:
- payload["temperature"] = request.temperature
- if request.top_p is not None:
- payload["top_p"] = request.top_p
- if request.max_output_tokens is not None:
- payload["max_tokens"] = request.max_output_tokens
- if request.metadata is not None:
- payload["metadata"] = request.metadata
-
- if output_config := responses_reasoning_to_output_config(request.reasoning):
- payload["output_config"] = output_config
-
- raw_tool_choice = request.tool_choice
- tools = convert_tools(request.tools)
- if tools and raw_tool_choice != "none":
- payload["tools"] = tools
- tool_choice = convert_tool_choice(raw_tool_choice)
- if tool_choice is not None:
- payload["tool_choice"] = tool_choice
-
- return payload
-
-
-def _append_input_item(
- item: Any,
- *,
- messages: list[dict[str, Any]],
- system_parts: list[str],
- pending_reasoning: _PendingReasoning,
- quarantined_function_call_ids: set[str],
-) -> None:
- if isinstance(item, str):
- _append_pending_reasoning(messages, pending_reasoning)
- messages.append({"role": "user", "content": item})
- return
- if not isinstance(item, dict):
- raise ResponsesConversionError(
- f"Unsupported Responses input item: {type(item).__name__}"
- )
-
- item_type = item.get("type")
- if item_type in (None, "message") or "role" in item:
- role = required_str(item.get("role", "user"), "input.role")
- if role == "assistant":
- _append_message_item(
- role,
- item.get("content", ""),
- messages,
- system_parts,
- reasoning_content=pending_reasoning,
- )
- return
- _append_pending_reasoning(messages, pending_reasoning)
- _append_message_item(role, item.get("content", ""), messages, system_parts)
- return
- if item_type in {"function_call", "custom_tool_call"}:
- namespace = optional_str(item.get("namespace"))
- field_name = f"{item_type}.name"
- name = required_str(item.get("name"), field_name)
- call_id = call_id_from_item(item)
- if item_type == "custom_tool_call":
- tool_input = custom_tool_input_to_anthropic(item.get("input"))
- else:
- try:
- tool_input = parse_arguments(item.get("arguments"))
- except ResponsesConversionError as exc:
- quarantined_function_call_ids.add(call_id)
- _trace_quarantined_function_call(call_id, exc)
- return
- tool_use = {
- "type": "tool_use",
- "id": call_id,
- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),
- "input": tool_input,
- }
- _append_tool_use_message(
- messages,
- tool_use,
- reasoning_content=pending_reasoning,
- )
- return
- if item_type in {"function_call_output", "custom_tool_call_output"}:
- call_id = call_id_from_item(item)
- if (
- item_type == "function_call_output"
- and call_id in quarantined_function_call_ids
- ):
- return
- _append_pending_reasoning_before_tool_output(messages, pending_reasoning)
- _append_tool_result_message(
- messages,
- {
- "type": "tool_result",
- "tool_use_id": call_id,
- "content": item.get("output", ""),
- },
- )
- return
- if item_type == "reasoning":
- pending_reasoning.add_item(item)
- return
- if item_type in {"input_text", "output_text", "text"}:
- _append_pending_reasoning(messages, pending_reasoning)
- messages.append({"role": "user", "content": _text_from_part(item)})
- return
-
- raise ResponsesConversionError(
- f"Unsupported Responses input item type: {item_type!r}"
- )
-
-
-def _trace_quarantined_function_call(
- call_id: str, exc: ResponsesConversionError
-) -> None:
- trace_event(
- stage="responses",
- event="responses.input.function_call_quarantined",
- source="openai_responses",
- call_id=call_id,
- error_type=type(exc).__name__,
- )
-
-
-def _append_message_item(
- role: str,
- content: Any,
- messages: list[dict[str, Any]],
- system_parts: list[str],
- *,
- reasoning_content: _PendingReasoning | None = None,
-) -> None:
- normalized_role = "system" if role == "developer" else role
- if normalized_role == "system":
- text = _content_as_text(content)
- if text:
- system_parts.append(text)
- return
- if normalized_role not in {"user", "assistant"}:
- raise ResponsesConversionError(f"Unsupported Responses message role: {role!r}")
- converted_content = _convert_message_content(content)
- reasoning_text: str | None = None
- reasoning_blocks: list[dict[str, str]] = []
- if normalized_role == "assistant" and reasoning_content is not None:
- reasoning_text, reasoning_blocks = reasoning_content.take()
- if reasoning_blocks:
- if isinstance(converted_content, str):
- converted_blocks: list[dict[str, Any]] = list(reasoning_blocks)
- if converted_content:
- converted_blocks.append({"type": "text", "text": converted_content})
- converted_content = converted_blocks
- else:
- converted_content = [*reasoning_blocks, *converted_content]
- message = {
- "role": normalized_role,
- "content": converted_content,
- }
- if reasoning_text is not None:
- message["reasoning_content"] = reasoning_text
- messages.append(message)
-
-
-def _append_pending_reasoning(
- messages: list[dict[str, Any]], pending_reasoning: _PendingReasoning
-) -> None:
- reasoning_text, reasoning_blocks = pending_reasoning.take()
- if reasoning_text is None and not reasoning_blocks:
- return
- message: dict[str, Any] = {
- "role": "assistant",
- "content": reasoning_blocks or "",
- }
- if reasoning_text is not None:
- message["reasoning_content"] = reasoning_text
- messages.append(message)
-
-
-def _append_pending_reasoning_before_tool_output(
- messages: list[dict[str, Any]], pending_reasoning: _PendingReasoning
-) -> None:
- if pending_reasoning.text is None and not pending_reasoning.encrypted:
- return
- message = _last_assistant_tool_use_message(messages)
- if message is None:
- _append_pending_reasoning(messages, pending_reasoning)
- return
- reasoning_text, reasoning_blocks = pending_reasoning.take()
- if reasoning_text is not None:
- _merge_message_reasoning(message, reasoning_text)
- _prepend_reasoning_blocks(message, reasoning_blocks)
-
-
-def _append_tool_use_message(
- messages: list[dict[str, Any]],
- tool_use: dict[str, Any],
- *,
- reasoning_content: _PendingReasoning,
-) -> None:
- message = _last_assistant_tool_use_message(messages)
- if message is None:
- message = {"role": "assistant", "content": []}
- messages.append(message)
- reasoning_text, reasoning_blocks = reasoning_content.take()
- if reasoning_text is not None:
- _merge_message_reasoning(message, reasoning_text)
- _prepend_reasoning_blocks(message, reasoning_blocks)
- content = message["content"]
- if isinstance(content, list):
- content.append(tool_use)
-
-
-def _append_tool_result_message(
- messages: list[dict[str, Any]],
- tool_result: dict[str, Any],
-) -> None:
- message = _last_user_tool_result_message(messages)
- if message is None:
- message = {"role": "user", "content": []}
- messages.append(message)
- content = message["content"]
- if isinstance(content, list):
- content.append(tool_result)
-
-
-def _last_assistant_tool_use_message(
- messages: list[dict[str, Any]],
-) -> dict[str, Any] | None:
- if not messages:
- return None
- message = messages[-1]
- if message.get("role") != "assistant":
- return None
- content = message.get("content")
- if not isinstance(content, list) or not content:
- return None
- block_types = [
- block.get("type") if isinstance(block, dict) else None for block in content
- ]
- if "tool_use" in block_types and all(
- block_type in {"redacted_thinking", "thinking", "tool_use"}
- for block_type in block_types
- ):
- return message
- return None
-
-
-def _last_user_tool_result_message(
- messages: list[dict[str, Any]],
-) -> dict[str, Any] | None:
- if not messages:
- return None
- message = messages[-1]
- if message.get("role") != "user":
- return None
- content = message.get("content")
- if not isinstance(content, list) or not content:
- return None
- if all(
- isinstance(block, dict) and block.get("type") == "tool_result"
- for block in content
- ):
- return message
- return None
-
-
-def _merge_message_reasoning(message: dict[str, Any], reasoning: str) -> None:
- existing = message.get("reasoning_content")
- existing_reasoning = existing if isinstance(existing, str) else None
- message["reasoning_content"] = combine_reasoning(existing_reasoning, reasoning)
-
-
-def _prepend_reasoning_blocks(
- message: dict[str, Any], blocks: list[dict[str, str]]
-) -> None:
- if not blocks:
- return
- content = message.get("content")
- if isinstance(content, list):
- content[:0] = blocks
-
-
-def _iter_input_items(value: Any) -> list[Any]:
- if value is None:
- return []
- if isinstance(value, list):
- return value
- return [value]
-
-
-def _convert_message_content(content: Any) -> str | list[dict[str, Any]]:
- if isinstance(content, str):
- return content
- if isinstance(content, list):
- blocks: list[dict[str, Any]] = []
- for part in content:
- if isinstance(part, str):
- blocks.append({"type": "text", "text": part})
- continue
- if not isinstance(part, dict):
- raise ResponsesConversionError(
- f"Unsupported Responses content part: {type(part).__name__}"
- )
- part_type = part.get("type")
- if part_type in {"input_text", "output_text", "text"} or "text" in part:
- blocks.append({"type": "text", "text": _text_from_part(part)})
- continue
- if part_type == "refusal":
- blocks.append({"type": "text", "text": str(part.get("refusal", ""))})
- continue
- raise ResponsesConversionError(
- f"Unsupported Responses content part type: {part_type!r}"
- )
- return blocks
- if isinstance(content, dict):
- return [{"type": "text", "text": _text_from_part(content)}]
- raise ResponsesConversionError(
- f"Unsupported Responses message content: {type(content).__name__}"
- )
-
-
-def _content_as_text(content: Any) -> str:
- converted = _convert_message_content(content)
- if isinstance(converted, str):
- return converted
- return "\n".join(str(block.get("text", "")) for block in converted)
-
-
-def _text_from_part(part: Mapping[str, Any]) -> str:
- if text := optional_str(part.get("text")):
- return text
- if text := optional_str(part.get("input_text")):
- return text
- if text := optional_str(part.get("output_text")):
- return text
- return ""
diff --git a/src/free_claude_code/core/openai_responses/models.py b/src/free_claude_code/core/openai_responses/models.py
index ec80b446..3dec9975 100644
--- a/src/free_claude_code/core/openai_responses/models.py
+++ b/src/free_claude_code/core/openai_responses/models.py
@@ -1,6 +1,6 @@
-"""Pydantic models for OpenAI Responses-compatible ingress."""
+"""Wire and presentation models for OpenAI Responses-compatible ingress."""
-from typing import Any
+from dataclasses import dataclass
from pydantic import BaseModel, ConfigDict
@@ -11,16 +11,30 @@ class OpenAIResponsesRequest(BaseModel):
model_config = ConfigDict(extra="allow")
model: str
- input: Any = None
+ input: object = None
instructions: str | None = None
- tools: list[dict[str, Any]] | None = None
- tool_choice: Any = None
+ tools: list[dict[str, object]] | None = None
+ tool_choice: object = None
parallel_tool_calls: bool | None = None
stream: bool | None = True
temperature: float | None = None
top_p: float | None = None
max_output_tokens: int | None = None
- metadata: dict[str, Any] | None = None
- reasoning: dict[str, Any] | None = None
+ metadata: dict[str, object] | None = None
+ reasoning: dict[str, object] | None = None
previous_response_id: str | None = None
store: bool | None = None
+ include: object = None
+ prompt_cache_key: object = None
+
+
+@dataclass(frozen=True, slots=True)
+class ResponsesPresentationSnapshot:
+ """Validated fields echoed in public Responses envelopes."""
+
+ model: str
+ parallel_tool_calls: bool
+ tool_choice: object
+ temperature: float | None
+ top_p: float | None
+ max_output_tokens: int | None
diff --git a/src/free_claude_code/core/openai_responses/presenter.py b/src/free_claude_code/core/openai_responses/presenter.py
index 4cd6ac98..a59f9bae 100644
--- a/src/free_claude_code/core/openai_responses/presenter.py
+++ b/src/free_claude_code/core/openai_responses/presenter.py
@@ -1,6 +1,7 @@
"""Present canonical inference events through the OpenAI Responses protocol."""
import asyncio
+import json
import sys
import time
import uuid
@@ -17,7 +18,6 @@ from free_claude_code.core.inference import (
ReasoningBlockStarted,
ReasoningDelta,
ReplayArtifact,
- ReplayArtifactKind,
ResponseCompleted,
ResponseStarted,
TextBlockCompleted,
@@ -28,9 +28,9 @@ from free_claude_code.core.inference import (
ToolCallKind,
ToolCallStarted,
UsageUpdated,
- replay_payload_text,
)
from free_claude_code.core.json_types import JsonObject, JsonValue
+from free_claude_code.core.replay_envelope import encode_replay_envelope
from free_claude_code.core.token_estimation import estimate_text_tokens
from free_claude_code.core.trace import close_stream_input, trace_event
@@ -45,14 +45,9 @@ from .ids import (
new_reasoning_item_id,
new_response_id,
)
-from .models import OpenAIResponsesRequest
+from .models import ResponsesPresentationSnapshot
from .streaming.error_mapping import replay_unsafe_function_call_error
from .streaming.event_builders import ResponseEventBuilder
-from .tools import (
- custom_tool_input_text_from_arguments,
- normalized_function_call_arguments,
- responses_tool_identity_from_anthropic_name,
-)
PostStartTerminalFailureObserver = Callable[[BaseException], None]
@@ -89,8 +84,8 @@ type _OutputState = _TextState | _ReasoningState | _ToolState
class ResponsesEventPresenter:
"""Serialize one canonical stream while owning Responses envelope state."""
- def __init__(self, request: OpenAIResponsesRequest) -> None:
- self._request = request
+ def __init__(self, snapshot: ResponsesPresentationSnapshot) -> None:
+ self._snapshot = snapshot
self._response_id = new_response_id()
self._created_at = int(time.time())
self._events = ResponseEventBuilder()
@@ -145,21 +140,21 @@ class ResponsesEventPresenter:
"object": "response",
"created_at": self._created_at,
"status": status,
- "model": self._request.model,
+ "model": self._snapshot.model,
"output": [item for item in self._output if item is not None],
"parallel_tool_calls": (
True
- if self._request.parallel_tool_calls is None
- else self._request.parallel_tool_calls
+ if self._snapshot.parallel_tool_calls is None
+ else self._snapshot.parallel_tool_calls
),
"tool_choice": _json_value(
"auto"
- if self._request.tool_choice is None
- else self._request.tool_choice
+ if self._snapshot.tool_choice is None
+ else self._snapshot.tool_choice
),
- "temperature": self._request.temperature,
- "top_p": self._request.top_p,
- "max_output_tokens": self._request.max_output_tokens,
+ "temperature": self._snapshot.temperature,
+ "top_p": self._snapshot.top_p,
+ "max_output_tokens": self._snapshot.max_output_tokens,
"usage": _responses_usage(
self._usage,
reasoning_estimate=self._reasoning_tokens_estimate,
@@ -271,23 +266,15 @@ class ResponsesEventPresenter:
return chunks
def _tool_started(self, event: ToolCallStarted) -> list[str]:
- identity = responses_tool_identity_from_anthropic_name(
- self._request.tools,
- event.name,
- )
- kind = (
- ToolCallKind.CUSTOM
- if event.kind is ToolCallKind.CUSTOM or identity.kind == "custom"
- else ToolCallKind.FUNCTION
- )
+ kind = event.kind
state = _ToolState(
output_index=self._reserve_output(),
item_id=f"{'ctc' if kind is ToolCallKind.CUSTOM else 'fc'}_"
f"{uuid.uuid4().hex[:24]}",
call_id=event.call_id or new_call_id(),
kind=kind,
- name=identity.name if identity.name else event.name,
- namespace=identity.namespace or event.namespace,
+ name=event.name,
+ namespace=event.namespace,
)
self._set_block(event.block_id, state)
return [
@@ -308,7 +295,7 @@ class ResponsesEventPresenter:
if state.kind is ToolCallKind.CUSTOM:
return self._complete_custom_tool(state, arguments)
try:
- normalized = normalized_function_call_arguments(arguments or "{}")
+ normalized = _normalized_function_call_arguments(arguments or "{}")
except ResponsesConversionError as exc:
trace_event(
stage="responses",
@@ -344,7 +331,7 @@ class ResponsesEventPresenter:
return chunks
def _complete_custom_tool(self, state: _ToolState, arguments: str) -> list[str]:
- input_text = custom_tool_input_text_from_arguments(arguments)
+ input_text = _custom_tool_input_text_from_arguments(arguments)
item = _tool_item(state, status="completed", input_text=input_text)
self._commit_output(state.output_index, item)
chunks: list[str] = []
@@ -425,13 +412,13 @@ class ResponsesEventPresenter:
async def iter_responses_sse_from_events(
events: AsyncIterator[InferenceEvent],
- request: OpenAIResponsesRequest,
+ snapshot: ResponsesPresentationSnapshot,
*,
on_post_start_terminal_failure: PostStartTerminalFailureObserver | None = None,
) -> AsyncIterator[str]:
"""Serialize canonical events and map only post-start failures to wire events."""
- presenter = ResponsesEventPresenter(request)
+ presenter = ResponsesEventPresenter(snapshot)
emitted_any = False
try:
async for event in events:
@@ -526,14 +513,41 @@ def _reasoning_item(
def _encrypted_reasoning(
artifacts: tuple[ReplayArtifact, ...],
) -> str | None:
- for artifact in artifacts:
- if artifact.kind in {
- ReplayArtifactKind.REDACTED_THINKING,
- ReplayArtifactKind.ENCRYPTED_REASONING,
- ReplayArtifactKind.REASONING_DETAILS,
- }:
- return replay_payload_text(artifact)
- return None
+ return encode_replay_envelope(artifacts) if artifacts else None
+
+
+def _normalized_function_call_arguments(value: str) -> str:
+ try:
+ parsed = json.loads(value)
+ except json.JSONDecodeError as exc:
+ raise ResponsesConversionError(
+ f"Responses function_call arguments are invalid JSON: {exc.msg}"
+ ) from exc
+ if not isinstance(parsed, dict):
+ raise ResponsesConversionError(
+ "Responses function_call arguments must decode to an object"
+ )
+ return json.dumps(parsed, separators=(",", ":"))
+
+
+def _custom_tool_input_text_from_arguments(arguments: str) -> str:
+ if not arguments:
+ return ""
+ try:
+ parsed = json.loads(arguments)
+ except json.JSONDecodeError:
+ return arguments
+ if isinstance(parsed, Mapping):
+ value = parsed.get("input")
+ if value is None and not parsed:
+ return ""
+ if value is None:
+ value = parsed
+ else:
+ value = parsed
+ if isinstance(value, str):
+ return value
+ return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
def _tool_item(
diff --git a/src/free_claude_code/core/openai_responses/provider_input.py b/src/free_claude_code/core/openai_responses/provider_input.py
deleted file mode 100644
index f18030e5..00000000
--- a/src/free_claude_code/core/openai_responses/provider_input.py
+++ /dev/null
@@ -1,352 +0,0 @@
-"""Convert Anthropic Messages into an upstream OpenAI Responses request."""
-
-import json
-from typing import Any
-
-from free_claude_code.core.anthropic.content import get_block_attr, get_block_type
-from free_claude_code.core.anthropic.conversion import resolve_anthropic_tool_choice
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec
-from free_claude_code.core.anthropic.request_serialization import (
- serialize_tool_result_content,
-)
-from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
-
-from .errors import ResponsesConversionError
-
-
-def build_responses_provider_request(
- request: MessagesRequest,
- *,
- reasoning: ReasoningPolicy,
-) -> dict[str, Any]:
- """Build a stateless Responses request without silently dropping fields."""
-
- _validate_supported_request(request)
- tool_names = OpenAIToolNameCodec.from_request(request)
- instructions = _system_text(request)
- input_items: list[dict[str, Any]] = []
- for message in request.messages:
- if message.role == "system":
- text = _message_text(message.content, context="system message")
- if text:
- instructions.append(text)
- elif message.role == "assistant":
- input_items.extend(
- _assistant_items(
- message.content,
- reasoning_content=message.reasoning_content,
- tool_names=tool_names,
- )
- )
- else:
- input_items.extend(_user_items(message.content))
-
- if not input_items:
- raise ResponsesConversionError(
- "OpenAI Responses conversion requires at least one user or assistant item."
- )
-
- body: dict[str, Any] = {
- "model": request.model,
- "input": input_items,
- "stream": True,
- "store": False,
- "include": ["reasoning.encrypted_content"],
- }
- if instructions:
- body["instructions"] = "\n\n".join(instructions)
- if request.max_tokens is not None:
- body["max_output_tokens"] = request.max_tokens
- if request.temperature is not None:
- body["temperature"] = request.temperature
- if request.top_p is not None:
- body["top_p"] = request.top_p
- if request.metadata is not None:
- body["metadata"] = request.metadata
- if request.tools:
- body["tools"] = [
- {
- "type": "function",
- "name": tool_names.encode(tool.name),
- "description": tool.description,
- "parameters": tool.input_schema or {"type": "object", "properties": {}},
- "strict": False,
- }
- for tool in request.tools
- ]
- tool_choice = resolve_anthropic_tool_choice(request.tools, request.tool_choice)
- if tool_choice is not None:
- body["tool_choice"] = _tool_choice(tool_choice, tool_names=tool_names)
- if reasoning_config := _reasoning_config(reasoning):
- body["reasoning"] = reasoning_config
- return body
-
-
-def _validate_supported_request(request: MessagesRequest) -> None:
- if request.model_extra:
- raise ResponsesConversionError(
- "OpenAI Responses does not support these request fields: "
- f"{sorted(str(key) for key in request.model_extra)}."
- )
- provider_tool_types = sorted(
- {tool.type for tool in request.tools or () if tool.type is not None}
- )
- if provider_tool_types:
- raise ResponsesConversionError(
- "OpenAI Responses cannot represent provider-managed tool types: "
- f"{provider_tool_types}."
- )
- unsupported: list[str] = []
- if request.stop_sequences:
- unsupported.append("stop_sequences")
- if request.top_k is not None:
- unsupported.append("top_k")
- if not _is_noop_context_management(request.context_management):
- unsupported.append("context_management")
- unsupported.extend(_unsupported_output_config_paths(request.output_config))
- if request.mcp_servers:
- unsupported.append("mcp_servers")
- if request.extra_body:
- unsupported.append("extra_body")
- if unsupported:
- raise ResponsesConversionError(
- "OpenAI Responses cannot represent these fields without data loss: "
- f"{unsupported}."
- )
-
-
-def _unsupported_output_config_paths(
- output_config: dict[str, Any] | None,
-) -> list[str]:
- if not output_config:
- return []
- return [f"output_config.{key}" for key in sorted(output_config) if key != "effort"]
-
-
-def _is_noop_context_management(
- context_management: dict[str, Any] | None,
-) -> bool:
- if not context_management:
- return True
- if set(context_management) != {"edits"}:
- return False
- edits = context_management["edits"]
- return isinstance(edits, list) and all(
- isinstance(edit, dict)
- and edit
- == {
- "type": "clear_thinking_20251015",
- "keep": "all",
- }
- for edit in edits
- )
-
-
-def _system_text(request: MessagesRequest) -> list[str]:
- if request.system is None:
- return []
- if isinstance(request.system, str):
- return [request.system] if request.system else []
- return [part.text for part in request.system if part.text]
-
-
-def _assistant_items(
- content: Any,
- *,
- reasoning_content: str | None,
- tool_names: OpenAIToolNameCodec,
-) -> list[dict[str, Any]]:
- if isinstance(content, str):
- items = [_assistant_message([{"type": "output_text", "text": content}])]
- if reasoning_content is not None:
- items.insert(
- 0,
- {
- "type": "reasoning",
- "summary": [{"type": "summary_text", "text": reasoning_content}],
- },
- )
- return items
- if not isinstance(content, list):
- raise ResponsesConversionError(
- "Assistant content must be text or content blocks."
- )
-
- items: list[dict[str, Any]] = []
- text_parts: list[dict[str, Any]] = []
- thinking_parts: list[str] = (
- [reasoning_content] if reasoning_content is not None else []
- )
- encrypted_parts: list[str] = []
-
- def flush_text() -> None:
- if text_parts:
- items.append(_assistant_message(list(text_parts)))
- text_parts.clear()
-
- for block in content:
- block_type = get_block_type(block)
- if block_type == "text":
- text_parts.append(
- {
- "type": "output_text",
- "text": str(get_block_attr(block, "text", "")),
- }
- )
- elif block_type == "thinking":
- thinking_parts.append(str(get_block_attr(block, "thinking", "")))
- elif block_type == "redacted_thinking":
- encrypted_parts.append(str(get_block_attr(block, "data", "")))
- elif block_type == "tool_use":
- flush_text()
- items.append(
- {
- "type": "function_call",
- "call_id": str(get_block_attr(block, "id", "")),
- "name": tool_names.encode(str(get_block_attr(block, "name", ""))),
- "arguments": json.dumps(
- get_block_attr(block, "input", {}),
- ensure_ascii=False,
- separators=(",", ":"),
- ),
- }
- )
- else:
- raise ResponsesConversionError(
- "OpenAI Responses cannot represent assistant content block "
- f"{block_type!r}."
- )
- if thinking_parts or encrypted_parts:
- summary = [
- {"type": "summary_text", "text": text} for text in thinking_parts if text
- ]
- if encrypted_parts:
- for index, encrypted in enumerate(encrypted_parts):
- item: dict[str, Any] = {
- "type": "reasoning",
- "summary": summary if index == 0 else [],
- "encrypted_content": encrypted,
- }
- items.insert(index, item)
- else:
- items.insert(0, {"type": "reasoning", "summary": summary})
- flush_text()
- return items
-
-
-def _user_items(content: Any) -> list[dict[str, Any]]:
- if isinstance(content, str):
- return [_user_message([{"type": "input_text", "text": content}])]
- if not isinstance(content, list):
- raise ResponsesConversionError("User content must be text or content blocks.")
-
- items: list[dict[str, Any]] = []
- message_parts: list[dict[str, Any]] = []
-
- def flush_message() -> None:
- if message_parts:
- items.append(_user_message(list(message_parts)))
- message_parts.clear()
-
- for block in content:
- block_type = get_block_type(block)
- if block_type == "text":
- message_parts.append(
- {
- "type": "input_text",
- "text": str(get_block_attr(block, "text", "")),
- }
- )
- elif block_type == "image":
- message_parts.append(_image_part(block))
- elif block_type == "tool_result":
- flush_message()
- items.append(
- {
- "type": "function_call_output",
- "call_id": str(get_block_attr(block, "tool_use_id", "")),
- "output": serialize_tool_result_content(
- get_block_attr(block, "content")
- ),
- }
- )
- elif block_type == "document":
- raise ResponsesConversionError(
- "OpenAI Responses provider does not support Anthropic document blocks."
- )
- else:
- raise ResponsesConversionError(
- f"OpenAI Responses cannot represent user content block {block_type!r}."
- )
- flush_message()
- return items
-
-
-def _image_part(block: Any) -> dict[str, Any]:
- source = get_block_attr(block, "source", {})
- source_type = get_block_attr(source, "type")
- if source_type == "url":
- url = get_block_attr(source, "url")
- elif source_type == "base64":
- media_type = get_block_attr(source, "media_type")
- data = get_block_attr(source, "data")
- if not isinstance(media_type, str) or not isinstance(data, str):
- raise ResponsesConversionError("Base64 images require media_type and data.")
- url = f"data:{media_type};base64,{data}"
- else:
- raise ResponsesConversionError(
- f"Unsupported image source type {source_type!r}."
- )
- if not isinstance(url, str) or not url:
- raise ResponsesConversionError("Image source requires a non-empty URL.")
- return {"type": "input_image", "image_url": url}
-
-
-def _message_text(content: Any, *, context: str) -> str:
- if isinstance(content, str):
- return content
- if not isinstance(content, list):
- raise ResponsesConversionError(f"{context} must contain only text.")
- parts: list[str] = []
- for block in content:
- if get_block_type(block) != "text":
- raise ResponsesConversionError(f"{context} must contain only text.")
- parts.append(str(get_block_attr(block, "text", "")))
- return "\n\n".join(parts)
-
-
-def _assistant_message(content: list[dict[str, Any]]) -> dict[str, Any]:
- return {"type": "message", "role": "assistant", "content": content}
-
-
-def _user_message(content: list[dict[str, Any]]) -> dict[str, Any]:
- return {"type": "message", "role": "user", "content": content}
-
-
-def _tool_choice(
- choice: dict[str, Any],
- *,
- tool_names: OpenAIToolNameCodec,
-) -> str | dict[str, str]:
- choice_type = choice.get("type")
- if choice_type in {"auto", "none"}:
- return str(choice_type)
- if choice_type == "any":
- return "required"
- if choice_type == "tool":
- name = choice.get("name")
- if not isinstance(name, str) or not name:
- raise ResponsesConversionError("Forced tool choice requires a tool name.")
- return {"type": "function", "name": tool_names.encode(name)}
- raise ResponsesConversionError(f"Unsupported tool_choice type {choice_type!r}.")
-
-
-def _reasoning_config(reasoning: ReasoningPolicy) -> dict[str, str]:
- if reasoning.control is ReasoningControl.OFF:
- return {"effort": "none"}
- if reasoning.effort is not None:
- return {"effort": reasoning.effort.value, "summary": "auto"}
- if reasoning.requests_reasoning:
- return {"summary": "auto"}
- return {}
diff --git a/src/free_claude_code/core/openai_responses/reasoning.py b/src/free_claude_code/core/openai_responses/reasoning.py
index 5617a0e4..6d42280e 100644
--- a/src/free_claude_code/core/openai_responses/reasoning.py
+++ b/src/free_claude_code/core/openai_responses/reasoning.py
@@ -3,8 +3,6 @@
from collections.abc import Mapping
from typing import Any
-from .tools import optional_str
-
def reasoning_text_from_item(item: Mapping[str, Any]) -> str | None:
content_parts = _text_parts_from_items(
@@ -23,7 +21,7 @@ def reasoning_text_from_item(item: Mapping[str, Any]) -> str | None:
def encrypted_reasoning_from_item(item: Mapping[str, Any]) -> str | None:
"""Return opaque reasoning content without interpreting it."""
- return optional_str(item.get("encrypted_content"))
+ return _optional_str(item.get("encrypted_content"))
def combine_reasoning(existing: str | None, addition: str | None) -> str | None:
@@ -54,7 +52,11 @@ def _text_parts_from_items(value: Any, *, item_type: str) -> list[str]:
parts: list[str] = []
for item in value:
if isinstance(item, dict) and item.get("type") == item_type:
- text = optional_str(item.get("text"))
+ text = _optional_str(item.get("text"))
if text is not None:
parts.append(text)
return parts
+
+
+def _optional_str(value: object) -> str | None:
+ return value if isinstance(value, str) else None
diff --git a/src/free_claude_code/core/openai_responses/tools.py b/src/free_claude_code/core/openai_responses/tools.py
deleted file mode 100644
index 259e75e7..00000000
--- a/src/free_claude_code/core/openai_responses/tools.py
+++ /dev/null
@@ -1,375 +0,0 @@
-"""Tool conversion helpers for the OpenAI Responses adapter."""
-
-import hashlib
-import json
-import re
-from collections.abc import Mapping
-from dataclasses import dataclass
-from typing import Any, Literal
-
-from .errors import ResponsesConversionError
-from .ids import new_call_id
-
-_MAX_ANTHROPIC_TOOL_NAME_LEN = 64
-_NAMESPACE_TOOL_SEPARATOR = "__"
-_UNSUPPORTED_PASSIVE_TOOL_TYPES = frozenset(
- {"web_search", "image_generation", "tool_search"}
-)
-_INVALID_TOOL_NAME_CHARS = re.compile(r"[^A-Za-z0-9_-]+")
-
-
-@dataclass(frozen=True, slots=True)
-class ResponsesToolIdentity:
- kind: Literal["function", "custom"]
- name: str
- namespace: str | None = None
-
-
-def convert_tools(value: Any) -> list[dict[str, Any]] | None:
- if value is None:
- return None
- if not isinstance(value, list):
- raise ResponsesConversionError("Responses tools must be a list")
-
- tools: list[dict[str, Any]] = []
- for tool in value:
- if not isinstance(tool, dict):
- raise ResponsesConversionError(
- f"Unsupported Responses tool: {type(tool).__name__}"
- )
- tool_type = tool.get("type")
- if tool_type == "function":
- tools.append(_convert_function_tool(tool, namespace=None))
- continue
- if tool_type == "custom":
- tools.append(_convert_custom_tool(tool, namespace=None))
- continue
- if tool_type == "namespace":
- tools.extend(_convert_namespace_tool(tool))
- continue
- if tool_type in _UNSUPPORTED_PASSIVE_TOOL_TYPES:
- continue
- if tool_type != "function":
- raise ResponsesConversionError(
- f"Unsupported Responses tool type: {tool_type!r}"
- )
- return tools
-
-
-def convert_tool_choice(value: Any) -> dict[str, Any] | None:
- if value is None or value == "auto":
- return None
- if value == "none":
- return None
- if value == "required":
- return {"type": "any"}
- if isinstance(value, dict):
- choice_type = value.get("type")
- if choice_type == "function":
- namespace = optional_str(value.get("namespace"))
- name = required_str(value.get("name"), "tool_choice.name")
- return {
- "type": "tool",
- "name": responses_tool_name_to_anthropic_name(
- name, namespace=namespace
- ),
- }
- if choice_type == "custom":
- source = _custom_source(value)
- namespace = optional_str(source.get("namespace")) or optional_str(
- value.get("namespace")
- )
- name = required_str(source.get("name"), "tool_choice.name")
- return {
- "type": "tool",
- "name": responses_tool_name_to_anthropic_name(
- name, namespace=namespace
- ),
- }
- if choice_type == "tool":
- namespace = optional_str(value.get("namespace"))
- name = optional_str(value.get("name"))
- if name:
- return {
- "type": "tool",
- "name": responses_tool_name_to_anthropic_name(
- name, namespace=namespace
- ),
- }
- return dict(value)
- if choice_type in {"auto", "any"}:
- return dict(value)
- raise ResponsesConversionError(f"Unsupported Responses tool_choice: {value!r}")
-
-
-def responses_tool_name_to_anthropic_name(
- name: str, *, namespace: str | None = None
-) -> str:
- """Return a deterministic Anthropic tool name for a Responses tool identity."""
-
- if not namespace:
- return name
- combined = (
- f"{_tool_name_part(namespace)}"
- f"{_NAMESPACE_TOOL_SEPARATOR}"
- f"{_tool_name_part(name)}"
- )
- if len(combined) <= _MAX_ANTHROPIC_TOOL_NAME_LEN:
- return combined
- digest = hashlib.sha1(combined.encode("utf-8")).hexdigest()[:8]
- prefix_len = _MAX_ANTHROPIC_TOOL_NAME_LEN - len(digest) - 1
- return f"{combined[:prefix_len]}_{digest}"
-
-
-def responses_tool_identity_from_anthropic_name(
- tools: list[dict[str, Any]] | None, anthropic_name: str
-) -> ResponsesToolIdentity:
- """Return the Responses namespace/name represented by an Anthropic tool name."""
-
- if tools is None:
- return ResponsesToolIdentity(kind="function", name=anthropic_name)
- for tool in tools:
- if not isinstance(tool, dict):
- continue
- tool_type = tool.get("type")
- if tool_type == "function":
- source = tool.get("function")
- function = source if isinstance(source, dict) else tool
- if (name := optional_str(function.get("name"))) and (
- responses_tool_name_to_anthropic_name(name) == anthropic_name
- ):
- return ResponsesToolIdentity(kind="function", name=name)
- continue
- if tool_type == "custom":
- source = _custom_source(tool)
- if (name := optional_str(source.get("name"))) and (
- responses_tool_name_to_anthropic_name(name) == anthropic_name
- ):
- return ResponsesToolIdentity(kind="custom", name=name)
- continue
- if tool_type != "namespace":
- continue
- namespace = optional_str(tool.get("name"))
- nested_tools = tool.get("tools")
- if not namespace or not isinstance(nested_tools, list):
- continue
- for nested_tool in nested_tools:
- if not isinstance(nested_tool, dict):
- continue
- nested_tool_type = nested_tool.get("type")
- if nested_tool_type == "function":
- source = nested_tool.get("function")
- function = source if isinstance(source, dict) else nested_tool
- if (name := optional_str(function.get("name"))) and (
- responses_tool_name_to_anthropic_name(name, namespace=namespace)
- == anthropic_name
- ):
- return ResponsesToolIdentity(
- kind="function", name=name, namespace=namespace
- )
- continue
- if nested_tool_type == "custom":
- source = _custom_source(nested_tool)
- if (name := optional_str(source.get("name"))) and (
- responses_tool_name_to_anthropic_name(name, namespace=namespace)
- == anthropic_name
- ):
- return ResponsesToolIdentity(
- kind="custom", name=name, namespace=namespace
- )
- return ResponsesToolIdentity(kind="function", name=anthropic_name)
-
-
-def parse_arguments(value: Any) -> dict[str, Any]:
- if value is None or value == "":
- return {}
- if isinstance(value, dict):
- return value
- if not isinstance(value, str):
- raise ResponsesConversionError("Responses function_call arguments must be JSON")
- try:
- parsed = json.loads(value)
- except json.JSONDecodeError as exc:
- raise ResponsesConversionError(
- f"Responses function_call arguments are invalid JSON: {exc.msg}"
- ) from exc
- if not isinstance(parsed, dict):
- raise ResponsesConversionError(
- "Responses function_call arguments must decode to an object"
- )
- return parsed
-
-
-def normalized_function_call_arguments(value: Any) -> str:
- return json.dumps(parse_arguments(value), separators=(",", ":"))
-
-
-def custom_tool_input_to_anthropic(value: Any) -> dict[str, str]:
- return {"input": custom_tool_input_text(value)}
-
-
-def custom_tool_input_text(value: Any) -> str:
- if value is None:
- return ""
- if isinstance(value, str):
- return value
- return _json_dumps(value)
-
-
-def custom_tool_input_text_from_anthropic(value: Any) -> str:
- if isinstance(value, Mapping):
- raw_input = value.get("input")
- if isinstance(raw_input, str):
- return raw_input
- if raw_input is not None:
- return custom_tool_input_text(raw_input)
- if not value:
- return ""
- return _json_dumps(value)
- return custom_tool_input_text(value)
-
-
-def custom_tool_input_text_from_arguments(arguments: str) -> str:
- if not arguments:
- return ""
- try:
- parsed = json.loads(arguments)
- except json.JSONDecodeError:
- return arguments
- return custom_tool_input_text_from_anthropic(parsed)
-
-
-def call_id_from_item(item: Mapping[str, Any]) -> str:
- for key in ("call_id", "id"):
- if value := optional_str(item.get(key)):
- return value
- return new_call_id()
-
-
-def required_str(value: Any, field_name: str) -> str:
- if isinstance(value, str) and value:
- return value
- raise ResponsesConversionError(
- f"Responses field {field_name} must be a non-empty string"
- )
-
-
-def optional_str(value: Any) -> str | None:
- return value if isinstance(value, str) else None
-
-
-def _convert_namespace_tool(tool: Mapping[str, Any]) -> list[dict[str, Any]]:
- namespace = required_str(tool.get("name"), "tool.namespace.name")
- nested_tools = tool.get("tools")
- if not isinstance(nested_tools, list):
- raise ResponsesConversionError(
- f"Responses namespace tool {namespace!r} tools must be a list"
- )
-
- converted_tools: list[dict[str, Any]] = []
- for nested_tool in nested_tools:
- if not isinstance(nested_tool, dict):
- raise ResponsesConversionError(
- f"Unsupported Responses namespace tool: {type(nested_tool).__name__}"
- )
- nested_tool_type = nested_tool.get("type")
- if nested_tool_type == "function":
- converted_tools.append(
- _convert_function_tool(nested_tool, namespace=namespace)
- )
- continue
- if nested_tool_type == "custom":
- converted_tools.append(
- _convert_custom_tool(nested_tool, namespace=namespace)
- )
- continue
- raise ResponsesConversionError(
- f"Unsupported Responses namespace tool type: {nested_tool_type!r}"
- )
- return converted_tools
-
-
-def _convert_function_tool(
- tool: Mapping[str, Any], *, namespace: str | None
-) -> dict[str, Any]:
- function = tool.get("function")
- source = function if isinstance(function, dict) else tool
- name = required_str(source.get("name"), "tool.name")
- schema = source.get("parameters")
- if schema is None:
- schema = {"type": "object", "properties": {}}
- if not isinstance(schema, dict):
- raise ResponsesConversionError(
- f"Responses tool {name!r} parameters must be an object"
- )
- converted: dict[str, Any] = {
- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),
- "input_schema": schema,
- }
- if description := optional_str(source.get("description")):
- converted["description"] = description
- return converted
-
-
-def _convert_custom_tool(
- tool: Mapping[str, Any], *, namespace: str | None
-) -> dict[str, Any]:
- source = _custom_source(tool)
- name = required_str(source.get("name"), "tool.name")
- converted: dict[str, Any] = {
- "name": responses_tool_name_to_anthropic_name(name, namespace=namespace),
- "input_schema": {
- "type": "object",
- "properties": {
- "input": {
- "type": "string",
- "description": "Free-form input for the custom tool.",
- }
- },
- "required": ["input"],
- },
- }
- if description := _custom_tool_description(source):
- converted["description"] = description
- return converted
-
-
-def _custom_source(tool: Mapping[str, Any]) -> Mapping[str, Any]:
- custom = tool.get("custom")
- return custom if isinstance(custom, Mapping) else tool
-
-
-def _custom_tool_description(source: Mapping[str, Any]) -> str | None:
- parts: list[str] = []
- if description := optional_str(source.get("description")):
- parts.append(description)
- format_value = source.get("format")
- if isinstance(format_value, Mapping):
- format_type = optional_str(format_value.get("type"))
- if format_type == "text":
- parts.append("Custom tool input format: unconstrained text.")
- elif format_type == "grammar":
- syntax = optional_str(format_value.get("syntax"))
- definition = optional_str(format_value.get("definition"))
- guidance = "Custom tool input format: grammar"
- if syntax:
- guidance = f"{guidance} ({syntax})"
- guidance = f"{guidance}: {definition}" if definition else f"{guidance}."
- parts.append(guidance)
- elif format_type:
- parts.append(f"Custom tool input format: {format_type}.")
- else:
- parts.append(f"Custom tool input format: {_json_dumps(format_value)}")
- return "\n\n".join(parts) if parts else None
-
-
-def _tool_name_part(value: str) -> str:
- normalized = _INVALID_TOOL_NAME_CHARS.sub("_", value).strip("_")
- return normalized or "tool"
-
-
-def _json_dumps(value: Any) -> str:
- try:
- return json.dumps(value)
- except TypeError:
- return str(value)
diff --git a/src/free_claude_code/core/replay_envelope.py b/src/free_claude_code/core/replay_envelope.py
new file mode 100644
index 00000000..f1d92608
--- /dev/null
+++ b/src/free_claude_code/core/replay_envelope.py
@@ -0,0 +1,169 @@
+"""Versioned public envelope for opaque inference replay artifacts."""
+
+import base64
+import binascii
+import json
+import math
+from collections.abc import Mapping, Sequence
+
+from free_claude_code.core.inference import (
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+)
+from free_claude_code.core.json_types import JsonValue
+
+REPLAY_ENVELOPE_PREFIX = "fcc-replay-v1:"
+_REPLAY_ENVELOPE_VERSION = 1
+_MAX_REPLAY_ENVELOPE_BYTES = 1_048_576
+_ARTIFACT_KEYS = frozenset({"origin", "kind", "attachment", "scope", "payload"})
+
+
+class ReplayEnvelopeError(ValueError):
+ """A recognized FCC replay envelope is malformed or unsupported."""
+
+
+def encode_replay_envelope(artifacts: tuple[ReplayArtifact, ...]) -> str:
+ """Encode ordered replay artifacts into the deterministic v1 carrier."""
+
+ if not artifacts:
+ raise ValueError("a replay envelope requires at least one artifact")
+ payload = {
+ "version": _REPLAY_ENVELOPE_VERSION,
+ "artifacts": [
+ {
+ "origin": artifact.origin.value,
+ "kind": artifact.kind.value,
+ "attachment": artifact.attachment.value,
+ "scope": (artifact.scope.value if artifact.scope is not None else None),
+ "payload": _json_copy(artifact.payload),
+ }
+ for artifact in artifacts
+ ],
+ }
+ encoded = json.dumps(
+ payload,
+ allow_nan=False,
+ ensure_ascii=False,
+ separators=(",", ":"),
+ sort_keys=True,
+ ).encode("utf-8")
+ if len(encoded) > _MAX_REPLAY_ENVELOPE_BYTES:
+ raise ValueError("replay envelope exceeds the supported size limit")
+ carrier = base64.urlsafe_b64encode(encoded).decode("ascii").rstrip("=")
+ return f"{REPLAY_ENVELOPE_PREFIX}{carrier}"
+
+
+def decode_replay_envelope(
+ value: str,
+ *,
+ attachment: ReplayAttachment,
+) -> tuple[ReplayArtifact, ...] | None:
+ """Decode a recognized carrier, or return ``None`` for a legacy raw value."""
+
+ if not value.startswith(REPLAY_ENVELOPE_PREFIX):
+ return None
+ token = value.removeprefix(REPLAY_ENVELOPE_PREFIX)
+ if not token:
+ raise ReplayEnvelopeError("FCC replay envelope payload is empty")
+ padding = "=" * (-len(token) % 4)
+ try:
+ raw = base64.b64decode(
+ token + padding,
+ altchars=b"-_",
+ validate=True,
+ )
+ except (binascii.Error, ValueError) as exc:
+ raise ReplayEnvelopeError("FCC replay envelope is not valid base64url") from exc
+ if len(raw) > _MAX_REPLAY_ENVELOPE_BYTES:
+ raise ReplayEnvelopeError(
+ "FCC replay envelope exceeds the supported size limit"
+ )
+ try:
+ payload = json.loads(raw.decode("utf-8"))
+ except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+ raise ReplayEnvelopeError(
+ "FCC replay envelope is not valid UTF-8 JSON"
+ ) from exc
+ if not isinstance(payload, dict) or set(payload) != {"version", "artifacts"}:
+ raise ReplayEnvelopeError("FCC replay envelope has an invalid top-level schema")
+ if payload.get("version") != _REPLAY_ENVELOPE_VERSION:
+ raise ReplayEnvelopeError("FCC replay envelope version is unsupported")
+ raw_artifacts = payload.get("artifacts")
+ if not isinstance(raw_artifacts, list) or not raw_artifacts:
+ raise ReplayEnvelopeError(
+ "FCC replay envelope artifacts must be a non-empty list"
+ )
+ artifacts = tuple(
+ _decode_artifact(raw_artifact, index=index, attachment=attachment)
+ for index, raw_artifact in enumerate(raw_artifacts)
+ )
+ return artifacts
+
+
+def _decode_artifact(
+ value: object,
+ *,
+ index: int,
+ attachment: ReplayAttachment,
+) -> ReplayArtifact:
+ path = f"artifacts[{index}]"
+ if not isinstance(value, dict) or set(value) != _ARTIFACT_KEYS:
+ raise ReplayEnvelopeError(f"FCC replay envelope {path} has an invalid schema")
+ try:
+ origin = ReplayArtifactOrigin(value["origin"])
+ kind = ReplayArtifactKind(value["kind"])
+ decoded_attachment = ReplayAttachment(value["attachment"])
+ except (KeyError, TypeError, ValueError) as exc:
+ raise ReplayEnvelopeError(
+ f"FCC replay envelope {path} has an unknown artifact value"
+ ) from exc
+ if decoded_attachment is not attachment:
+ raise ReplayEnvelopeError(
+ f"FCC replay envelope {path}.attachment does not match its carrier"
+ )
+ raw_scope = value.get("scope")
+ if raw_scope is not None and (
+ not isinstance(raw_scope, str) or not raw_scope.strip()
+ ):
+ raise ReplayEnvelopeError(
+ f"FCC replay envelope {path}.scope must be null or a non-empty string"
+ )
+ raw_payload = value.get("payload")
+ if not _is_json_value(raw_payload):
+ raise ReplayEnvelopeError(
+ f"FCC replay envelope {path}.payload is not valid JSON"
+ )
+ return ReplayArtifact(
+ origin=origin,
+ kind=kind,
+ attachment=decoded_attachment,
+ payload=raw_payload,
+ scope=(
+ ReplayCompatibilityScope(raw_scope) if isinstance(raw_scope, str) else None
+ ),
+ )
+
+
+def _is_json_value(value: object) -> bool:
+ if value is None or isinstance(value, bool | int | str):
+ return True
+ if isinstance(value, float):
+ return math.isfinite(value)
+ if isinstance(value, list):
+ return all(_is_json_value(item) for item in value)
+ if isinstance(value, dict):
+ return all(
+ isinstance(key, str) and _is_json_value(item) for key, item in value.items()
+ )
+ return False
+
+
+def _json_copy(value: JsonValue) -> JsonValue:
+ if isinstance(value, Mapping):
+ return {str(key): _json_copy(item) for key, item in value.items()}
+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+ return [_json_copy(item) for item in value]
+ return value
diff --git a/src/free_claude_code/providers/base.py b/src/free_claude_code/providers/base.py
index ab426729..5435b8fb 100644
--- a/src/free_claude_code/providers/base.py
+++ b/src/free_claude_code/providers/base.py
@@ -7,12 +7,11 @@ from dataclasses import dataclass
from loguru import logger
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 (
exception_cause_types,
redacted_exception_traceback,
)
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import InferenceEvent, InferenceRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.core.trace import trace_event
@@ -47,8 +46,9 @@ class BaseProvider(ABC):
@abstractmethod
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
"""Validate the upstream request before opening an SSE stream."""
@@ -107,9 +107,10 @@ class BaseProvider(ABC):
@abstractmethod
def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
diff --git a/src/free_claude_code/providers/cloudflare/client.py b/src/free_claude_code/providers/cloudflare/client.py
index 616d8348..c7b6218c 100644
--- a/src/free_claude_code/providers/cloudflare/client.py
+++ b/src/free_claude_code/providers/cloudflare/client.py
@@ -10,7 +10,6 @@ import httpx
from free_claude_code.application.errors import ApplicationUnavailableError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.provider_catalog import CLOUDFLARE_AI_REST_ROOT
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.core.inference import (
InferenceEvent,
InferenceStreamLedger,
@@ -30,6 +29,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
validate_extra_body_does_not_override_canonical_fields,
)
diff --git a/src/free_claude_code/providers/deepseek/client.py b/src/free_claude_code/providers/deepseek/client.py
index 29a5a345..09e1f23e 100644
--- a/src/free_claude_code/providers/deepseek/client.py
+++ b/src/free_claude_code/providers/deepseek/client.py
@@ -2,7 +2,7 @@
from typing import Any
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
@@ -35,12 +35,14 @@ class DeepSeekProvider(OpenAIChatProvider):
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict:
return build_deepseek_request_body(
request,
+ provider_model=provider_model,
reasoning=reasoning,
)
diff --git a/src/free_claude_code/providers/deepseek/compat.py b/src/free_claude_code/providers/deepseek/compat.py
index f62503ff..1f8ab1ff 100644
--- a/src/free_claude_code/providers/deepseek/compat.py
+++ b/src/free_claude_code/providers/deepseek/compat.py
@@ -1,18 +1,19 @@
-"""DeepSeek Anthropic-to-OpenAI chat request policy."""
-
-from collections.abc import Mapping
-from typing import Any
+"""DeepSeek-owned OpenAI Chat compatibility policy."""
from loguru import logger
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from free_claude_code.core.anthropic import (
- ReasoningReplayMode,
- dump_messages_request,
- serialize_tool_result_content,
+from free_claude_code.core.inference import (
+ DocumentContent,
+ ImageContent,
+ InferenceRequest,
+ MessageItem,
+ ReasoningItem,
+ ToolCallItem,
+ ToolChoiceMode,
)
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.json_types import JsonObject
from free_claude_code.core.reasoning import (
ReasoningControl,
ReasoningEffort,
@@ -20,8 +21,13 @@ from free_claude_code.core.reasoning import (
)
from free_claude_code.providers.openai_chat import (
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
build_openai_chat_request_body,
)
+from free_claude_code.providers.openai_compat import (
+ OpenAIToolNameCodec,
+ openai_replay_scope,
+)
DEEPSEEK_REQUEST_POLICY = OpenAIChatRequestPolicy(
provider_name="DEEPSEEK",
@@ -29,466 +35,109 @@ DEEPSEEK_REQUEST_POLICY = OpenAIChatRequestPolicy(
include_extra_body=True,
)
-_UNSUPPORTED_MESSAGE_BLOCK_TYPES = frozenset(
- {
- "image",
- "document",
- "server_tool_use",
- "web_search_tool_result",
- "web_fetch_tool_result",
- }
-)
-_STRIPPABLE_MESSAGE_BLOCK_TYPES = frozenset({"image", "document"})
-_FORWARDABLE_ATTACHMENT_BLOCK_TYPES = frozenset({"image"})
-_OMITTED_ATTACHMENT_TEXT = (
- "[attachment omitted: DeepSeek does not support image or document inputs]"
-)
-_OMITTED_ATTACHMENT_BLOCK = {"type": "text", "text": _OMITTED_ATTACHMENT_TEXT}
-
-
-def _is_vision_capable_model(model: str | None) -> bool:
- """True when the DeepSeek model accepts OpenAI image parts.
-
- DeepSeek's vision models (e.g. ``deepseek-v4-flash-vision-exp``) support
- image inputs natively. Document blocks are still stripped because the
- shared OpenAI conversion path has no document parts.
- """
- if not model:
- return False
- return "vision" in str(model).rsplit("/", 1)[-1].lower()
-
def build_deepseek_request_body(
- request_data: MessagesRequest, *, reasoning: ReasoningPolicy
-) -> dict:
- """Build a DeepSeek Chat Completions body from an Anthropic request."""
- logger.debug(
- "DEEPSEEK_REQUEST: chat build model={} msgs={}",
- request_data.model,
- len(request_data.messages),
- )
-
- vision_capable = _is_vision_capable_model(request_data.model)
- data = dump_messages_request(request_data)
- if "messages" in data:
- data["messages"] = _strip_unsupported_attachment_blocks(
- data["messages"], allow_attachments=vision_capable
- )
- _validate_deepseek_request_dict(data, allow_attachments=vision_capable)
- _downgrade_forced_tool_choice(data)
-
- has_tool_history = _has_tool_history(data)
- has_replayable_tool_thinking = _all_tool_calls_have_replayable_thinking(data)
- unsafe_tool_followup = has_tool_history and not has_replayable_tool_thinking
+ request: InferenceRequest,
+ *,
+ provider_model: str,
+ reasoning: ReasoningPolicy,
+) -> JsonObject:
+ """Build one DeepSeek request without rewriting canonical history."""
+
+ _validate_media(request, provider_model=provider_model)
effective_reasoning = reasoning
- if reasoning.control is not ReasoningControl.OFF:
- if unsafe_tool_followup:
- logger.debug(
- "DEEPSEEK_REQUEST: disabling thinking for tool follow-up without "
- "replayable thinking model={} msgs={} tools={}",
- data.get("model"),
- len(data.get("messages", [])),
- len(data.get("tools", [])),
- )
- _remove_deepseek_thinking_hints(data)
- effective_reasoning = ReasoningPolicy.off()
- elif has_tool_history:
- logger.debug(
- "DEEPSEEK_REQUEST: keeping thinking for tool follow-up with "
- "replayable thinking model={} msgs={} tools={}",
- data.get("model"),
- len(data.get("messages", [])),
- len(data.get("tools", [])),
- )
- elif data.get("tools") or data.get("tool_choice"):
- logger.debug(
- "DEEPSEEK_REQUEST: keeping thinking for initial tool request "
- "model={} msgs={} tools={}",
- data.get("model"),
- len(data.get("messages", [])),
- len(data.get("tools", [])),
- )
-
- if "messages" in data:
- data["messages"] = _normalize_tool_result_content(
- sanitize_deepseek_messages_for_openai(data["messages"])
+ if (
+ reasoning.control is not ReasoningControl.OFF
+ and _has_tool_history(request)
+ and not _all_tool_calls_have_replayable_reasoning(request)
+ ):
+ logger.debug(
+ "DEEPSEEK_REQUEST: disabling thinking for a tool follow-up without "
+ "replayable reasoning model={} items={}",
+ provider_model,
+ len(request.items),
)
+ effective_reasoning = ReasoningPolicy.off()
- sanitized_request = MessagesRequest.model_validate(data)
body = build_openai_chat_request_body(
- sanitized_request,
+ request,
+ provider_model=provider_model,
reasoning=effective_reasoning,
policy=DEEPSEEK_REQUEST_POLICY,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=openai_replay_scope(
+ "DEEPSEEK",
+ provider_model,
+ replay_format="chat-completions",
+ ),
postprocessors=(_apply_deepseek_chat_extras,),
)
- if "max_tokens" not in body or body.get("max_tokens") is None:
- body["max_tokens"] = ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-
- logger.debug(
- "DEEPSEEK_REQUEST: build done model={} msgs={} tools={}",
- body.get("model"),
- len(body.get("messages", [])),
- len(body.get("tools", [])),
- )
+ if (
+ request.tool_choice is not None
+ and request.tool_choice.mode is ToolChoiceMode.SPECIFIC
+ ):
+ logger.debug(
+ "DEEPSEEK_REQUEST: downgrading unsupported specific tool choice to auto"
+ )
+ body["tool_choice"] = "auto"
+ body.setdefault("max_tokens", ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS)
return body
-def sanitize_deepseek_messages_for_openai(messages: Any) -> Any:
- """Keep only DeepSeek-required reasoning history on assistant tool calls."""
- if not isinstance(messages, list):
- return messages
-
- sanitized: list[Any] = []
- for message in messages:
- if not isinstance(message, dict):
- sanitized.append(message)
- continue
- if message.get("role") != "assistant":
- sanitized.append(message)
+def _validate_media(request: InferenceRequest, *, provider_model: str) -> None:
+ vision_capable = "vision" in provider_model.rsplit("/", 1)[-1].lower()
+ for item in request.items:
+ if not isinstance(item, MessageItem):
continue
- replay_tool_reasoning = _assistant_has_tool_use(message)
- new_msg = dict(message)
- if not replay_tool_reasoning:
- new_msg.pop("reasoning_content", None)
- content = message.get("content")
- if not isinstance(content, list):
- sanitized.append(new_msg)
- continue
-
- filtered = [
- block
- for block in content
- if not (
- isinstance(block, dict)
- and (
- block.get("type") == "redacted_thinking"
- or (block.get("type") == "thinking" and not replay_tool_reasoning)
+ for content in item.content:
+ if isinstance(content, DocumentContent):
+ raise InvalidRequestError(
+ "DeepSeek Chat does not support document content."
)
- )
- ]
- new_msg["content"] = filtered or ""
- sanitized.append(new_msg)
- return sanitized
-
-
-def _strip_unsupported_attachment_blocks(
- messages: Any, *, allow_attachments: bool = False
-) -> Any:
- if not isinstance(messages, list):
- return messages
-
- stripped: list[Any] = []
- top_level_dropped: dict[str, int] = {}
- nested_dropped: dict[str, int] = {}
- placeholder_replacements = 0
-
- for message in messages:
- if not isinstance(message, dict):
- stripped.append(message)
- continue
- content = message.get("content")
- if not isinstance(content, list):
- stripped.append(message)
- continue
-
- new_content: list[Any] = []
- message_dropped_attachment = False
- for block in content:
- if isinstance(block, dict):
- btype = block.get("type")
- if btype in _STRIPPABLE_MESSAGE_BLOCK_TYPES:
- if (
- allow_attachments
- and btype in _FORWARDABLE_ATTACHMENT_BLOCK_TYPES
- ):
- new_content.append(block)
- continue
- top_level_dropped[btype] = top_level_dropped.get(btype, 0) + 1
- message_dropped_attachment = True
- continue
- if btype == "tool_result":
- inner = block.get("content")
- if isinstance(inner, list):
- filtered_inner: list[Any] = []
- for sub in inner:
- if (
- isinstance(sub, dict)
- and sub.get("type") in _STRIPPABLE_MESSAGE_BLOCK_TYPES
- ):
- sub_type = sub["type"]
- if (
- allow_attachments
- and sub_type in _FORWARDABLE_ATTACHMENT_BLOCK_TYPES
- ):
- filtered_inner.append(sub)
- continue
- nested_dropped[sub_type] = (
- nested_dropped.get(sub_type, 0) + 1
- )
- continue
- filtered_inner.append(sub)
- if not filtered_inner:
- filtered_inner = [_OMITTED_ATTACHMENT_BLOCK]
- placeholder_replacements += 1
- new_block = dict(block)
- new_block["content"] = filtered_inner
- new_content.append(new_block)
- continue
- new_content.append(block)
- if not new_content and message_dropped_attachment:
- new_content = [_OMITTED_ATTACHMENT_BLOCK]
- placeholder_replacements += 1
- new_msg = dict(message)
- new_msg["content"] = new_content
- stripped.append(new_msg)
-
- if top_level_dropped or nested_dropped:
- logger.warning(
- "DEEPSEEK_REQUEST: stripped unsupported attachment blocks "
- "(top_level={} nested_in_tool_result={} placeholder_tool_results={}). "
- "DeepSeek has no vision/document support; the model will not see this content.",
- dict(top_level_dropped),
- dict(nested_dropped),
- placeholder_replacements,
- )
- return stripped
-
-
-def _is_server_listed_tool(tool: Mapping[str, Any]) -> bool:
- name = (tool.get("name") or "").strip()
- if name in ("web_search", "web_fetch"):
- return True
- typ = tool.get("type")
- if isinstance(typ, str):
- return typ.startswith("web_search") or typ.startswith("web_fetch")
- return False
-
-
-def _walk_block_list_for_unsupported(
- blocks: Any, *, where: str, allow_attachments: bool = False
-) -> None:
- if not isinstance(blocks, list):
- return
- for block in blocks:
- if not isinstance(block, dict):
- continue
- btype = block.get("type")
- if btype in _UNSUPPORTED_MESSAGE_BLOCK_TYPES:
- if allow_attachments and btype in _FORWARDABLE_ATTACHMENT_BLOCK_TYPES:
- continue
- raise InvalidRequestError(
- f"DeepSeek native does not support {btype!r} blocks ({where})."
- )
- if btype == "tool_result" and "content" in block:
- _walk_block_list_for_unsupported(
- block["content"],
- where=f"{where} (tool_result content)",
- allow_attachments=allow_attachments,
- )
-
-
-def _validate_deepseek_request_dict(
- data: dict[str, Any], *, allow_attachments: bool = False
-) -> None:
- mcp = data.get("mcp_servers")
- if mcp:
- raise InvalidRequestError("DeepSeek does not support mcp_servers on requests.")
-
- for tool in data.get("tools") or ():
- if not isinstance(tool, dict):
- continue
- if _is_server_listed_tool(tool):
- raise InvalidRequestError(
- "DeepSeek does not support listed Anthropic server tools "
- "(web_search / web_fetch). Remove them or use a different provider."
- )
-
- for i, message in enumerate(data.get("messages") or ()):
- if not isinstance(message, dict):
- continue
- content = message.get("content")
- if isinstance(content, list):
- _walk_block_list_for_unsupported(
- content,
- where=f"messages[{i}].content",
- allow_attachments=allow_attachments,
- )
-
- system = data.get("system")
- if isinstance(system, list):
- _walk_block_list_for_unsupported(
- system, where="system", allow_attachments=allow_attachments
- )
-
-
-def _has_tool_history_blocks(message: Mapping[str, Any]) -> bool:
- role = message.get("role")
- content = message.get("content")
- if not isinstance(content, list):
- return False
-
- for block in content:
- if not isinstance(block, dict):
- continue
- btype = block.get("type")
- if role == "assistant" and btype == "tool_use":
- return True
- if role == "user" and btype == "tool_result":
- return True
- return False
-
-
-def _has_replayable_thinking_before_tool_use(message: Mapping[str, Any]) -> bool:
- if message.get("role") != "assistant":
- return False
- content = message.get("content")
- if not isinstance(content, list):
- return False
-
- has_thinking = isinstance(message.get("reasoning_content"), str)
- for block in content:
- if not isinstance(block, dict):
- continue
- btype = block.get("type")
- if btype == "thinking" and isinstance(block.get("thinking"), str):
- has_thinking = True
- continue
- if btype == "tool_use":
- return has_thinking
- return False
-
-
-def _assistant_has_tool_use(message: Mapping[str, Any]) -> bool:
- if message.get("role") != "assistant":
- return False
- content = message.get("content")
- return isinstance(content, list) and any(
- isinstance(block, dict) and block.get("type") == "tool_use" for block in content
- )
-
-
-def _has_tool_history(data: dict[str, Any]) -> bool:
- for message in data.get("messages") or ():
- if isinstance(message, Mapping) and _has_tool_history_blocks(message):
- return True
- return False
-
-
-def _all_tool_calls_have_replayable_thinking(data: dict[str, Any]) -> bool:
- found_tool_call = False
- for message in data.get("messages") or ():
- if not isinstance(message, Mapping) or not _assistant_has_tool_use(message):
- continue
- found_tool_call = True
- if not _has_replayable_thinking_before_tool_use(message):
- return False
- return found_tool_call
-
-
-def _remove_deepseek_thinking_hints(data: dict[str, Any]) -> None:
- output_config = data.get("output_config")
- if isinstance(output_config, dict) and "effort" in output_config:
- cleaned_output_config = dict(output_config)
- cleaned_output_config.pop("effort", None)
- if cleaned_output_config:
- data["output_config"] = cleaned_output_config
- else:
- data.pop("output_config", None)
-
- context_management = data.get("context_management")
- if not isinstance(context_management, dict):
- return
- edits = context_management.get("edits")
- if not isinstance(edits, list):
- return
- filtered_edits = [
- edit
- for edit in edits
- if not (
- isinstance(edit, dict)
- and isinstance(edit.get("type"), str)
- and edit["type"].startswith("clear_thinking_")
- )
- ]
- if len(filtered_edits) == len(edits):
- return
- cleaned_context_management = dict(context_management)
- if filtered_edits:
- cleaned_context_management["edits"] = filtered_edits
- data["context_management"] = cleaned_context_management
- else:
- cleaned_context_management.pop("edits", None)
- if cleaned_context_management:
- data["context_management"] = cleaned_context_management
- else:
- data.pop("context_management", None)
-
-
-def _normalize_tool_result_content(messages: Any) -> Any:
- if not isinstance(messages, list):
- return messages
-
- normalized: list[Any] = []
- for message in messages:
- if not isinstance(message, dict):
- normalized.append(message)
- continue
-
- content = message.get("content")
- if not isinstance(content, list):
- normalized.append(message)
- continue
-
- new_content: list[Any] = []
- for block in content:
- if not isinstance(block, dict):
- new_content.append(block)
- continue
-
- if block.get("type") == "tool_result":
- normalized_block = dict(block)
- normalized_block["content"] = serialize_tool_result_content(
- block.get("content")
+ if isinstance(content, ImageContent) and not vision_capable:
+ raise InvalidRequestError(
+ "The selected DeepSeek model does not support image content."
)
- new_content.append(normalized_block)
- else:
- new_content.append(block)
- new_msg = dict(message)
- new_msg["content"] = new_content
- normalized.append(new_msg)
- return normalized
+def _has_tool_history(request: InferenceRequest) -> bool:
+ return any(isinstance(item, ToolCallItem) for item in request.items)
-def _downgrade_forced_tool_choice(data: dict[str, Any]) -> None:
- tool_choice = data.get("tool_choice")
- if not isinstance(tool_choice, dict):
- return
- if tool_choice.get("type") != "tool" or not isinstance(
- tool_choice.get("name"), str
- ):
- return
- logger.debug(
- "DEEPSEEK_REQUEST: downgrading forced tool_choice to auto for unsupported "
- "native request shape tool={}",
- tool_choice["name"],
- )
- data["tool_choice"] = {"type": "auto"}
+def _all_tool_calls_have_replayable_reasoning(request: InferenceRequest) -> bool:
+ reasoning_turns = {
+ item.turn_id for item in request.items if isinstance(item, ReasoningItem)
+ }
+ tool_turns = {
+ item.turn_id for item in request.items if isinstance(item, ToolCallItem)
+ }
+ return bool(tool_turns) and tool_turns <= reasoning_turns
def _apply_deepseek_chat_extras(
- body: dict[str, Any], _request_data: MessagesRequest, policy: ReasoningPolicy
+ body: JsonObject,
+ _request: InferenceRequest,
+ policy: ReasoningPolicy,
) -> None:
- extra_body = body.setdefault("extra_body", {})
- if not isinstance(extra_body, dict):
- return
+ messages = body.get("messages")
+ if isinstance(messages, list):
+ for message in messages:
+ if (
+ isinstance(message, dict)
+ and message.get("role") == "assistant"
+ and not message.get("tool_calls")
+ ):
+ message.pop("reasoning_content", None)
+
+ raw_extra = body.setdefault("extra_body", {})
+ if not isinstance(raw_extra, dict):
+ raise InvalidRequestError("DeepSeek extra_body must be an object.")
if policy.control is ReasoningControl.OFF:
- extra_body["thinking"] = {"type": "disabled"}
+ raw_extra["thinking"] = {"type": "disabled"}
return
if policy.effort in {ReasoningEffort.XHIGH, ReasoningEffort.MAX}:
body["reasoning_effort"] = "max"
elif policy.effort is not None:
body["reasoning_effort"] = "high"
elif policy.requests_reasoning:
- extra_body["thinking"] = {"type": "enabled"}
+ raw_extra["thinking"] = {"type": "enabled"}
diff --git a/src/free_claude_code/providers/gemini/client.py b/src/free_claude_code/providers/gemini/client.py
index 1dee808d..0e426292 100644
--- a/src/free_claude_code/providers/gemini/client.py
+++ b/src/free_claude_code/providers/gemini/client.py
@@ -1,6 +1,5 @@
"""Google AI Studio Gemini provider (OpenAI-compatible chat completions)."""
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.google_openai import (
@@ -11,6 +10,7 @@ from free_claude_code.providers.google_openai import (
from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
)
_REQUEST_POLICY = OpenAIChatRequestPolicy(
diff --git a/src/free_claude_code/providers/github_models/client.py b/src/free_claude_code/providers/github_models/client.py
index 639d3fd9..c10724a1 100644
--- a/src/free_claude_code/providers/github_models/client.py
+++ b/src/free_claude_code/providers/github_models/client.py
@@ -6,7 +6,6 @@ from typing import Any
import httpx
from free_claude_code.application.model_metadata import ProviderModelInfo
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.providers.admission import (
ProviderAdmissionController,
ProviderOperationKind,
@@ -22,6 +21,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
)
GITHUB_MODELS_CATALOG_URL = "https://models.github.ai/catalog/models"
diff --git a/src/free_claude_code/providers/google_openai/provider.py b/src/free_claude_code/providers/google_openai/provider.py
index 09a71fe8..661370d7 100644
--- a/src/free_claude_code/providers/google_openai/provider.py
+++ b/src/free_claude_code/providers/google_openai/provider.py
@@ -4,7 +4,7 @@ from collections.abc import Mapping
from copy import deepcopy
from typing import Any
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import (
DEFAULT_REASONING_POLICY,
ReasoningPolicy,
@@ -17,6 +17,10 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProvider,
build_openai_chat_request_body,
)
+from free_claude_code.providers.openai_compat import (
+ OpenAIToolNameCodec,
+ openai_replay_scope,
+)
from .thought_signatures import apply_google_thought_signatures
@@ -59,14 +63,22 @@ class GoogleOpenAIProvider(OpenAIChatProvider):
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict[str, Any]:
return build_openai_chat_request_body(
request,
+ provider_model=provider_model,
reasoning=reasoning,
policy=self._profile.request_policy,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=openai_replay_scope(
+ self._provider_name,
+ provider_model,
+ replay_format="chat-completions",
+ ),
postprocessors=(
lambda body, _request_data, _policy: apply_google_thought_signatures(
body,
diff --git a/src/free_claude_code/providers/groq/client.py b/src/free_claude_code/providers/groq/client.py
index 83aa9973..319f0e46 100644
--- a/src/free_claude_code/providers/groq/client.py
+++ b/src/free_claude_code/providers/groq/client.py
@@ -9,8 +9,7 @@ from typing import Any
import openai
from loguru import logger
-from free_claude_code.core.anthropic import ReasoningReplayMode
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import (
DEFAULT_REASONING_POLICY,
ReasoningEffort,
@@ -23,6 +22,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
validate_extra_body_does_not_override_reasoning_fields,
)
@@ -99,11 +99,16 @@ class GroqProvider(OpenAIChatProvider):
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict[str, Any]:
- body = super()._build_request_body(request, reasoning=reasoning)
+ body = super()._build_request_body(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ )
model = body.get("model")
if not isinstance(model, str):
return body
diff --git a/src/free_claude_code/providers/kilo/client.py b/src/free_claude_code/providers/kilo/client.py
index 86a9ccbc..3eacb5f2 100644
--- a/src/free_claude_code/providers/kilo/client.py
+++ b/src/free_claude_code/providers/kilo/client.py
@@ -1,7 +1,6 @@
"""Kilo.ai provider implementation."""
from free_claude_code.application.model_metadata import ProviderModelInfo
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.core.reasoning import ReasoningEffort
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
@@ -10,7 +9,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProvider,
OpenAIChatRequestPolicy,
ReasoningObject,
- apply_reasoning_details_replay,
+ ReasoningReplayMode,
validate_extra_body_does_not_override_canonical_fields,
)
@@ -24,7 +23,6 @@ _PROFILE = OpenAIChatProfile(
extra_body_validator=validate_extra_body_does_not_override_canonical_fields,
),
ReasoningObject(tuple((effort, effort.value) for effort in ReasoningEffort)),
- postprocessors=(apply_reasoning_details_replay,),
reasoning_delta_field="reasoning",
structured_reasoning_details=True,
)
diff --git a/src/free_claude_code/providers/lmstudio/client.py b/src/free_claude_code/providers/lmstudio/client.py
index c2e83fda..4a2c5f2f 100644
--- a/src/free_claude_code/providers/lmstudio/client.py
+++ b/src/free_claude_code/providers/lmstudio/client.py
@@ -16,8 +16,7 @@ import time
import httpx
from loguru import logger
-from free_claude_code.core.anthropic import ReasoningReplayMode, get_token_count
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest, get_inference_token_count
from free_claude_code.core.reasoning import (
DEFAULT_REASONING_POLICY,
ReasoningEffort,
@@ -33,6 +32,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
)
_PROFILE = OpenAIChatProfile(
@@ -78,22 +78,23 @@ class LMStudioProvider(OpenAIChatProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
- super().preflight_stream(request, reasoning=reasoning)
+ super().preflight_stream(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ )
self._preflight_context_budget(request)
- def _preflight_context_budget(self, request: MessagesRequest) -> None:
+ def _preflight_context_budget(self, request: InferenceRequest) -> None:
loaded_context = self._loaded_context_length()
if loaded_context is None:
return
- estimate = get_token_count(
- request.messages,
- request.system,
- request.tools,
- )
+ estimate = get_inference_token_count(request)
# The estimate is cl100k-based and undercounts local tokenizers
# (observed ~8% low vs devstral); a request above 90% of the loaded
# context is already past where client-side compaction should have
diff --git a/src/free_claude_code/providers/mistral/client.py b/src/free_claude_code/providers/mistral/client.py
index d0e7b93e..7790ca93 100644
--- a/src/free_claude_code/providers/mistral/client.py
+++ b/src/free_claude_code/providers/mistral/client.py
@@ -5,8 +5,7 @@ from typing import Any
from loguru import logger
-from free_claude_code.core.anthropic import ReasoningReplayMode
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
@@ -15,7 +14,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
- build_openai_chat_request_body,
+ ReasoningReplayMode,
)
from .reasoning import (
@@ -46,14 +45,15 @@ class MistralProvider(OpenAIChatProvider):
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict:
- body = build_openai_chat_request_body(
+ body = super()._build_request_body(
request,
+ provider_model=provider_model,
reasoning=reasoning,
- policy=_REQUEST_POLICY,
)
apply_mistral_reasoning_request_shape(body, reasoning=reasoning)
return body
diff --git a/src/free_claude_code/providers/nvidia_nim/client.py b/src/free_claude_code/providers/nvidia_nim/client.py
index a658540c..51f3c596 100644
--- a/src/free_claude_code/providers/nvidia_nim/client.py
+++ b/src/free_claude_code/providers/nvidia_nim/client.py
@@ -9,8 +9,8 @@ import openai
from loguru import logger
from free_claude_code.config.nim import NimSettings
-from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.failures import ExecutionFailure
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
@@ -66,14 +66,16 @@ class NvidiaNimProvider(OpenAIChatProvider):
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict:
"""Internal helper for tests and shared building."""
return build_nim_request_body(
request,
self._nim_settings,
+ provider_model=provider_model,
reasoning=reasoning,
)
diff --git a/src/free_claude_code/providers/nvidia_nim/request_options.py b/src/free_claude_code/providers/nvidia_nim/request_options.py
index bbc4894d..c3d2ac65 100644
--- a/src/free_claude_code/providers/nvidia_nim/request_options.py
+++ b/src/free_claude_code/providers/nvidia_nim/request_options.py
@@ -1,33 +1,48 @@
"""NVIDIA NIM request option injection."""
-from copy import deepcopy
from typing import Any
from free_claude_code.config.nim import NimSettings
-from free_claude_code.core.anthropic import ReasoningReplayMode, set_if_not_none
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest, thaw_json_object
from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
from free_claude_code.providers.openai_chat import (
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
build_openai_chat_request_body,
)
+from free_claude_code.providers.openai_compat import (
+ OpenAIToolNameCodec,
+ openai_replay_scope,
+)
from .tool_schema import sanitize_nim_tool_schemas
NIM_REQUEST_POLICY = OpenAIChatRequestPolicy(
provider_name="NIM",
reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
+ postprocessor_consumes_extra_body=True,
)
def build_nim_request_body(
- request_data: MessagesRequest, nim: NimSettings, *, reasoning: ReasoningPolicy
+ request_data: InferenceRequest,
+ nim: NimSettings,
+ *,
+ provider_model: str,
+ reasoning: ReasoningPolicy,
) -> dict[str, Any]:
- """Build OpenAI-format request body from Anthropic request plus NIM settings."""
+ """Build an OpenAI-format body from canonical input plus NIM settings."""
return build_openai_chat_request_body(
request_data,
+ provider_model=provider_model,
reasoning=reasoning,
policy=NIM_REQUEST_POLICY,
+ tool_names=OpenAIToolNameCodec.from_request(request_data),
+ replay_scope=openai_replay_scope(
+ "NIM",
+ provider_model,
+ replay_format="chat-completions",
+ ),
postprocessors=(
lambda body, request, policy: apply_nim_request_options(
body,
@@ -41,7 +56,7 @@ def build_nim_request_body(
def apply_nim_request_options(
body: dict[str, Any],
- request_data: MessagesRequest,
+ request_data: InferenceRequest,
reasoning: ReasoningPolicy,
*,
nim: NimSettings,
@@ -49,12 +64,13 @@ def apply_nim_request_options(
"""Apply NIM schema repairs and configured request defaults."""
sanitize_nim_tool_schemas(body)
- max_tokens = body.get("max_tokens") or request_data.max_tokens
+ max_tokens = body.get("max_tokens") or request_data.max_output_tokens
if max_tokens is None:
max_tokens = nim.max_tokens
elif nim.max_tokens:
max_tokens = min(max_tokens, nim.max_tokens)
- set_if_not_none(body, "max_tokens", max_tokens)
+ if max_tokens is not None:
+ body["max_tokens"] = max_tokens
if body.get("temperature") is None and nim.temperature is not None:
body["temperature"] = nim.temperature
@@ -73,9 +89,9 @@ def apply_nim_request_options(
body["parallel_tool_calls"] = nim.parallel_tool_calls
extra_body: dict[str, Any] = {}
- request_extra = request_data.extra_body
- if request_extra:
- extra_body.update(deepcopy(request_extra))
+ extension = request_data.openai_chat_extension
+ if extension is not None:
+ extra_body.update(thaw_json_object(extension.extra_body))
for key in (
"reasoning",
"reasoning_budget",
diff --git a/src/free_claude_code/providers/open_router/client.py b/src/free_claude_code/providers/open_router/client.py
index 7410f4cb..60d98042 100644
--- a/src/free_claude_code/providers/open_router/client.py
+++ b/src/free_claude_code/providers/open_router/client.py
@@ -2,7 +2,6 @@
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.core.reasoning import ReasoningEffort
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
@@ -12,7 +11,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProvider,
OpenAIChatRequestPolicy,
ReasoningObject,
- apply_reasoning_details_replay,
+ ReasoningReplayMode,
validate_extra_body_does_not_override_canonical_fields,
)
@@ -48,6 +47,5 @@ class OpenRouterProvider(OpenAIChatProvider):
_PROFILE = OpenAIChatProfile(
_REQUEST_POLICY,
ReasoningObject(tuple((effort, effort.value) for effort in ReasoningEffort)),
- postprocessors=(apply_reasoning_details_replay,),
structured_reasoning_details=True,
)
diff --git a/src/free_claude_code/providers/openai_chat/__init__.py b/src/free_claude_code/providers/openai_chat/__init__.py
index fcf8b146..6cd2f6ef 100644
--- a/src/free_claude_code/providers/openai_chat/__init__.py
+++ b/src/free_claude_code/providers/openai_chat/__init__.py
@@ -16,7 +16,7 @@ from .reasoning import (
NamedEffortReasoning,
ReasoningObject,
)
-from .reasoning_details import apply_reasoning_details_replay
+from .request_codec import ReasoningReplayMode
from .request_policy import OpenAIChatRequestPolicy, build_openai_chat_request_body
from .usage import usage_int
@@ -50,7 +50,7 @@ __all__ = [
"OpenAIChatProvider",
"OpenAIChatRequestPolicy",
"ReasoningObject",
- "apply_reasoning_details_replay",
+ "ReasoningReplayMode",
"build_openai_chat_request_body",
"create_openai_chat_provider",
"openai_v1_base_url",
diff --git a/src/free_claude_code/providers/openai_chat/function_tags.py b/src/free_claude_code/providers/openai_chat/function_tags.py
new file mode 100644
index 00000000..dfa32ff1
--- /dev/null
+++ b/src/free_claude_code/providers/openai_chat/function_tags.py
@@ -0,0 +1,261 @@
+"""Parse exact OpenAI-compatible function-tag tool envelopes."""
+
+import uuid
+from collections.abc import Mapping
+from dataclasses import dataclass
+from enum import Enum
+from typing import cast
+
+from free_claude_code.core.anthropic.tool_schema import (
+ arguments_match_schema,
+ coerce_text_argument,
+)
+from free_claude_code.core.inference import (
+ FunctionTool,
+ InferenceRequest,
+ ToolChoiceMode,
+ thaw_json_object,
+)
+from free_claude_code.core.json_types import JsonObject, JsonValue
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+
+_FUNCTION_TAG_BLOCK_START = "<tool_call>"
+_FUNCTION_TAG_BLOCK_END = "</tool_call>"
+_FUNCTION_TAG_START = "<function="
+_FUNCTION_TAG_END = "</function>"
+_PARAMETER_TAG_START = "<parameter="
+_PARAMETER_TAG_END = "</parameter>"
+_MAX_FUNCTION_TAG_CANDIDATE_CHARS = 4 * 1024 * 1024
+
+
+@dataclass(frozen=True, slots=True)
+class _RawFunctionTagCall:
+ name: str
+ arguments: dict[str, str]
+
+
+class _FunctionTagState(Enum):
+ SEARCHING = 1
+ CANDIDATE = 2
+ DISABLED = 3
+ FINISHED = 4
+
+
+class FunctionTagToolParser:
+ """Parse an exact terminal function-tag envelope into tool use."""
+
+ def __init__(self, request: InferenceRequest):
+ self._tool_names = OpenAIToolNameCodec.from_request(request)
+ self._schemas = {
+ tool.name: thaw_json_object(tool.input_schema)
+ for tool in request.tools
+ if isinstance(tool, FunctionTool)
+ }
+ tool_choice_disabled = (
+ request.tool_choice is not None
+ and request.tool_choice.mode is ToolChoiceMode.NONE
+ )
+ self._state = (
+ _FunctionTagState.SEARCHING
+ if self._schemas and not tool_choice_disabled
+ else _FunctionTagState.DISABLED
+ )
+ self._parts: list[str] = []
+ self._length = 0
+ self._marker_tail = ""
+
+ def feed(self, text: str) -> str:
+ """Hold a possible reserved response and return text safe to expose."""
+ if not text:
+ return ""
+ if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:
+ return text
+
+ if self._state is _FunctionTagState.CANDIDATE:
+ self._parts.append(text)
+ self._length += len(text)
+ if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:
+ return self.disable()
+ return ""
+
+ candidate = "".join((self._marker_tail, text))
+ marker_index = candidate.find(_FUNCTION_TAG_BLOCK_START)
+ if marker_index >= 0:
+ visible = candidate[:marker_index]
+ control = candidate[marker_index:]
+ self._state = _FunctionTagState.CANDIDATE
+ self._marker_tail = ""
+ self._parts.append(control)
+ self._length = len(control)
+ if self._length > _MAX_FUNCTION_TAG_CANDIDATE_CHARS:
+ return "".join((visible, self.disable()))
+ return visible
+
+ held_length = _partial_function_tag_marker_suffix_length(candidate)
+ if held_length:
+ self._marker_tail = candidate[-held_length:]
+ return candidate[:-held_length]
+ self._marker_tail = ""
+ return candidate
+
+ def disable(self) -> str:
+ """Disable textual recovery and release any held candidate unchanged."""
+ if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:
+ return ""
+ self._state = _FunctionTagState.DISABLED
+ text = "".join((self._marker_tail, *self._parts))
+ self._marker_tail = ""
+ self._parts.clear()
+ self._length = 0
+ return text
+
+ def finish(self) -> tuple[str, tuple[JsonObject, ...]]:
+ """Finalize one response atomically as visible text or validated tools."""
+ if self._state in {_FunctionTagState.DISABLED, _FunctionTagState.FINISHED}:
+ return "", ()
+ if self._state is _FunctionTagState.SEARCHING:
+ self._state = _FunctionTagState.FINISHED
+ text = self._marker_tail
+ self._marker_tail = ""
+ return text, ()
+ self._state = _FunctionTagState.FINISHED
+ raw = "".join(self._parts)
+ self._parts.clear()
+ self._length = 0
+ try:
+ calls = _parse_function_tag_calls(raw)
+ tool_uses = self._validated_tool_uses(calls)
+ except ValueError:
+ return raw, ()
+ return "", tool_uses
+
+ def _validated_tool_uses(
+ self, calls: tuple[_RawFunctionTagCall, ...]
+ ) -> tuple[JsonObject, ...]:
+ tool_uses: list[JsonObject] = []
+ for call in calls:
+ name = self._tool_names.decode(call.name)
+ schema = self._schemas.get(name)
+ if schema is None:
+ raise ValueError
+ properties = schema.get("properties")
+ property_schemas = properties if isinstance(properties, Mapping) else {}
+ additional = schema.get("additionalProperties")
+ arguments: JsonObject = {}
+ for parameter_name, value in call.arguments.items():
+ parameter_schema = property_schemas.get(parameter_name)
+ if not isinstance(parameter_schema, Mapping):
+ parameter_schema = (
+ additional if isinstance(additional, Mapping) else {}
+ )
+ arguments[parameter_name] = cast(
+ JsonValue,
+ coerce_text_argument(value, parameter_schema),
+ )
+ if not arguments_match_schema(arguments, schema):
+ raise ValueError
+ tool_use: JsonObject = {
+ "type": "tool_use",
+ "id": f"toolu_function_tag_{uuid.uuid4().hex[:8]}",
+ "name": name,
+ "input": arguments,
+ }
+ tool_uses.append(tool_use)
+ return tuple(tool_uses)
+
+
+def _parse_function_tag_calls(text: str) -> tuple[_RawFunctionTagCall, ...]:
+ cursor = 0
+ calls: list[_RawFunctionTagCall] = []
+ while True:
+ cursor = _skip_function_tag_whitespace(text, cursor)
+ if cursor == len(text):
+ break
+ if not text.startswith(_FUNCTION_TAG_BLOCK_START, cursor):
+ raise ValueError
+
+ block_start = cursor + len(_FUNCTION_TAG_BLOCK_START)
+ block_end = text.find(_FUNCTION_TAG_BLOCK_END, block_start)
+ if block_end < 0:
+ raise ValueError
+ name, arguments = _parse_function_tag_block(text[block_start:block_end])
+ calls.append(_RawFunctionTagCall(name=name, arguments=arguments))
+ cursor = block_end + len(_FUNCTION_TAG_BLOCK_END)
+
+ if not calls:
+ raise ValueError
+ return tuple(calls)
+
+
+def _parse_function_tag_block(block: str) -> tuple[str, dict[str, str]]:
+ cursor = _skip_function_tag_whitespace(block, 0)
+ if not block.startswith(_FUNCTION_TAG_START, cursor):
+ raise ValueError
+ name_end = block.find(">", cursor + len(_FUNCTION_TAG_START))
+ if name_end < 0:
+ raise ValueError
+ name = block[cursor + len(_FUNCTION_TAG_START) : name_end]
+ if not _valid_function_tag_name(name):
+ raise ValueError
+
+ arguments: dict[str, str] = {}
+ cursor = name_end + 1
+ while True:
+ cursor = _skip_function_tag_whitespace(block, cursor)
+ if block.startswith(_FUNCTION_TAG_END, cursor):
+ cursor += len(_FUNCTION_TAG_END)
+ break
+ if cursor == len(block) or not block.startswith(_PARAMETER_TAG_START, cursor):
+ raise ValueError
+
+ parameter_name_end = block.find(">", cursor + len(_PARAMETER_TAG_START))
+ if parameter_name_end < 0:
+ raise ValueError
+ parameter_name = block[cursor + len(_PARAMETER_TAG_START) : parameter_name_end]
+ if not _valid_function_tag_name(parameter_name) or parameter_name in arguments:
+ raise ValueError
+
+ value_start = parameter_name_end + 1
+ value_end = block.find(_PARAMETER_TAG_END, value_start)
+ if value_end < 0:
+ raise ValueError
+ arguments[parameter_name] = _unwrap_function_tag_newlines(
+ block[value_start:value_end]
+ )
+ cursor = value_end + len(_PARAMETER_TAG_END)
+
+ if block[cursor:].strip():
+ raise ValueError
+ return name, arguments
+
+
+def _skip_function_tag_whitespace(text: str, cursor: int) -> int:
+ while cursor < len(text) and text[cursor].isspace():
+ cursor += 1
+ return cursor
+
+
+def _valid_function_tag_name(value: str) -> bool:
+ return bool(value) and not any(
+ character.isspace() or character in "<>" for character in value
+ )
+
+
+def _unwrap_function_tag_newlines(value: str) -> str:
+ if value.startswith("\r\n"):
+ value = value[2:]
+ elif value.startswith("\n"):
+ value = value[1:]
+ if value.endswith("\r\n"):
+ return value[:-2]
+ if value.endswith("\n"):
+ return value[:-1]
+ return value
+
+
+def _partial_function_tag_marker_suffix_length(text: str) -> int:
+ max_length = min(len(text), len(_FUNCTION_TAG_BLOCK_START) - 1)
+ for length in range(max_length, 0, -1):
+ if _FUNCTION_TAG_BLOCK_START.startswith(text[-length:]):
+ return length
+ return 0
diff --git a/src/free_claude_code/providers/openai_chat/profiles.py b/src/free_claude_code/providers/openai_chat/profiles.py
index d40aa51a..ff0e7187 100644
--- a/src/free_claude_code/providers/openai_chat/profiles.py
+++ b/src/free_claude_code/providers/openai_chat/profiles.py
@@ -1,14 +1,13 @@
"""Declarative profiles for ordinary OpenAI-compatible providers."""
-from collections.abc import Mapping
from copy import deepcopy
from dataclasses import dataclass
from typing import Any, Literal
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from free_claude_code.core.anthropic import ReasoningReplayMode
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest, thaw_json_object
+from free_claude_code.core.json_types import JsonObject
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.model_listing import RequiredPathValues
@@ -27,7 +26,7 @@ from .reasoning import (
ReasoningObject,
ThinkingObjectReasoning,
)
-from .reasoning_details import apply_reasoning_details_replay
+from .request_codec import ReasoningReplayMode
from .request_policy import OpenAIChatPostprocessor, OpenAIChatRequestPolicy
_ALL_EFFORTS = tuple((effort, effort.value) for effort in ReasoningEffort)
@@ -137,8 +136,8 @@ class OpenAIChatProfile:
def apply_reasoning(
self,
- body: dict[str, Any],
- _request: MessagesRequest,
+ body: JsonObject,
+ _request: InferenceRequest,
policy: ReasoningPolicy,
) -> None:
self.reasoning.encode(body, policy)
@@ -149,9 +148,13 @@ class OpenAIChatProfile:
def _apply_cohere_request_quirks(
- body: dict[str, Any], request: MessagesRequest, _policy: ReasoningPolicy
+ body: JsonObject, request: InferenceRequest, _policy: ReasoningPolicy
) -> None:
- _merge_allowed_cohere_extra_body(body, request.extra_body)
+ extension = request.openai_chat_extension
+ _merge_allowed_cohere_extra_body(
+ body,
+ thaw_json_object(extension.extra_body) if extension is not None else None,
+ )
_COHERE_EXTRA_BODY_KEYS = frozenset(
@@ -164,11 +167,11 @@ _COHERE_EXTRA_BODY_KEYS = frozenset(
)
-def _merge_allowed_cohere_extra_body(body: dict[str, Any], extra_body: Any) -> None:
+def _merge_allowed_cohere_extra_body(
+ body: JsonObject, extra_body: JsonObject | None
+) -> None:
if extra_body in (None, {}):
return
- if not isinstance(extra_body, Mapping):
- raise InvalidRequestError("Cohere extra_body must be an object when provided.")
unsupported = sorted(
str(key) for key in extra_body if key not in _COHERE_EXTRA_BODY_KEYS
@@ -215,7 +218,6 @@ OPENAI_CHAT_PROFILES: dict[str, OpenAIChatProfile] = {
"cline_pass": OpenAIChatProfile(
_policy("CLINE_PASS", ReasoningReplayMode.DISABLED),
NO_REASONING,
- postprocessors=(apply_reasoning_details_replay,),
model_listing=OpenAIModelListing(
path="/ai/cline/recommended-models",
collection_field="clinePass",
@@ -383,7 +385,6 @@ OPENAI_CHAT_PROFILES: dict[str, OpenAIChatProfile] = {
max_tokens_field="max_completion_tokens",
),
ReasoningObject(_MINIMAL_TO_XHIGH),
- postprocessors=(apply_reasoning_details_replay,),
model_listing=OpenAIModelListing(
required_sequence_items=(
("input_modalities", "text"),
@@ -451,6 +452,7 @@ OPENAI_CHAT_PROFILES: dict[str, OpenAIChatProfile] = {
_policy(
"COHERE",
ReasoningReplayMode.REASONING_CONTENT,
+ postprocessor_consumes_extra_body=True,
strip_message_names=True,
unsupported_body_keys=frozenset(
{
diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.py
index c4837be3..a03737b4 100644
--- a/src/free_claude_code/providers/openai_chat/provider.py
+++ b/src/free_claude_code/providers/openai_chat/provider.py
@@ -15,27 +15,17 @@ from openai import AsyncOpenAI, DefaultAsyncHttpx2Client
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.core.anthropic import (
ContentType,
- FunctionTagToolParser,
HeuristicToolParser,
- OpenAIToolNameCodec,
ThinkTagParser,
)
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.streaming import (
- accept_tool_json_repair,
- continuation_suffix,
- make_response_recovery_body,
- make_text_recovery_body,
- make_tool_repair_body,
- parse_complete_tool_input,
- tool_schemas_by_name,
-)
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.core.inference import (
FinishReason,
InferenceEvent,
+ InferenceRequest,
InferenceStreamLedger,
InferenceUsage,
+ ReplayCompatibilityScope,
TokenMeasurement,
UsageSource,
)
@@ -66,6 +56,20 @@ from free_claude_code.providers.model_listing import (
model_infos_from_ids,
validate_model_list_page,
)
+from free_claude_code.providers.openai_chat.function_tags import FunctionTagToolParser
+from free_claude_code.providers.openai_chat.recovery import (
+ accept_tool_json_repair,
+ continuation_suffix,
+ make_response_recovery_body,
+ make_text_recovery_body,
+ make_tool_repair_body,
+ parse_complete_tool_input,
+ tool_schemas_by_name,
+)
+from free_claude_code.providers.openai_compat import (
+ OpenAIToolNameCodec,
+ openai_replay_scope,
+)
from free_claude_code.providers.stream_recovery import (
RecoveryController,
RecoveryFailureAction,
@@ -241,7 +245,7 @@ class _OpenAIChatStreamAssembler:
def __init__(
self,
*,
- request: MessagesRequest,
+ request: InferenceRequest,
ledger: InferenceStreamLedger,
profile: OpenAIChatProfile,
provider_name: str,
@@ -249,6 +253,7 @@ class _OpenAIChatStreamAssembler:
tool_names: OpenAIToolNameCodec,
tool_calls: OpenAIToolCallAssembler,
extra_reasoning_events: _ExtraReasoningEvents,
+ replay_scope: ReplayCompatibilityScope,
) -> None:
self._request = request
self._ledger = ledger
@@ -262,7 +267,7 @@ class _OpenAIChatStreamAssembler:
self._function_tag_parser = FunctionTagToolParser(request)
self._heuristic_parser = HeuristicToolParser()
self._structured_reasoning = (
- StructuredReasoningStream()
+ StructuredReasoningStream(replay_scope)
if profile.structured_reasoning_details
else None
)
@@ -474,6 +479,7 @@ class _OpenAIChatStreamAssembler:
yield from self._tool_calls.flush_tool_argument_alias_buffers(
self._ledger,
+ self._tool_names,
self._tool_argument_aliases,
self._tool_argument_alias_buffers,
)
@@ -664,26 +670,39 @@ class OpenAIChatProvider(BaseProvider):
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict[str, Any]:
"""Build a provider request from the immutable profile."""
return build_openai_chat_request_body(
request,
+ provider_model=provider_model,
reasoning=reasoning,
policy=self._profile.request_policy,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=openai_replay_scope(
+ self._provider_name,
+ provider_model,
+ replay_format="chat-completions",
+ ),
postprocessors=self._profile.request_postprocessors,
)
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
"""Validate OpenAI-chat request conversion before streaming."""
- self._build_request_body(request, reasoning=reasoning)
+ self._build_request_body(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ )
def _handle_extra_reasoning(
self, delta: Any, ledger: InferenceStreamLedger, *, output_reasoning: bool
@@ -836,9 +855,10 @@ class OpenAIChatProvider(BaseProvider):
def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
@@ -847,9 +867,10 @@ class OpenAIChatProvider(BaseProvider):
runner = _OpenAIChatStreamRunner(
self,
request=request,
+ provider_model=provider_model,
input_tokens=input_tokens,
request_id=request_id,
- response_model=response_model,
+ response_model=response_model or request.model,
reasoning=reasoning,
)
return runner.run()
@@ -862,24 +883,30 @@ class _OpenAIChatStreamRunner:
self,
provider: OpenAIChatProvider,
*,
- request: MessagesRequest,
+ request: InferenceRequest,
+ provider_model: str,
input_tokens: int,
request_id: str | None,
- response_model: str | None,
+ response_model: str,
reasoning: ReasoningPolicy,
) -> None:
self._provider = provider
self._request = request
+ self._provider_model = provider_model
self._input_tokens = input_tokens
self._request_id = request_id
- self._response_model = (
- request.model if response_model is None else response_model
- )
+ self._response_model = response_model
self._reasoning = reasoning
self._tool_names = OpenAIToolNameCodec.from_request(request)
+ self._replay_scope = openai_replay_scope(
+ provider._provider_name,
+ provider_model,
+ replay_format="chat-completions",
+ )
self._response_id = f"response_{uuid.uuid4().hex}"
self._tool_calls = OpenAIToolCallAssembler(
- record_extra_content=provider._record_tool_call_extra_content
+ record_extra_content=provider._record_tool_call_extra_content,
+ replay_scope=self._replay_scope,
)
async def run(self) -> AsyncIterator[InferenceEvent]:
@@ -916,6 +943,7 @@ class _OpenAIChatStreamRunner:
body = self._provider._build_request_body(
self._request,
+ provider_model=self._provider_model,
reasoning=self._reasoning,
)
request_stream_usage(body)
@@ -1334,7 +1362,13 @@ class _OpenAIChatStreamRunner:
if recovered.tool_calls:
events.extend(ledger.close_content_blocks())
for tool_call in recovered.tool_calls:
- events.extend(self._tool_calls.process_tool_call(tool_call, ledger))
+ events.extend(
+ self._tool_calls.process_tool_call(
+ tool_call,
+ ledger,
+ tool_names=self._tool_names,
+ )
+ )
if not events:
return None
events.extend(ledger.close_all_blocks())
@@ -1370,8 +1404,8 @@ class _OpenAIChatStreamRunner:
block = ledger.tool_block_for_tool_index(tool_index)
emitted_prefix = block.content if block is not None else ""
repair_prefix = emitted_prefix
- if not repair_prefix and state.name == "Task" and state.task_arg_buffer:
- repair_prefix = state.task_arg_buffer
+ if not repair_prefix and state.name == "Task":
+ repair_prefix = self._tool_calls.buffered_task_args(tool_index)
if not repair_prefix and tool_index in tool_argument_alias_buffers:
repair_prefix = tool_argument_alias_buffers[tool_index]
if (
@@ -1452,4 +1486,5 @@ class _OpenAIChatStreamRunner:
tool_names=self._tool_names,
tool_calls=self._tool_calls,
extra_reasoning_events=extra_reasoning_events,
+ replay_scope=self._replay_scope,
)
diff --git a/src/free_claude_code/providers/openai_chat/reasoning_details.py b/src/free_claude_code/providers/openai_chat/reasoning_details.py
index 2e2e5635..fffeffe6 100644
--- a/src/free_claude_code/providers/openai_chat/reasoning_details.py
+++ b/src/free_claude_code/providers/openai_chat/reasoning_details.py
@@ -4,10 +4,6 @@ import json
from collections.abc import Iterator, Mapping, Sequence
from typing import Any, Literal
-from free_claude_code.core.anthropic import (
- is_synthetic_openai_tool_turn_boundary,
-)
-from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.inference import (
InferenceEvent,
InferenceStreamLedger,
@@ -15,45 +11,16 @@ from free_claude_code.core.inference import (
ReplayArtifactKind,
ReplayArtifactOrigin,
ReplayAttachment,
+ ReplayCompatibilityScope,
)
-from free_claude_code.core.reasoning import ReasoningPolicy
-
-
-def apply_reasoning_details_replay(
- body: dict[str, Any], request: MessagesRequest, _policy: ReasoningPolicy
-) -> None:
- """Replay opaque reasoning details on their converted assistant messages."""
- assistant_details = _assistant_reasoning_details(request.messages)
- if not assistant_details:
- return
- messages = body.get("messages")
- if not isinstance(messages, list):
- return
-
- cursor = 0
- for details in assistant_details:
- for index in range(cursor, len(messages)):
- message = messages[index]
- if (
- not isinstance(message, dict)
- or message.get("role") != "assistant"
- or is_synthetic_openai_tool_turn_boundary(message)
- ):
- continue
- existing = message.get("reasoning_details")
- if isinstance(existing, list):
- existing.extend(details)
- else:
- message["reasoning_details"] = list(details)
- cursor = index + 1
- break
class StructuredReasoningStream:
"""Reconcile alternate plaintext reasoning representations for one stream."""
- def __init__(self) -> None:
+ def __init__(self, replay_scope: ReplayCompatibilityScope) -> None:
self._text_source: Literal["native", "details"] | None = None
+ self._replay_scope = replay_scope
def events(
self,
@@ -89,6 +56,7 @@ class StructuredReasoningStream:
kind=ReplayArtifactKind.REASONING_DETAILS,
attachment=ReplayAttachment.REASONING,
payload=preserved,
+ scope=self._replay_scope,
)
)
@@ -102,39 +70,6 @@ def _reasoning_details(delta: Any) -> Sequence[Any]:
return details if _is_sequence(details) else ()
-def _assistant_reasoning_details(messages: Any) -> list[list[dict[str, Any]]]:
- if not _is_sequence(messages):
- return []
- result: list[list[dict[str, Any]]] = []
- for message in messages:
- if _field(message, "role") != "assistant":
- continue
- details = _redacted_reasoning_details(_field(message, "content"))
- if details:
- result.append(details)
- return result
-
-
-def _redacted_reasoning_details(content: Any) -> list[dict[str, Any]]:
- if not _is_sequence(content):
- return []
- details: list[dict[str, Any]] = []
- for block in content:
- if _field(block, "type") != "redacted_thinking":
- continue
- data = _field(block, "data")
- if not isinstance(data, str) or not data:
- continue
- parsed = _json_payload(data)
- if isinstance(parsed, list):
- details.extend(item for item in parsed if isinstance(item, dict))
- elif isinstance(parsed, dict):
- details.append(parsed)
- else:
- details.append({"type": "reasoning.encrypted", "data": data})
- return details
-
-
def _reasoning_detail_text(detail: Any) -> str | None:
kind = str(_field(detail, "type") or "").lower()
if "encrypted" in kind or "redacted" in kind:
@@ -162,13 +97,6 @@ def _preserved_reasoning_detail(detail: Any) -> str | None:
return None
-def _json_payload(value: str) -> Any:
- try:
- return json.loads(value)
- except json.JSONDecodeError:
- return None
-
-
def _field(item: Any, name: str) -> Any:
if isinstance(item, Mapping):
return item.get(name)
diff --git a/src/free_claude_code/core/anthropic/streaming/recovery.py b/src/free_claude_code/providers/openai_chat/recovery.py
similarity index 91%
rename from src/free_claude_code/core/anthropic/streaming/recovery.py
rename to src/free_claude_code/providers/openai_chat/recovery.py
index 68143304..79383479 100644
--- a/src/free_claude_code/core/anthropic/streaming/recovery.py
+++ b/src/free_claude_code/providers/openai_chat/recovery.py
@@ -1,4 +1,4 @@
-"""Pure Anthropic continuation and tool-repair transformations."""
+"""OpenAI Chat continuation and tool-repair transformations."""
import json
from copy import deepcopy
@@ -8,7 +8,11 @@ from typing import Any
import jsonschema
from loguru import logger
-from ..models import MessagesRequest
+from free_claude_code.core.inference import (
+ FunctionTool,
+ InferenceRequest,
+ thaw_json_object,
+)
_RECOVERY_USER_PREFIX = (
"The previous provider stream was interrupted. Continue the assistant response "
@@ -21,7 +25,7 @@ _RECOVERY_THINKING_PREFIX = (
@dataclass(frozen=True, slots=True)
class ToolSchema:
- """Tool schema resolved from the original Anthropic request."""
+ """Tool schema resolved from the original canonical request."""
name: str
input_schema: dict[str, Any]
@@ -35,20 +39,16 @@ class ToolRepair:
parsed_input: dict[str, Any]
-def tool_schemas_by_name(request: MessagesRequest) -> dict[str, ToolSchema]:
- """Return Anthropic tool input schemas keyed by tool name."""
+def tool_schemas_by_name(request: InferenceRequest) -> dict[str, ToolSchema]:
+ """Return canonical function-tool schemas keyed by tool name."""
schemas: dict[str, ToolSchema] = {}
- tools = request.tools
- if not tools:
- return schemas
-
- for tool in tools:
+ for tool in request.tools:
+ if not isinstance(tool, FunctionTool):
+ continue
name = tool.name
if not name:
continue
- schema = tool.input_schema
- if schema is None:
- schema = {"type": "object"}
+ schema = thaw_json_object(tool.input_schema)
schemas[name] = ToolSchema(name=name, input_schema=deepcopy(schema))
return schemas
diff --git a/src/free_claude_code/providers/openai_chat/request_codec.py b/src/free_claude_code/providers/openai_chat/request_codec.py
new file mode 100644
index 00000000..62129698
--- /dev/null
+++ b/src/free_claude_code/providers/openai_chat/request_codec.py
@@ -0,0 +1,747 @@
+"""Encode canonical inference requests as OpenAI Chat Completions bodies."""
+
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import cast
+
+from free_claude_code.core.inference import (
+ Base64MediaSource,
+ CacheControl,
+ CustomTool,
+ DocumentContent,
+ FunctionTool,
+ ImageContent,
+ InferenceItem,
+ InferenceRequest,
+ InstructionItem,
+ InstructionPlacement,
+ MessageItem,
+ MessageRole,
+ ReasoningItem,
+ RefusalContent,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayCompatibilityScope,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoiceMode,
+ ToolResultItem,
+ UrlMediaSource,
+ thaw_json,
+ thaw_json_object,
+)
+from free_claude_code.core.json_types import JsonObject, JsonValue
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+
+
+class OpenAIConversionError(ValueError):
+ """Canonical content cannot be represented by OpenAI Chat without loss."""
+
+
+class ReasoningReplayMode(StrEnum):
+ """How visible assistant reasoning is replayed to a Chat provider."""
+
+ DISABLED = "disabled"
+ THINK_TAGS = "think_tags"
+ REASONING_CONTENT = "reasoning_content"
+ REASONING = "reasoning"
+
+
+@dataclass(slots=True)
+class _PlainSegment:
+ messages: list[JsonObject]
+
+
+@dataclass(slots=True)
+class _ToolTurnSegment:
+ assistant_message: JsonObject
+ required_tool_ids: list[str]
+ deferred_items: list[InferenceItem] = field(default_factory=list)
+ reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS
+ replay_scope: ReplayCompatibilityScope | None = None
+ assistant_emitted: bool = False
+
+
+type _TranscriptSegment = _PlainSegment | _ToolTurnSegment
+
+
+class _SyntheticOpenAIToolTurnBoundary(dict[str, JsonValue]):
+ __slots__ = ()
+
+
+def is_synthetic_openai_tool_turn_boundary(message: object) -> bool:
+ """Return whether FCC inserted a harmless assistant tool-turn boundary."""
+
+ return isinstance(message, _SyntheticOpenAIToolTurnBoundary)
+
+
+class _OpenAIChatHistoryLedger:
+ """Emit tool calls before their results without reordering later content."""
+
+ def __init__(
+ self,
+ *,
+ tool_names: OpenAIToolNameCodec,
+ ) -> None:
+ self._tool_names = tool_names
+ self._output: list[JsonObject] = []
+ self._segments: list[_TranscriptSegment] = []
+ self._tool_results: dict[str, JsonObject] = {}
+
+ def add_plain(self, messages: list[JsonObject]) -> None:
+ if messages:
+ self._segments.append(_PlainSegment(messages))
+ self._drain_ready_segments()
+
+ def add_tool_turn(self, segment: _ToolTurnSegment) -> None:
+ self._segments.append(segment)
+ self._drain_ready_segments()
+
+ def add_user_turn(self, items: list[InferenceItem]) -> None:
+ visible: list[MessageItem] = []
+
+ def flush_visible() -> None:
+ if visible:
+ self.add_plain(_user_messages(visible))
+ visible.clear()
+
+ for item in items:
+ if isinstance(item, MessageItem):
+ visible.append(item)
+ elif isinstance(item, ToolResultItem):
+ flush_visible()
+ self._record_tool_result(item)
+ else:
+ raise OpenAIConversionError(
+ f"user turn contains unsupported {type(item).__name__}"
+ )
+ flush_visible()
+ self._drain_ready_segments()
+
+ def finish(self) -> list[JsonObject]:
+ self._drain_ready_segments()
+ missing = self._missing_required_tool_ids()
+ if missing:
+ raise OpenAIConversionError(
+ "OpenAI Chat cannot replay incomplete tool history; missing "
+ f"tool results for call IDs: {missing}"
+ )
+ while self._segments:
+ segment = self._segments.pop(0)
+ if isinstance(segment, _PlainSegment):
+ self._output.extend(segment.messages)
+ else:
+ self._emit_tool_turn(segment)
+ return _coalesce_user_messages(_close_tool_result_turns(self._output))
+
+ def _record_tool_result(self, item: ToolResultItem) -> None:
+ message: JsonObject = {
+ "role": "tool",
+ "tool_call_id": item.call_id,
+ "content": serialize_tool_result_content(item.content),
+ }
+ if self._has_pending_tool_id(item.call_id):
+ self._tool_results[item.call_id] = message
+ else:
+ self.add_plain([message])
+
+ def _drain_ready_segments(self) -> None:
+ while self._segments:
+ segment = self._segments[0]
+ if isinstance(segment, _PlainSegment):
+ self._output.extend(segment.messages)
+ self._segments.pop(0)
+ continue
+ if not segment.assistant_emitted:
+ self._output.append(segment.assistant_message)
+ segment.assistant_emitted = True
+ if any(
+ call_id not in self._tool_results
+ for call_id in segment.required_tool_ids
+ ):
+ break
+ self._segments.pop(0)
+ for call_id in segment.required_tool_ids:
+ self._output.append(self._tool_results.pop(call_id))
+ self._output.extend(
+ _assistant_messages(
+ segment.deferred_items,
+ reasoning_replay=segment.reasoning_replay,
+ replay_scope=segment.replay_scope,
+ )
+ )
+
+ def _emit_tool_turn(self, segment: _ToolTurnSegment) -> None:
+ if not segment.assistant_emitted:
+ self._output.append(segment.assistant_message)
+ for call_id in segment.required_tool_ids:
+ result = self._tool_results.pop(call_id, None)
+ if result is not None:
+ self._output.append(result)
+ self._output.extend(
+ _assistant_messages(
+ segment.deferred_items,
+ reasoning_replay=segment.reasoning_replay,
+ replay_scope=segment.replay_scope,
+ )
+ )
+
+ def _missing_required_tool_ids(self) -> list[str]:
+ return [
+ call_id
+ for segment in self._segments
+ if isinstance(segment, _ToolTurnSegment)
+ for call_id in segment.required_tool_ids
+ if call_id not in self._tool_results
+ ]
+
+ def _has_pending_tool_id(self, call_id: str) -> bool:
+ return any(
+ isinstance(segment, _ToolTurnSegment)
+ and call_id in segment.required_tool_ids
+ for segment in self._segments
+ )
+
+
+def build_base_request_body(
+ request: InferenceRequest,
+ *,
+ provider_model: str,
+ tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope | None,
+ default_max_tokens: int | None = None,
+ reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
+) -> JsonObject:
+ """Build common OpenAI Chat fields from canonical semantics."""
+
+ turns = _turns(request.items)
+ ledger = _OpenAIChatHistoryLedger(tool_names=tool_names)
+ for turn_items in turns:
+ if all(isinstance(item, InstructionItem) for item in turn_items):
+ text = "\n\n".join(
+ item.text for item in turn_items if isinstance(item, InstructionItem)
+ )
+ ledger.add_plain([{"role": "user", "content": text}])
+ elif any(isinstance(item, ToolResultItem) for item in turn_items) or all(
+ isinstance(item, MessageItem) and item.role is MessageRole.USER
+ for item in turn_items
+ ):
+ ledger.add_user_turn(turn_items)
+ else:
+ segment = _assistant_segment(
+ turn_items,
+ reasoning_replay=reasoning_replay,
+ replay_scope=replay_scope,
+ tool_names=tool_names,
+ )
+ if isinstance(segment, _ToolTurnSegment):
+ ledger.add_tool_turn(segment)
+ else:
+ ledger.add_plain(segment.messages)
+
+ messages = ledger.finish()
+ top_level = [
+ item
+ for item in request.items
+ if isinstance(item, InstructionItem)
+ and item.placement is InstructionPlacement.TOP_LEVEL
+ ]
+ if top_level:
+ messages.insert(0, _system_message(top_level))
+
+ body: JsonObject = {"model": provider_model, "messages": messages}
+ max_tokens = request.max_output_tokens or default_max_tokens
+ if max_tokens is not None:
+ body["max_tokens"] = max_tokens
+ if request.temperature is not None:
+ body["temperature"] = request.temperature
+ if request.top_p is not None:
+ body["top_p"] = request.top_p
+ if request.stop_sequences:
+ body["stop"] = list(request.stop_sequences)
+ if request.metadata is not None:
+ body["metadata"] = thaw_json_object(request.metadata)
+ if request.tools:
+ body["tools"] = [
+ _tool_definition(tool, tool_names=tool_names) for tool in request.tools
+ ]
+ if request.tool_choice is not None:
+ body["tool_choice"] = _tool_choice(request, tool_names=tool_names)
+ elif request.tools:
+ body["tool_choice"] = "auto"
+ if request.parallel_tool_calls is not None:
+ body["parallel_tool_calls"] = request.parallel_tool_calls
+ return body
+
+
+def serialize_tool_result_content(content: JsonValue) -> str:
+ """Serialize canonical tool output into provider-safe text."""
+
+ if content is None:
+ return ""
+ if isinstance(content, str):
+ return content
+ if isinstance(content, Mapping):
+ return json.dumps(thaw_json(content), ensure_ascii=False)
+ if isinstance(content, Sequence):
+ parts: list[str] = []
+ for item in content:
+ if isinstance(item, Mapping) and item.get("type") == "text":
+ text = item.get("text")
+ parts.append(text if isinstance(text, str) else str(text or ""))
+ elif isinstance(item, Mapping | Sequence) and not isinstance(item, str):
+ parts.append(json.dumps(thaw_json(item), ensure_ascii=False))
+ else:
+ parts.append(str(item))
+ return "\n".join(parts)
+ return str(content)
+
+
+def _turns(items: tuple[InferenceItem, ...]) -> list[list[InferenceItem]]:
+ turns: list[list[InferenceItem]] = []
+ indexes: dict[str, int] = {}
+ for item in items:
+ if isinstance(item, InstructionItem):
+ if item.placement is InstructionPlacement.TOP_LEVEL:
+ continue
+ turn_id = item.turn_id
+ else:
+ turn_id = item.turn_id
+ if turn_id is None:
+ raise OpenAIConversionError("transcript item has no turn identity")
+ index = indexes.get(turn_id)
+ if index is None:
+ index = len(turns)
+ indexes[turn_id] = index
+ turns.append([])
+ turns[index].append(item)
+ return turns
+
+
+def _assistant_segment(
+ items: list[InferenceItem],
+ *,
+ reasoning_replay: ReasoningReplayMode,
+ replay_scope: ReplayCompatibilityScope | None,
+ tool_names: OpenAIToolNameCodec,
+) -> _TranscriptSegment:
+ first_tool = next(
+ (index for index, item in enumerate(items) if isinstance(item, ToolCallItem)),
+ None,
+ )
+ if first_tool is None:
+ return _PlainSegment(
+ _assistant_messages(
+ items,
+ reasoning_replay=reasoning_replay,
+ replay_scope=replay_scope,
+ )
+ )
+ calls = [item for item in items if isinstance(item, ToolCallItem)]
+ pre_items = items[:first_tool]
+ message = _assistant_message(
+ pre_items,
+ reasoning_replay=reasoning_replay,
+ replay_scope=replay_scope,
+ )
+ message["tool_calls"] = [
+ _tool_call(item, tool_names=tool_names, replay_scope=replay_scope)
+ for item in calls
+ ]
+ if message.get("content") == " ":
+ message["content"] = ""
+ if reasoning_replay is ReasoningReplayMode.REASONING_CONTENT:
+ message.setdefault("reasoning_content", "")
+ return _ToolTurnSegment(
+ assistant_message=message,
+ required_tool_ids=[item.call_id for item in calls],
+ deferred_items=[
+ item
+ for index, item in enumerate(items)
+ if index > first_tool and not isinstance(item, ToolCallItem)
+ ],
+ reasoning_replay=reasoning_replay,
+ replay_scope=replay_scope,
+ )
+
+
+def _assistant_messages(
+ items: list[InferenceItem],
+ *,
+ reasoning_replay: ReasoningReplayMode,
+ replay_scope: ReplayCompatibilityScope | None,
+) -> list[JsonObject]:
+ if not items:
+ return []
+ return [
+ _assistant_message(
+ items,
+ reasoning_replay=reasoning_replay,
+ replay_scope=replay_scope,
+ )
+ ]
+
+
+def _assistant_message(
+ items: list[InferenceItem],
+ *,
+ reasoning_replay: ReasoningReplayMode,
+ replay_scope: ReplayCompatibilityScope | None,
+) -> JsonObject:
+ text_parts: list[str] = []
+ reasoning_parts: list[str] = []
+ reasoning_details: list[JsonValue] = []
+ for item in items:
+ if isinstance(item, MessageItem):
+ if item.role is not MessageRole.ASSISTANT:
+ raise OpenAIConversionError("assistant turn contains user content")
+ for part in item.content:
+ if isinstance(part, TextContent):
+ text_parts.append(part.text)
+ elif isinstance(part, RefusalContent):
+ text_parts.append(part.refusal)
+ else:
+ raise OpenAIConversionError(
+ "OpenAI Chat cannot represent assistant media content"
+ )
+ elif isinstance(item, ReasoningItem):
+ if reasoning_replay is ReasoningReplayMode.THINK_TAGS and item.reasoning:
+ text_parts.append(f"<think>\n{item.reasoning}\n</think>")
+ elif (
+ reasoning_replay is not ReasoningReplayMode.DISABLED and item.reasoning
+ ):
+ reasoning_parts.append(item.reasoning)
+ reasoning_details.extend(
+ _reasoning_details(item.artifacts, replay_scope=replay_scope)
+ )
+ else:
+ raise OpenAIConversionError(
+ f"assistant turn contains unsupported {type(item).__name__}"
+ )
+ message: JsonObject = {
+ "role": "assistant",
+ "content": "\n\n".join(text_parts) or " ",
+ }
+ if reasoning_parts and reasoning_replay in {
+ ReasoningReplayMode.REASONING_CONTENT,
+ ReasoningReplayMode.REASONING,
+ }:
+ message[reasoning_replay.value] = "\n".join(reasoning_parts)
+ if reasoning_details:
+ message["reasoning_details"] = [
+ thaw_json(detail) for detail in reasoning_details
+ ]
+ return message
+
+
+def _user_messages(items: list[MessageItem]) -> list[JsonObject]:
+ content_parts: list[JsonObject] = []
+ for item in items:
+ if item.role is not MessageRole.USER:
+ raise OpenAIConversionError("user turn contains assistant content")
+ for part in item.content:
+ if isinstance(part, TextContent):
+ content: JsonObject = {"type": "text", "text": part.text}
+ _add_cache_control(content, part.cache_control)
+ content_parts.append(content)
+ elif isinstance(part, ImageContent):
+ content_parts.append(_image_part(part))
+ elif isinstance(part, DocumentContent):
+ raise OpenAIConversionError(
+ "OpenAI Chat cannot represent document content without data loss"
+ )
+ elif isinstance(part, RefusalContent):
+ content_parts.append({"type": "text", "text": part.refusal})
+ if all(
+ part.get("type") == "text" and "cache_control" not in part
+ for part in content_parts
+ ):
+ message_content: JsonValue = "\n".join(
+ str(part.get("text", "")) for part in content_parts
+ )
+ else:
+ message_content = content_parts
+ return [{"role": "user", "content": message_content}]
+
+
+def _system_message(items: list[InstructionItem]) -> JsonObject:
+ if all(item.cache_control is None for item in items):
+ return {
+ "role": "system",
+ "content": "\n\n".join(item.text for item in items).strip(),
+ }
+ parts: list[JsonObject] = []
+ for item in items:
+ part: JsonObject = {"type": "text", "text": item.text}
+ _add_cache_control(part, item.cache_control)
+ parts.append(part)
+ return {"role": "system", "content": parts}
+
+
+def _image_part(content: ImageContent) -> JsonObject:
+ if isinstance(content.source, UrlMediaSource):
+ url = content.source.url
+ elif isinstance(content.source, Base64MediaSource):
+ url = f"data:{content.source.media_type};base64,{content.source.data}"
+ else:
+ raise OpenAIConversionError("unsupported canonical image source")
+ part: JsonObject = {"type": "image_url", "image_url": {"url": url}}
+ _add_cache_control(part, content.cache_control)
+ return part
+
+
+def _tool_definition(
+ tool: FunctionTool | CustomTool,
+ *,
+ tool_names: OpenAIToolNameCodec,
+) -> JsonObject:
+ kind = (
+ ToolCallKind.CUSTOM if isinstance(tool, CustomTool) else ToolCallKind.FUNCTION
+ )
+ if isinstance(tool, FunctionTool):
+ parameters = thaw_json_object(tool.input_schema)
+ description = tool.description or ""
+ strict = tool.strict
+ else:
+ parameters = {
+ "type": "object",
+ "properties": {
+ "input": {
+ "type": "string",
+ "description": "Free-form input for the custom tool.",
+ }
+ },
+ "required": ["input"],
+ }
+ format_parts = [f"Custom tool input format: {tool.format.type.value}."]
+ if tool.format.syntax:
+ format_parts.append(f"Syntax: {tool.format.syntax}.")
+ if tool.format.definition:
+ format_parts.append(tool.format.definition)
+ description = "\n\n".join(
+ part for part in (tool.description, *format_parts) if part
+ )
+ strict = False
+ function: JsonObject = {
+ "name": tool_names.encode(
+ tool.name,
+ kind=kind,
+ namespace=tool.namespace,
+ ),
+ "description": description,
+ "parameters": parameters,
+ }
+ if strict:
+ function["strict"] = True
+ definition: JsonObject = {"type": "function", "function": function}
+ _add_cache_control(definition, tool.cache_control)
+ return definition
+
+
+def _tool_choice(
+ request: InferenceRequest,
+ *,
+ tool_names: OpenAIToolNameCodec,
+) -> JsonValue:
+ choice = request.tool_choice
+ if choice is None:
+ return "auto"
+ if choice.mode is ToolChoiceMode.AUTO:
+ return "auto"
+ if choice.mode is ToolChoiceMode.NONE:
+ return "none"
+ if choice.mode is ToolChoiceMode.REQUIRED:
+ return "required"
+ if choice.kind is None or choice.name is None:
+ raise OpenAIConversionError("specific tool choice has no identity")
+ return {
+ "type": "function",
+ "function": {
+ "name": tool_names.encode(
+ choice.name,
+ kind=choice.kind,
+ namespace=choice.namespace,
+ )
+ },
+ }
+
+
+def _tool_call(
+ item: ToolCallItem,
+ *,
+ tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope | None,
+) -> JsonObject:
+ if item.kind is ToolCallKind.CUSTOM:
+ arguments_value: JsonValue = {"input": _custom_input_text(item.input)}
+ else:
+ arguments_value = item.input
+ call: JsonObject = {
+ "id": item.call_id,
+ "type": "function",
+ "function": {
+ "name": tool_names.encode(
+ item.name,
+ kind=item.kind,
+ namespace=item.namespace,
+ ),
+ "arguments": json.dumps(
+ thaw_json(arguments_value),
+ ensure_ascii=False,
+ separators=(",", ":"),
+ ),
+ },
+ }
+ if extra_content := _tool_extra_content(
+ item.artifacts,
+ replay_scope=replay_scope,
+ ):
+ call["extra_content"] = extra_content
+ return call
+
+
+def _custom_input_text(value: JsonValue) -> str:
+ if isinstance(value, str):
+ return value
+ if isinstance(value, Mapping):
+ raw = value.get("input")
+ if isinstance(raw, str):
+ return raw
+ return json.dumps(thaw_json(value), ensure_ascii=False, separators=(",", ":"))
+
+
+def _reasoning_details(
+ artifacts: tuple[ReplayArtifact, ...],
+ *,
+ replay_scope: ReplayCompatibilityScope | None,
+) -> list[JsonValue]:
+ details: list[JsonValue] = []
+ for artifact in artifacts:
+ if (
+ artifact.kind is not ReplayArtifactKind.REASONING_DETAILS
+ or not _scope_matches(artifact, replay_scope)
+ ):
+ continue
+ payload = artifact.payload
+ if isinstance(payload, str):
+ try:
+ parsed = json.loads(payload)
+ except json.JSONDecodeError:
+ continue
+ if isinstance(parsed, list):
+ details.extend(cast(list[JsonValue], parsed))
+ elif isinstance(parsed, dict):
+ details.append(cast(JsonValue, parsed))
+ elif isinstance(payload, Sequence) and not isinstance(payload, str):
+ details.extend(payload)
+ else:
+ details.append(payload)
+ return details
+
+
+def _tool_extra_content(
+ artifacts: tuple[ReplayArtifact, ...],
+ *,
+ replay_scope: ReplayCompatibilityScope | None,
+) -> JsonObject:
+ result: JsonObject = {}
+ for artifact in artifacts:
+ if not _scope_matches(artifact, replay_scope):
+ continue
+ if artifact.kind is ReplayArtifactKind.THOUGHT_SIGNATURE and isinstance(
+ artifact.payload, str
+ ):
+ result["google"] = {"thought_signature": artifact.payload}
+ elif artifact.kind is ReplayArtifactKind.TOOL_EXTRA_CONTENT and isinstance(
+ artifact.payload, Mapping
+ ):
+ result.update(thaw_json_object(artifact.payload))
+ return result
+
+
+def _scope_matches(
+ artifact: ReplayArtifact,
+ replay_scope: ReplayCompatibilityScope | None,
+) -> bool:
+ return replay_scope is not None and artifact.scope == replay_scope
+
+
+def _add_cache_control(target: JsonObject, cache_control: CacheControl | None) -> None:
+ if cache_control is None:
+ return
+ value: dict[str, str] = {"type": cache_control.type.value}
+ if cache_control.ttl is not None:
+ value["ttl"] = cache_control.ttl.value
+ target["cache_control"] = value
+
+
+def _coalesce_user_messages(
+ messages: list[JsonObject],
+) -> list[JsonObject]:
+ result: list[JsonObject] = []
+ for message in messages:
+ if (
+ message.get("role") == "user"
+ and result
+ and result[-1].get("role") == "user"
+ ):
+ previous = result[-1]
+ previous["content"] = _merge_user_content(
+ previous.get("content"),
+ message.get("content"),
+ )
+ else:
+ result.append(message)
+ return result
+
+
+def _merge_user_content(first: JsonValue, second: JsonValue) -> JsonValue:
+ if isinstance(first, str) and isinstance(second, str):
+ return f"{first}\n\n{second}"
+ first_parts = _user_content_parts(first)
+ second_parts = _user_content_parts(second)
+ if (
+ first_parts
+ and second_parts
+ and first_parts[-1].get("type") == "text"
+ and second_parts[0].get("type") == "text"
+ and "cache_control" not in first_parts[-1]
+ and "cache_control" not in second_parts[0]
+ ):
+ first_text = str(first_parts[-1].get("text", ""))
+ second_text = str(second_parts.pop(0).get("text", ""))
+ first_parts[-1]["text"] = f"{first_text}\n\n{second_text}"
+ return [*first_parts, *second_parts]
+
+
+def _user_content_parts(content: JsonValue) -> list[JsonObject]:
+ if isinstance(content, str):
+ return [{"type": "text", "text": content}]
+ if isinstance(content, Sequence) and not isinstance(content, str):
+ parts: list[JsonObject] = []
+ for part in content:
+ if not isinstance(part, Mapping):
+ raise OpenAIConversionError("OpenAI Chat produced invalid user content")
+ parts.append(thaw_json_object(part))
+ return parts
+ raise OpenAIConversionError("OpenAI Chat produced invalid user content")
+
+
+def _close_tool_result_turns(
+ messages: list[JsonObject],
+) -> list[JsonObject]:
+ result: list[JsonObject] = []
+ for message in messages:
+ if (
+ message.get("role") == "user"
+ and result
+ and result[-1].get("role") == "tool"
+ ):
+ result.append(
+ _SyntheticOpenAIToolTurnBoundary(role="assistant", content=" ")
+ )
+ result.append(message)
+ return result
diff --git a/src/free_claude_code/providers/openai_chat/request_policy.py b/src/free_claude_code/providers/openai_chat/request_policy.py
index 2d15a395..f03b1a7e 100644
--- a/src/free_claude_code/providers/openai_chat/request_policy.py
+++ b/src/free_claude_code/providers/openai_chat/request_policy.py
@@ -1,36 +1,42 @@
"""Request-body policy for OpenAI-compatible chat providers."""
from collections.abc import Callable, Iterable
-from copy import deepcopy
from dataclasses import dataclass, field
-from typing import Any, Literal
+from typing import Literal
from loguru import logger
from free_claude_code.application.errors import InvalidRequestError
-from free_claude_code.core.anthropic import (
- OpenAIToolNameCodec,
+from free_claude_code.core.inference import (
+ InferenceRequest,
+ ReplayCompatibilityScope,
+ thaw_json_object,
+)
+from free_claude_code.core.json_types import JsonObject, JsonValue
+from free_claude_code.core.reasoning import ReasoningPolicy
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+
+from .request_codec import (
+ OpenAIConversionError,
ReasoningReplayMode,
build_base_request_body,
)
-from free_claude_code.core.anthropic.conversion import OpenAIConversionError
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.reasoning import ReasoningPolicy
MaxTokensField = Literal["max_tokens", "max_completion_tokens"]
OpenAIChatPostprocessor = Callable[
- [dict[str, Any], MessagesRequest, ReasoningPolicy], None
+ [JsonObject, InferenceRequest, ReasoningPolicy], None
]
-ExtraBodyValidator = Callable[[dict[str, Any]], None]
+ExtraBodyValidator = Callable[[JsonObject], None]
@dataclass(frozen=True, slots=True)
class OpenAIChatRequestPolicy:
- """Provider policy for Anthropic-to-OpenAI chat request conversion."""
+ """Provider policy for canonical-to-OpenAI Chat request encoding."""
provider_name: str
reasoning_replay: ReasoningReplayMode
include_extra_body: bool = False
+ postprocessor_consumes_extra_body: bool = False
extra_body_validator: ExtraBodyValidator | None = None
reject_extra_body_message: str | None = None
default_max_tokens: int | None = None
@@ -41,113 +47,72 @@ class OpenAIChatRequestPolicy:
def build_openai_chat_request_body(
- request_data: MessagesRequest,
+ request_data: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
policy: OpenAIChatRequestPolicy,
+ tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope | None,
postprocessors: Iterable[OpenAIChatPostprocessor] = (),
-) -> dict[str, Any]:
- """Build an OpenAI-compatible chat request body from an Anthropic request."""
+) -> JsonObject:
+ """Build an OpenAI-compatible Chat request body from canonical input."""
logger.debug(
"{}_REQUEST: conversion start model={} msgs={}",
policy.provider_name,
- request_data.model,
- len(request_data.messages),
+ provider_model,
+ request_data.message_count,
)
try:
body = build_base_request_body(
request_data,
+ provider_model=provider_model,
+ tool_names=tool_names,
+ replay_scope=replay_scope,
default_max_tokens=policy.default_max_tokens,
reasoning_replay=policy.reasoning_replay,
)
except OpenAIConversionError as exc:
raise InvalidRequestError(str(exc)) from exc
- request_extra = request_data.extra_body
- if isinstance(request_extra, dict) and request_extra:
+ extension = request_data.openai_chat_extension
+ if extension is not None and extension.extra_body:
if policy.reject_extra_body_message:
raise InvalidRequestError(policy.reject_extra_body_message)
if policy.include_extra_body:
- extra_body = deepcopy(request_extra)
+ extra_body = thaw_json_object(extension.extra_body)
if policy.extra_body_validator is not None:
try:
policy.extra_body_validator(extra_body)
except ValueError as exc:
raise InvalidRequestError(str(exc)) from exc
body["extra_body"] = extra_body
+ elif not policy.postprocessor_consumes_extra_body:
+ raise InvalidRequestError(
+ f"{policy.provider_name} does not support caller extra_body."
+ )
_apply_common_openai_chat_policy(body, policy)
for postprocess in postprocessors:
postprocess(body, request_data, reasoning)
- _encode_openai_tool_names(body, OpenAIToolNameCodec.from_request(request_data))
-
logger.debug(
"{}_REQUEST: conversion done model={} msgs={} tools={}",
policy.provider_name,
body.get("model"),
- len(body.get("messages", [])),
- len(body.get("tools", [])),
+ _sequence_length(body.get("messages")),
+ _sequence_length(body.get("tools")),
)
return body
-def _encode_openai_tool_names(body: dict[str, Any], codec: OpenAIToolNameCodec) -> None:
- """Encode only canonical OpenAI Chat tool-name locations."""
- if not codec.has_aliases:
- return
-
- tools = body.get("tools")
- if isinstance(tools, list):
- for tool in tools:
- if not isinstance(tool, dict):
- continue
- function = tool.get("function")
- if not isinstance(function, dict):
- continue
- name = function.get("name")
- if isinstance(name, str):
- function["name"] = codec.encode(name)
-
- messages = body.get("messages")
- if isinstance(messages, list):
- for message in messages:
- if not isinstance(message, dict):
- continue
- tool_calls = message.get("tool_calls")
- if not isinstance(tool_calls, list):
- continue
- for tool_call in tool_calls:
- if not isinstance(tool_call, dict):
- continue
- function = tool_call.get("function")
- if not isinstance(function, dict):
- continue
- name = function.get("name")
- if isinstance(name, str):
- function["name"] = codec.encode(name)
-
- tool_choice = body.get("tool_choice")
- if not isinstance(tool_choice, dict):
- return
- function = tool_choice.get("function")
- if not isinstance(function, dict):
- return
- name = function.get("name")
- if not isinstance(name, str):
- return
- encoded = codec.encode(name)
- if encoded == name:
- return
- body["tool_choice"] = {
- **tool_choice,
- "function": {**function, "name": encoded},
- }
+def _sequence_length(value: object) -> int:
+ return len(value) if isinstance(value, list | tuple) else 0
def _apply_common_openai_chat_policy(
- body: dict[str, Any], policy: OpenAIChatRequestPolicy
+ body: JsonObject, policy: OpenAIChatRequestPolicy
) -> None:
if policy.strip_message_names:
_strip_message_names(body.get("messages"))
@@ -162,7 +127,7 @@ def _apply_common_openai_chat_policy(
body["n"] = 1
-def _strip_message_names(messages: Any) -> None:
+def _strip_message_names(messages: JsonValue) -> None:
if not isinstance(messages, list):
return
for message in messages:
@@ -170,7 +135,7 @@ def _strip_message_names(messages: Any) -> None:
message.pop("name", None)
-def _normalize_max_completion_tokens(body: dict[str, Any]) -> None:
+def _normalize_max_completion_tokens(body: JsonObject) -> None:
if "max_completion_tokens" in body:
body.pop("max_tokens", None)
return
diff --git a/src/free_claude_code/providers/openai_chat/tool_calls.py b/src/free_claude_code/providers/openai_chat/tool_calls.py
index 174f4352..3f06a752 100644
--- a/src/free_claude_code/providers/openai_chat/tool_calls.py
+++ b/src/free_claude_code/providers/openai_chat/tool_calls.py
@@ -1,27 +1,36 @@
"""OpenAI-chat tool-call assembly helpers."""
+import hashlib
import json
import uuid
from collections.abc import Callable, Iterator
from dataclasses import dataclass, field
from typing import Any
-from free_claude_code.core.anthropic import OpenAIToolNameCodec
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.streaming import (
- parse_complete_tool_input,
- tool_schemas_by_name,
-)
+from loguru import logger
+
from free_claude_code.core.inference import (
+ CustomTool,
InferenceEvent,
+ InferenceRequest,
InferenceStreamLedger,
ReplayArtifact,
ReplayArtifactKind,
ReplayArtifactOrigin,
ReplayAttachment,
+ ReplayCompatibilityScope,
ToolCallKind,
ToolCallState,
)
+from free_claude_code.core.json_types import JsonObject
+from free_claude_code.providers.openai_chat.recovery import (
+ parse_complete_tool_input,
+ tool_schemas_by_name,
+)
+from free_claude_code.providers.openai_compat import (
+ OpenAIToolIdentity,
+ OpenAIToolNameCodec,
+)
RecordToolExtraContent = Callable[[str, dict[str, Any]], None]
@@ -70,23 +79,38 @@ class OpenAIToolCallCollector:
def completed_calls(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
tool_names: OpenAIToolNameCodec | None = None,
tool_argument_aliases: dict[str, dict[str, str]] | None = None,
) -> tuple[dict[str, Any], ...] | None:
"""Return complete schema-valid calls, or None when output is incomplete."""
schemas = tool_schemas_by_name(request)
+ request_identities = {
+ OpenAIToolIdentity(
+ ToolCallKind.CUSTOM
+ if isinstance(tool, CustomTool)
+ else ToolCallKind.FUNCTION,
+ tool.name,
+ tool.namespace,
+ )
+ for tool in request.tools
+ }
completed: list[dict[str, Any]] = []
for index in sorted(self._calls):
state = self._calls[index]
wire_name = state.name.strip()
- name = tool_names.decode(wire_name) if tool_names is not None else wire_name
- if not name or name not in schemas:
+ identity = (
+ tool_names.decode_identity(wire_name)
+ if tool_names is not None
+ else OpenAIToolIdentity(ToolCallKind.FUNCTION, wire_name)
+ )
+ name = identity.name
+ if not name or identity not in request_identities:
return None
arguments = "".join(state.argument_parts)
aliases = (
- tool_argument_aliases.get(name, {})
+ tool_argument_aliases.get(wire_name, {})
if tool_argument_aliases is not None
else {}
)
@@ -102,7 +126,7 @@ class OpenAIToolCallCollector:
"index": index,
"id": state.tool_id,
"function": {
- "name": name,
+ "name": wire_name,
"arguments": arguments,
},
}
@@ -120,10 +144,11 @@ def iter_heuristic_tool_use_events(
) -> Iterator[InferenceEvent]:
"""Emit canonical events for one heuristic tool-use block."""
name = tool_use.get("name")
+ identity = OpenAIToolIdentity(ToolCallKind.FUNCTION, str(name or ""))
if tool_names is not None and isinstance(name, str):
- decoded_name = tool_names.decode(name)
- if decoded_name != name:
- tool_use = {**tool_use, "name": decoded_name}
+ identity = tool_names.decode_identity(name)
+ if identity.name != name:
+ tool_use = {**tool_use, "name": identity.name}
if tool_use.get("name") == "Task" and isinstance(tool_use.get("input"), dict):
task_input = tool_use["input"]
if task_input.get("run_in_background") is not False:
@@ -134,7 +159,8 @@ def iter_heuristic_tool_use_events(
tool_index,
str(tool_use["id"]),
str(tool_use["name"]),
- kind=ToolCallKind.FUNCTION,
+ kind=identity.kind,
+ namespace=identity.namespace,
)
yield ledger.emit_tool_delta(tool_index, json.dumps(tool_use["input"]))
yield ledger.stop_tool_block(tool_index)
@@ -182,7 +208,7 @@ def started_tool_states(
def all_emitted_tools_complete(
- ledger: InferenceStreamLedger, request: MessagesRequest
+ ledger: InferenceStreamLedger, request: InferenceRequest
) -> bool:
"""Return whether every emitted tool block has schema-valid input."""
schemas = tool_schemas_by_name(request)
@@ -201,9 +227,15 @@ class OpenAIToolCallAssembler:
"""Assemble OpenAI tool-call deltas into canonical tool events."""
def __init__(
- self, *, record_extra_content: RecordToolExtraContent | None = None
+ self,
+ *,
+ replay_scope: ReplayCompatibilityScope,
+ record_extra_content: RecordToolExtraContent | None = None,
) -> None:
+ self._replay_scope = replay_scope
self._record_extra_content = record_extra_content
+ self._task_arg_buffers: dict[int, str] = {}
+ self._task_args_emitted: set[int] = set()
def process_tool_call(
self,
@@ -237,18 +269,23 @@ class OpenAIToolCallAssembler:
if extra_content:
ledger.set_tool_artifacts(
tc_index,
- _tool_replay_artifacts(extra_content),
+ _tool_replay_artifacts(extra_content, scope=self._replay_scope),
)
if isinstance(incoming_name, str) and incoming_name:
- resolved_name = _decode_streamed_tool_name(
+ resolved_identity = _decode_streamed_tool_identity(
incoming_name,
tool_index=tc_index,
tool_names=tool_names,
buffers=tool_name_buffers,
)
- if resolved_name is not None:
- ledger.blocks.register_tool_name(tc_index, resolved_name)
+ if resolved_identity is not None:
+ ledger.blocks.register_tool_identity(
+ tc_index,
+ resolved_identity.name,
+ kind=resolved_identity.kind,
+ namespace=resolved_identity.namespace,
+ )
state = ledger.blocks.tool_states.get(tc_index)
resolved_id = (state.call_id if state and state.call_id else None) or tc.get(
@@ -268,6 +305,8 @@ class OpenAIToolCallAssembler:
tc_index,
tool_id,
display_name,
+ kind=state.kind if state else ToolCallKind.FUNCTION,
+ namespace=state.namespace if state else None,
artifacts=start_artifacts,
)
state = ledger.blocks.tool_states[tc_index]
@@ -278,6 +317,7 @@ class OpenAIToolCallAssembler:
ledger,
tc_index,
pre,
+ tool_names=tool_names,
tool_argument_aliases=tool_argument_aliases,
tool_argument_alias_buffers=tool_argument_alias_buffers,
)
@@ -297,6 +337,7 @@ class OpenAIToolCallAssembler:
ledger,
tc_index,
arguments,
+ tool_names=tool_names,
tool_argument_aliases=tool_argument_aliases,
tool_argument_alias_buffers=tool_argument_alias_buffers,
)
@@ -305,8 +346,34 @@ class OpenAIToolCallAssembler:
self, ledger: InferenceStreamLedger
) -> Iterator[InferenceEvent]:
"""Emit buffered Task args as a single JSON delta."""
- for tool_index, out in ledger.blocks.flush_task_arg_buffers():
- yield ledger.emit_tool_delta(tool_index, out)
+ for tool_index, buffered in list(self._task_arg_buffers.items()):
+ if not buffered or tool_index in self._task_args_emitted:
+ continue
+ output = "{}"
+ try:
+ parsed = json.loads(buffered)
+ if isinstance(parsed, dict):
+ _normalize_task_run_in_background(parsed)
+ output = json.dumps(parsed)
+ except (json.JSONDecodeError, TypeError, ValueError) as exc:
+ state = ledger.blocks.tool_states.get(tool_index)
+ digest = hashlib.sha256(
+ buffered.encode("utf-8", errors="replace")
+ ).hexdigest()[:16]
+ logger.warning(
+ "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",
+ state.call_id if state is not None and state.call_id else "unknown",
+ len(buffered),
+ digest,
+ exc,
+ )
+ self._task_args_emitted.add(tool_index)
+ self._task_arg_buffers.pop(tool_index, None)
+ yield ledger.emit_tool_delta(tool_index, output)
+
+ def buffered_task_args(self, tool_index: int) -> str:
+ """Return provider-owned Task arguments that have not been emitted yet."""
+ return self._task_arg_buffers.get(tool_index, "")
def flush_tool_name_buffers(
self,
@@ -334,6 +401,7 @@ class OpenAIToolCallAssembler:
def flush_tool_argument_alias_buffers(
self,
ledger: InferenceStreamLedger,
+ tool_names: OpenAIToolNameCodec,
tool_argument_aliases: dict[str, dict[str, str]],
tool_argument_alias_buffers: dict[int, str],
) -> Iterator[InferenceEvent]:
@@ -345,7 +413,13 @@ class OpenAIToolCallAssembler:
state = ledger.blocks.tool_states.get(tool_index)
if state is None or state.name == "Task":
continue
- aliases = tool_argument_aliases.get(state.name, {})
+ aliases = tool_argument_aliases_for_identity(
+ tool_argument_aliases,
+ tool_names=tool_names,
+ kind=state.kind,
+ name=state.name,
+ namespace=state.namespace,
+ )
if not aliases:
continue
restored = self._restore_aliased_tool_arguments(buffered_args, aliases)
@@ -361,6 +435,7 @@ class OpenAIToolCallAssembler:
tc_index: int,
args: str,
*,
+ tool_names: OpenAIToolNameCodec | None,
tool_argument_aliases: dict[str, dict[str, str]] | None = None,
tool_argument_alias_buffers: dict[int, str] | None = None,
) -> Iterator[InferenceEvent]:
@@ -371,12 +446,31 @@ class OpenAIToolCallAssembler:
if state is None:
return
if state.name == "Task":
- parsed = ledger.blocks.buffer_task_args(tc_index, args)
- if parsed is not None:
- yield ledger.emit_tool_delta(tc_index, json.dumps(parsed))
+ if tc_index in self._task_args_emitted:
+ return
+ buffered = self._task_arg_buffers.get(tc_index, "") + args
+ self._task_arg_buffers[tc_index] = buffered
+ try:
+ parsed = json.loads(buffered)
+ except json.JSONDecodeError, TypeError, ValueError:
+ return
+ if not isinstance(parsed, dict):
+ return
+ _normalize_task_run_in_background(parsed)
+ self._task_args_emitted.add(tc_index)
+ self._task_arg_buffers.pop(tc_index, None)
+ yield ledger.emit_tool_delta(tc_index, json.dumps(parsed))
return
aliases = (
- tool_argument_aliases.get(state.name, {}) if tool_argument_aliases else {}
+ tool_argument_aliases_for_identity(
+ tool_argument_aliases,
+ tool_names=tool_names,
+ kind=state.kind,
+ name=state.name,
+ namespace=state.namespace,
+ )
+ if tool_argument_aliases
+ else {}
)
if aliases:
if tool_argument_alias_buffers is None:
@@ -407,6 +501,24 @@ class OpenAIToolCallAssembler:
self._record_extra_content(tool_call_id, extra_content)
+def tool_argument_aliases_for_identity(
+ aliases: dict[str, dict[str, str]],
+ *,
+ tool_names: OpenAIToolNameCodec | None,
+ kind: ToolCallKind,
+ name: str,
+ namespace: str | None,
+) -> dict[str, str]:
+ """Resolve provider-private aliases by their exact upstream tool identity."""
+
+ wire_name = (
+ tool_names.encode(name, kind=kind, namespace=namespace)
+ if tool_names is not None
+ else name
+ )
+ return aliases.get(wire_name, {})
+
+
def restore_tool_argument_aliases(
argument_json: str,
aliases: dict[str, str],
@@ -443,31 +555,40 @@ def _merge_tool_name(existing: str, incoming: str) -> str:
return "".join((existing, incoming))
-def _decode_streamed_tool_name(
+def _normalize_task_run_in_background(args: JsonObject) -> None:
+ if args.get("run_in_background") is not False:
+ args["run_in_background"] = False
+
+
+def _decode_streamed_tool_identity(
incoming: str,
*,
tool_index: int,
tool_names: OpenAIToolNameCodec | None,
buffers: dict[int, str] | None,
-) -> str | None:
- if tool_names is None or not tool_names.has_aliases:
- return incoming
+) -> OpenAIToolIdentity | None:
+ if tool_names is None:
+ return OpenAIToolIdentity(ToolCallKind.FUNCTION, incoming)
+ if not tool_names.has_aliases:
+ return tool_names.decode_identity(incoming)
if buffers is None:
- return tool_names.decode(incoming)
+ return tool_names.decode_identity(incoming)
combined = _merge_tool_name(buffers.get(tool_index, ""), incoming)
if tool_names.is_alias(combined):
buffers.pop(tool_index, None)
- return tool_names.decode(combined)
+ return tool_names.decode_identity(combined)
if tool_names.is_alias_prefix(combined):
buffers[tool_index] = combined
return None
buffers.pop(tool_index, None)
- return tool_names.decode(combined)
+ return tool_names.decode_identity(combined)
def _tool_replay_artifacts(
extra_content: dict[str, Any],
+ *,
+ scope: ReplayCompatibilityScope,
) -> tuple[ReplayArtifact, ...]:
google = extra_content.get("google")
if isinstance(google, dict):
@@ -479,6 +600,7 @@ def _tool_replay_artifacts(
kind=ReplayArtifactKind.THOUGHT_SIGNATURE,
attachment=ReplayAttachment.TOOL_CALL,
payload=signature,
+ scope=scope,
),
)
return (
@@ -487,5 +609,6 @@ def _tool_replay_artifacts(
kind=ReplayArtifactKind.TOOL_EXTRA_CONTENT,
attachment=ReplayAttachment.TOOL_CALL,
payload=extra_content,
+ scope=scope,
),
)
diff --git a/src/free_claude_code/providers/openai_codex/provider.py b/src/free_claude_code/providers/openai_codex/provider.py
index 53882025..a72ff347 100644
--- a/src/free_claude_code/providers/openai_codex/provider.py
+++ b/src/free_claude_code/providers/openai_codex/provider.py
@@ -12,20 +12,19 @@ import httpx
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.model_metadata import ProviderModelInfo
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec
from free_claude_code.core.diagnostics import (
ERROR_DETAIL_DISPLAY_CAP_BYTES,
attach_upstream_error_body,
extract_upstream_error_detail,
)
from free_claude_code.core.failures import ExecutionFailure, FailureKind
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ ReplayCompatibilityScope,
+)
from free_claude_code.core.openai_responses import (
ResponsesConversionError,
- ResponsesEventDecoder,
- ResponsesStreamFailure,
- build_responses_provider_request,
)
from free_claude_code.core.reasoning import (
DEFAULT_REASONING_POLICY,
@@ -45,6 +44,16 @@ from free_claude_code.providers.failure_policy import (
is_retryable_stream_error,
)
from free_claude_code.providers.http import ProviderAttemptScope, maybe_await_aclose
+from free_claude_code.providers.openai_compat import (
+ OpenAIToolNameCodec,
+ openai_replay_scope,
+)
+from free_claude_code.providers.openai_responses import (
+ ResponsesEventDecoder,
+ ResponsesRequestEncodingError,
+ ResponsesStreamFailure,
+ build_responses_request_body,
+)
from free_claude_code.providers.stream_recovery import (
RecoveryController,
RecoveryFailureAction,
@@ -96,13 +105,18 @@ class OpenAICodexProvider(BaseProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
"""Validate and adapt the private Codex request before upstream I/O."""
- self._build_body(request, reasoning=reasoning)
+ self._build_body(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ )
async def cleanup(self) -> None:
"""Close only provider-owned transport resources."""
@@ -175,9 +189,10 @@ class OpenAICodexProvider(BaseProvider):
def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
@@ -185,24 +200,37 @@ class OpenAICodexProvider(BaseProvider):
"""Stream private Responses output as canonical inference events."""
tool_names = OpenAIToolNameCodec.from_request(request)
- body = self._build_body(request, reasoning=reasoning)
+ replay_scope = self._replay_scope(provider_model)
+ body = self._build_body(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ )
return self._run_stream(
body,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model or request.model,
tool_names=tool_names,
+ replay_scope=replay_scope,
)
- @staticmethod
def _build_body(
- request: MessagesRequest,
+ self,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> dict[str, Any]:
try:
- body = build_responses_provider_request(request, reasoning=reasoning)
- except ResponsesConversionError as exc:
+ body = build_responses_request_body(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=self._replay_scope(provider_model),
+ )
+ except (ResponsesConversionError, ResponsesRequestEncodingError) as exc:
raise InvalidRequestError(str(exc)) from exc
# The private Codex backend rejects these public Responses fields.
# Codex itself omits the output cap and uses separate internal metadata.
@@ -210,6 +238,14 @@ class OpenAICodexProvider(BaseProvider):
body.pop("metadata", None)
return body
+ @staticmethod
+ def _replay_scope(provider_model: str) -> ReplayCompatibilityScope:
+ return openai_replay_scope(
+ "openai",
+ provider_model,
+ replay_format="codex-responses",
+ )
+
async def _run_stream(
self,
body: dict[str, Any],
@@ -218,6 +254,7 @@ class OpenAICodexProvider(BaseProvider):
request_id: str | None,
response_model: str,
tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope,
) -> AsyncIterator[InferenceEvent]:
execution = self._admission.start_execution(request_id=request_id)
provider_stream = self._run_stream_execution(
@@ -226,6 +263,7 @@ class OpenAICodexProvider(BaseProvider):
request_id=request_id,
response_model=response_model,
tool_names=tool_names,
+ replay_scope=replay_scope,
execution=execution,
)
try:
@@ -250,6 +288,7 @@ class OpenAICodexProvider(BaseProvider):
request_id: str | None,
response_model: str,
tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope,
execution: ProviderExecution,
) -> AsyncIterator[InferenceEvent]:
"""Run one Codex execution while retaining Responses transport ownership."""
@@ -276,6 +315,7 @@ class OpenAICodexProvider(BaseProvider):
model=response_model,
input_tokens=input_tokens,
tool_names=tool_names,
+ replay_scope=replay_scope,
)
for event in stream.start():
for held in recovery.push(event):
diff --git a/src/free_claude_code/providers/openai_compat/__init__.py b/src/free_claude_code/providers/openai_compat/__init__.py
new file mode 100644
index 00000000..7c3af6bb
--- /dev/null
+++ b/src/free_claude_code/providers/openai_compat/__init__.py
@@ -0,0 +1,15 @@
+"""Shared upstream OpenAI transport helpers."""
+
+from .replay import openai_replay_scope
+from .tool_names import (
+ OPENAI_TOOL_NAME_MAX_LENGTH,
+ OpenAIToolIdentity,
+ OpenAIToolNameCodec,
+)
+
+__all__ = [
+ "OPENAI_TOOL_NAME_MAX_LENGTH",
+ "OpenAIToolIdentity",
+ "OpenAIToolNameCodec",
+ "openai_replay_scope",
+]
diff --git a/src/free_claude_code/providers/openai_compat/replay.py b/src/free_claude_code/providers/openai_compat/replay.py
new file mode 100644
index 00000000..a205d0b3
--- /dev/null
+++ b/src/free_claude_code/providers/openai_compat/replay.py
@@ -0,0 +1,18 @@
+"""Route-scoped replay identity for OpenAI-compatible transports."""
+
+import hashlib
+
+from free_claude_code.core.inference import ReplayCompatibilityScope
+
+
+def openai_replay_scope(
+ provider_identity: str,
+ provider_model: str,
+ *,
+ replay_format: str,
+) -> ReplayCompatibilityScope:
+ """Return an opaque deterministic scope for one replay-compatible route."""
+
+ material = "\0".join((provider_identity, provider_model, replay_format))
+ digest = hashlib.sha256(material.encode("utf-8")).hexdigest()
+ return ReplayCompatibilityScope(f"openai-{digest}")
diff --git a/src/free_claude_code/providers/openai_compat/tool_names.py b/src/free_claude_code/providers/openai_compat/tool_names.py
new file mode 100644
index 00000000..e7e1e1ff
--- /dev/null
+++ b/src/free_claude_code/providers/openai_compat/tool_names.py
@@ -0,0 +1,173 @@
+"""Request-scoped reversible tool identity for OpenAI transports."""
+
+import hashlib
+import re
+from collections import Counter
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from free_claude_code.core.inference import (
+ CustomTool,
+ InferenceRequest,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoiceMode,
+)
+
+OPENAI_TOOL_NAME_MAX_LENGTH = 64
+_ALIAS_DIGEST_LENGTH = 16
+_PORTABLE_TOOL_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
+_INVALID_TOOL_NAME_CHARACTERS = re.compile(r"[^A-Za-z0-9_-]+")
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIToolIdentity:
+ """Canonical tool identity represented by one upstream wire name."""
+
+ kind: ToolCallKind
+ name: str
+ namespace: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIToolNameCodec:
+ """Map canonical identities to deterministic OpenAI-compatible names."""
+
+ _identity_to_wire: dict[OpenAIToolIdentity, str]
+ _wire_to_identity: dict[str, OpenAIToolIdentity]
+ _aliased_names: frozenset[str]
+
+ @classmethod
+ def from_request(cls, request: InferenceRequest) -> OpenAIToolNameCodec:
+ """Build the codec from definitions, choice, and prior calls."""
+
+ identities: list[OpenAIToolIdentity] = [
+ OpenAIToolIdentity(
+ ToolCallKind.CUSTOM
+ if isinstance(tool, CustomTool)
+ else ToolCallKind.FUNCTION,
+ tool.name,
+ tool.namespace,
+ )
+ for tool in request.tools
+ ]
+ choice = request.tool_choice
+ if choice is not None and choice.mode is ToolChoiceMode.SPECIFIC:
+ if choice.kind is None or choice.name is None:
+ raise ValueError("specific tool choice is missing its identity")
+ identities.append(
+ OpenAIToolIdentity(choice.kind, choice.name, choice.namespace)
+ )
+ identities.extend(
+ OpenAIToolIdentity(item.kind, item.name, item.namespace)
+ for item in request.items
+ if isinstance(item, ToolCallItem)
+ )
+ return cls.from_identities(identities)
+
+ @classmethod
+ def from_names(cls, names: Iterable[str]) -> OpenAIToolNameCodec:
+ """Build function-tool identities for compatibility-focused unit tests."""
+
+ return cls.from_identities(
+ OpenAIToolIdentity(ToolCallKind.FUNCTION, name) for name in names
+ )
+
+ @classmethod
+ def from_identities(
+ cls,
+ identities: Iterable[OpenAIToolIdentity],
+ ) -> OpenAIToolNameCodec:
+ unique = sorted(
+ set(identities),
+ key=lambda identity: (
+ identity.namespace or "",
+ identity.name,
+ identity.kind.value,
+ ),
+ )
+ candidates = [_readable_identity(identity) for identity in unique]
+ counts = Counter(candidates)
+ reserved: set[str] = set()
+ identity_to_wire: dict[OpenAIToolIdentity, str] = {}
+ wire_to_identity: dict[str, OpenAIToolIdentity] = {}
+ aliased: set[str] = set()
+ for identity, candidate in zip(unique, candidates, strict=True):
+ if (
+ counts[candidate] == 1
+ and _PORTABLE_TOOL_NAME.fullmatch(candidate)
+ and candidate not in reserved
+ ):
+ wire_name = candidate
+ else:
+ wire_name = _unique_alias(identity, candidate, reserved)
+ aliased.add(wire_name)
+ reserved.add(wire_name)
+ identity_to_wire[identity] = wire_name
+ wire_to_identity[wire_name] = identity
+ return cls(identity_to_wire, wire_to_identity, frozenset(aliased))
+
+ @property
+ def has_aliases(self) -> bool:
+ return bool(self._aliased_names)
+
+ def encode(
+ self,
+ name: str,
+ *,
+ kind: ToolCallKind = ToolCallKind.FUNCTION,
+ namespace: str | None = None,
+ ) -> str:
+ identity = OpenAIToolIdentity(kind, name, namespace)
+ return self._identity_to_wire.get(identity, _readable_identity(identity))
+
+ def decode_identity(self, wire_name: str) -> OpenAIToolIdentity:
+ return self._wire_to_identity.get(
+ wire_name,
+ OpenAIToolIdentity(ToolCallKind.FUNCTION, wire_name),
+ )
+
+ def decode(self, wire_name: str) -> str:
+ """Return the canonical name for one known wire identity."""
+
+ return self.decode_identity(wire_name).name
+
+ def is_alias(self, value: str) -> bool:
+ return value in self._aliased_names
+
+ def is_unchanged_name(self, value: str) -> bool:
+ return value in self._wire_to_identity and value not in self._aliased_names
+
+ def is_alias_prefix(self, value: str) -> bool:
+ return bool(value) and any(
+ alias != value and alias.startswith(value) for alias in self._aliased_names
+ )
+
+
+def _readable_identity(identity: OpenAIToolIdentity) -> str:
+ if identity.namespace:
+ return f"{identity.namespace}__{identity.name}"
+ return identity.name
+
+
+def _unique_alias(
+ identity: OpenAIToolIdentity,
+ candidate: str,
+ reserved: set[str],
+) -> str:
+ readable = _INVALID_TOOL_NAME_CHARACTERS.sub("_", candidate).strip("_-") or "tool"
+ max_readable_length = OPENAI_TOOL_NAME_MAX_LENGTH - _ALIAS_DIGEST_LENGTH - 1
+ readable = readable[:max_readable_length].rstrip("_-") or "tool"
+ identity_key = "\0".join(
+ (identity.kind.value, identity.namespace or "", identity.name)
+ )
+ attempt = 0
+ while True:
+ digest_input = identity_key if attempt == 0 else f"{identity_key}\0{attempt}"
+ digest = hashlib.sha256(digest_input.encode("utf-8")).hexdigest()[
+ :_ALIAS_DIGEST_LENGTH
+ ]
+ alias = f"{readable}_{digest}"
+ if alias not in reserved:
+ return alias
+ attempt += 1
diff --git a/src/free_claude_code/providers/openai_responses/__init__.py b/src/free_claude_code/providers/openai_responses/__init__.py
index 79eb5d63..639ed27c 100644
--- a/src/free_claude_code/providers/openai_responses/__init__.py
+++ b/src/free_claude_code/providers/openai_responses/__init__.py
@@ -1,5 +1,13 @@
"""Standard OpenAI Responses provider transport."""
+from .events import ResponsesEventDecoder, ResponsesStreamFailure
+from .request_codec import ResponsesRequestEncodingError, build_responses_request_body
from .transport import OpenAIResponsesTransport
-__all__ = ["OpenAIResponsesTransport"]
+__all__ = [
+ "OpenAIResponsesTransport",
+ "ResponsesEventDecoder",
+ "ResponsesRequestEncodingError",
+ "ResponsesStreamFailure",
+ "build_responses_request_body",
+]
diff --git a/src/free_claude_code/core/openai_responses/provider_events.py b/src/free_claude_code/providers/openai_responses/events.py
similarity index 85%
rename from src/free_claude_code/core/openai_responses/provider_events.py
rename to src/free_claude_code/providers/openai_responses/events.py
index 21307737..4c58c3ad 100644
--- a/src/free_claude_code/core/openai_responses/provider_events.py
+++ b/src/free_claude_code/providers/openai_responses/events.py
@@ -3,7 +3,6 @@
from collections.abc import Mapping
from dataclasses import dataclass
-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec
from free_claude_code.core.inference import (
FinishReason,
InferenceEvent,
@@ -13,9 +12,12 @@ from free_claude_code.core.inference import (
ReplayArtifactKind,
ReplayArtifactOrigin,
ReplayAttachment,
+ ReplayCompatibilityScope,
TokenMeasurement,
+ ToolCallKind,
UsageSource,
)
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
class ResponsesStreamFailure(RuntimeError):
@@ -32,6 +34,8 @@ class _ToolState:
tool_index: int
call_id: str
name: str
+ kind: ToolCallKind
+ namespace: str | None
started: bool = False
received_delta: bool = False
stopped: bool = False
@@ -47,11 +51,13 @@ class ResponsesEventDecoder:
model: str,
input_tokens: int,
tool_names: OpenAIToolNameCodec | None = None,
+ replay_scope: ReplayCompatibilityScope,
) -> None:
self.ledger = InferenceStreamLedger(response_id, model, input_tokens)
self.completed = False
self.generated_output = False
self._tool_names = tool_names or OpenAIToolNameCodec.from_names(())
+ self._replay_scope = replay_scope
self._tools: dict[str, _ToolState] = {}
self._encrypted_reasoning: dict[str, str] = {}
@@ -70,7 +76,10 @@ class ResponsesEventDecoder:
return self._reasoning_delta(data)
if event_type == "response.output_text.delta":
return self._text_delta(data)
- if event_type == "response.function_call_arguments.delta":
+ if event_type in {
+ "response.function_call_arguments.delta",
+ "response.custom_tool_call_input.delta",
+ }:
return self._tool_delta(data)
if event_type == "response.output_item.done":
return self._item_done(data)
@@ -85,11 +94,18 @@ class ResponsesEventDecoder:
if not isinstance(item, dict):
return []
item_id = _string(item.get("id"))
- if item.get("type") == "function_call" and item_id:
+ if item.get("type") in {"function_call", "custom_tool_call"} and item_id:
+ identity = self._tool_names.decode_identity(_string(item.get("name")))
self._tools[item_id] = _ToolState(
tool_index=len(self._tools),
call_id=_string(item.get("call_id")) or item_id,
- name=self._tool_names.decode(_string(item.get("name"))),
+ name=identity.name,
+ kind=(
+ ToolCallKind.CUSTOM
+ if item.get("type") == "custom_tool_call"
+ else identity.kind
+ ),
+ namespace=identity.namespace,
)
if item.get("type") == "reasoning" and item_id:
encrypted = item.get("encrypted_content")
@@ -126,6 +142,8 @@ class ResponsesEventDecoder:
tool_index=len(self._tools),
call_id=item_id,
name="",
+ kind=ToolCallKind.FUNCTION,
+ namespace=None,
)
self._tools[item_id] = state
events = list(self.ledger.close_content_blocks())
@@ -142,20 +160,32 @@ class ResponsesEventDecoder:
return []
item_type = item.get("type")
item_id = _string(item.get("id"))
- if item_type == "function_call":
+ if item_type in {"function_call", "custom_tool_call"}:
state = self._tools.get(item_id)
if state is None:
+ identity = self._tool_names.decode_identity(_string(item.get("name")))
state = _ToolState(
tool_index=len(self._tools),
call_id=_string(item.get("call_id")) or item_id,
- name=self._tool_names.decode(_string(item.get("name"))),
+ name=identity.name,
+ kind=(
+ ToolCallKind.CUSTOM
+ if item_type == "custom_tool_call"
+ else identity.kind
+ ),
+ namespace=identity.namespace,
)
self._tools[item_id] = state
if not state.name:
- state.name = self._tool_names.decode(_string(item.get("name")))
+ identity = self._tool_names.decode_identity(_string(item.get("name")))
+ state.name = identity.name
+ state.kind = identity.kind
+ state.namespace = identity.namespace
events = list(self.ledger.close_content_blocks())
events.extend(self._ensure_tool_started(state))
- arguments = item.get("arguments")
+ arguments = item.get(
+ "input" if item_type == "custom_tool_call" else "arguments"
+ )
if not state.received_delta and isinstance(arguments, str) and arguments:
events.append(self.ledger.emit_tool_delta(state.tool_index, arguments))
self.generated_output = True
@@ -176,6 +206,7 @@ class ResponsesEventDecoder:
kind=ReplayArtifactKind.ENCRYPTED_REASONING,
attachment=ReplayAttachment.REASONING,
payload=encrypted,
+ scope=self._replay_scope,
)
)
)
@@ -193,6 +224,8 @@ class ResponsesEventDecoder:
state.tool_index,
state.call_id,
state.name,
+ kind=state.kind,
+ namespace=state.namespace,
)
]
diff --git a/src/free_claude_code/providers/openai_responses/request_codec.py b/src/free_claude_code/providers/openai_responses/request_codec.py
new file mode 100644
index 00000000..3349e070
--- /dev/null
+++ b/src/free_claude_code/providers/openai_responses/request_codec.py
@@ -0,0 +1,349 @@
+"""Encode canonical inference requests for an OpenAI Responses upstream."""
+
+import json
+from collections.abc import Mapping, Sequence
+
+from free_claude_code.core.inference import (
+ Base64MediaSource,
+ CustomTool,
+ DocumentContent,
+ FunctionTool,
+ ImageContent,
+ InferenceItem,
+ InferenceRequest,
+ InstructionItem,
+ MessageItem,
+ MessageRole,
+ ReasoningItem,
+ RefusalContent,
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoiceMode,
+ ToolResultItem,
+ UrlMediaSource,
+ replay_payload_text,
+ thaw_json,
+ thaw_json_object,
+)
+from free_claude_code.core.json_types import JsonValue
+from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+
+
+class ResponsesRequestEncodingError(ValueError):
+ """Canonical semantics cannot be represented by Responses without loss."""
+
+
+def build_responses_request_body(
+ request: InferenceRequest,
+ *,
+ provider_model: str,
+ reasoning: ReasoningPolicy,
+ tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope,
+) -> dict[str, object]:
+ """Build one stateless Responses request from canonical values."""
+
+ _validate_request(request)
+ instructions: list[str] = []
+ input_items: list[dict[str, object]] = []
+ for items in _turns(request.items):
+ for item in items:
+ if isinstance(item, InstructionItem):
+ _require_no_cache_control(item.cache_control, "instruction")
+ instructions.append(item.text)
+ elif isinstance(item, MessageItem):
+ input_items.append(_message_item(item))
+ elif isinstance(item, ReasoningItem):
+ input_items.append(_reasoning_item(item, replay_scope=replay_scope))
+ elif isinstance(item, ToolCallItem):
+ input_items.append(
+ _tool_call_item(
+ item,
+ tool_names=tool_names,
+ replay_scope=replay_scope,
+ )
+ )
+ elif isinstance(item, ToolResultItem):
+ input_items.append(_tool_result_item(item))
+
+ if not input_items:
+ raise ResponsesRequestEncodingError(
+ "OpenAI Responses requires at least one conversational input item"
+ )
+
+ body: dict[str, object] = {
+ "model": provider_model,
+ "input": input_items,
+ "stream": True,
+ "store": False,
+ "include": ["reasoning.encrypted_content"],
+ }
+ if instructions:
+ body["instructions"] = "\n\n".join(instructions)
+ if request.max_output_tokens is not None:
+ body["max_output_tokens"] = request.max_output_tokens
+ if request.temperature is not None:
+ body["temperature"] = request.temperature
+ if request.top_p is not None:
+ body["top_p"] = request.top_p
+ if request.metadata is not None:
+ body["metadata"] = thaw_json_object(request.metadata)
+ if request.tools:
+ body["tools"] = [
+ _tool_definition(tool, tool_names=tool_names) for tool in request.tools
+ ]
+ if request.tool_choice is not None:
+ body["tool_choice"] = _tool_choice(request, tool_names=tool_names)
+ elif request.tools:
+ body["tool_choice"] = "auto"
+ if request.parallel_tool_calls is not None:
+ body["parallel_tool_calls"] = request.parallel_tool_calls
+ if config := _reasoning_config(reasoning):
+ body["reasoning"] = config
+ return body
+
+
+def _validate_request(request: InferenceRequest) -> None:
+ unsupported: list[str] = []
+ if request.stop_sequences:
+ unsupported.append("stop_sequences")
+ if request.top_k is not None:
+ unsupported.append("top_k")
+ if request.extensions:
+ unsupported.append("extensions")
+ if unsupported:
+ raise ResponsesRequestEncodingError(
+ f"OpenAI Responses cannot represent these canonical fields: {unsupported}"
+ )
+
+
+def _turns(items: tuple[InferenceItem, ...]) -> list[list[InferenceItem]]:
+ turns: list[list[InferenceItem]] = []
+ turn_indexes: dict[str, int] = {}
+ top_level: list[InferenceItem] = []
+ for item in items:
+ turn_id = item.turn_id
+ if turn_id is None:
+ top_level.append(item)
+ continue
+ index = turn_indexes.get(turn_id)
+ if index is None:
+ index = len(turns)
+ turn_indexes[turn_id] = index
+ turns.append([])
+ turns[index].append(item)
+ return ([top_level] if top_level else []) + turns
+
+
+def _message_item(item: MessageItem) -> dict[str, object]:
+ content: list[dict[str, object]] = []
+ for part in item.content:
+ if isinstance(part, TextContent):
+ _require_no_cache_control(part.cache_control, "message text")
+ content.append(
+ {
+ "type": (
+ "input_text" if item.role is MessageRole.USER else "output_text"
+ ),
+ "text": part.text,
+ }
+ )
+ elif isinstance(part, RefusalContent):
+ if item.role is MessageRole.USER:
+ content.append({"type": "input_text", "text": part.refusal})
+ else:
+ content.append({"type": "refusal", "refusal": part.refusal})
+ elif isinstance(part, ImageContent):
+ if item.role is not MessageRole.USER:
+ raise ResponsesRequestEncodingError(
+ "Responses cannot replay assistant image content"
+ )
+ _require_no_cache_control(part.cache_control, "image")
+ content.append({"type": "input_image", "image_url": _image_url(part)})
+ elif isinstance(part, DocumentContent):
+ raise ResponsesRequestEncodingError(
+ "Responses transport does not support canonical document content"
+ )
+ return {"type": "message", "role": item.role.value, "content": content}
+
+
+def _image_url(content: ImageContent) -> str:
+ if isinstance(content.source, UrlMediaSource):
+ return content.source.url
+ if isinstance(content.source, Base64MediaSource):
+ return f"data:{content.source.media_type};base64,{content.source.data}"
+ raise ResponsesRequestEncodingError("unsupported canonical image source")
+
+
+def _reasoning_item(
+ item: ReasoningItem,
+ *,
+ replay_scope: ReplayCompatibilityScope,
+) -> dict[str, object]:
+ result: dict[str, object] = {
+ "type": "reasoning",
+ "summary": (
+ [{"type": "summary_text", "text": item.reasoning}] if item.reasoning else []
+ ),
+ }
+ matching = [
+ artifact
+ for artifact in item.artifacts
+ if artifact.attachment is ReplayAttachment.REASONING
+ and artifact.scope == replay_scope
+ ]
+ if matching:
+ if len(matching) != 1:
+ raise ResponsesRequestEncodingError(
+ "Responses encrypted reasoning accepts one scoped replay artifact"
+ )
+ result["encrypted_content"] = replay_payload_text(matching[0])
+ return result
+
+
+def _tool_call_item(
+ item: ToolCallItem,
+ *,
+ tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope,
+) -> dict[str, object]:
+ if any(
+ artifact.scope == replay_scope
+ and artifact.attachment is ReplayAttachment.TOOL_CALL
+ for artifact in item.artifacts
+ ):
+ raise ResponsesRequestEncodingError(
+ "Responses has no standard tool-call replay carrier"
+ )
+ name = tool_names.encode(
+ item.name,
+ kind=item.kind,
+ namespace=item.namespace,
+ )
+ if item.kind is ToolCallKind.CUSTOM:
+ custom_input = thaw_json(item.input)
+ return {
+ "type": "custom_tool_call",
+ "call_id": item.call_id,
+ "name": name,
+ "input": (
+ custom_input
+ if isinstance(custom_input, str)
+ else json.dumps(custom_input, ensure_ascii=False, separators=(",", ":"))
+ ),
+ }
+ return {
+ "type": "function_call",
+ "call_id": item.call_id,
+ "name": name,
+ "arguments": json.dumps(
+ thaw_json(item.input), ensure_ascii=False, separators=(",", ":")
+ ),
+ }
+
+
+def _tool_result_item(item: ToolResultItem) -> dict[str, object]:
+ return {
+ "type": "function_call_output",
+ "call_id": item.call_id,
+ "output": _serialize_tool_result(item.content),
+ }
+
+
+def _serialize_tool_result(content: JsonValue) -> str:
+ if content is None:
+ return ""
+ if isinstance(content, str):
+ return content
+ if isinstance(content, Mapping):
+ return json.dumps(thaw_json(content), ensure_ascii=False)
+ if isinstance(content, Sequence):
+ parts: list[str] = []
+ for value in content:
+ if isinstance(value, Mapping) and value.get("type") == "text":
+ text = value.get("text")
+ parts.append(text if isinstance(text, str) else str(text or ""))
+ elif isinstance(value, Mapping | Sequence) and not isinstance(value, str):
+ parts.append(json.dumps(thaw_json(value), ensure_ascii=False))
+ else:
+ parts.append(str(value))
+ return "\n".join(parts)
+ return str(content)
+
+
+def _tool_definition(
+ tool: FunctionTool | CustomTool,
+ *,
+ tool_names: OpenAIToolNameCodec,
+) -> dict[str, object]:
+ kind = (
+ ToolCallKind.CUSTOM if isinstance(tool, CustomTool) else ToolCallKind.FUNCTION
+ )
+ name = tool_names.encode(tool.name, kind=kind, namespace=tool.namespace)
+ _require_no_cache_control(tool.cache_control, "tool definition")
+ if isinstance(tool, FunctionTool):
+ return {
+ "type": "function",
+ "name": name,
+ "description": tool.description,
+ "parameters": thaw_json_object(tool.input_schema),
+ "strict": tool.strict,
+ }
+ result: dict[str, object] = {
+ "type": "custom",
+ "name": name,
+ "description": tool.description,
+ "format": {"type": tool.format.type.value},
+ }
+ custom_format = result["format"]
+ if isinstance(custom_format, dict):
+ if tool.format.syntax is not None:
+ custom_format["syntax"] = tool.format.syntax
+ if tool.format.definition is not None:
+ custom_format["definition"] = tool.format.definition
+ return result
+
+
+def _tool_choice(
+ request: InferenceRequest,
+ *,
+ tool_names: OpenAIToolNameCodec,
+) -> object:
+ choice = request.tool_choice
+ if choice is None or choice.mode is ToolChoiceMode.AUTO:
+ return "auto"
+ if choice.mode is ToolChoiceMode.NONE:
+ return "none"
+ if choice.mode is ToolChoiceMode.REQUIRED:
+ return "required"
+ if choice.name is None or choice.kind is None:
+ raise ResponsesRequestEncodingError("specific tool choice has no identity")
+ return {
+ "type": "custom" if choice.kind is ToolCallKind.CUSTOM else "function",
+ "name": tool_names.encode(
+ choice.name,
+ kind=choice.kind,
+ namespace=choice.namespace,
+ ),
+ }
+
+
+def _reasoning_config(reasoning: ReasoningPolicy) -> dict[str, str]:
+ if reasoning.control is ReasoningControl.OFF:
+ return {"effort": "none"}
+ if reasoning.effort is not None:
+ return {"effort": reasoning.effort.value, "summary": "auto"}
+ if reasoning.requests_reasoning:
+ return {"summary": "auto"}
+ return {}
+
+
+def _require_no_cache_control(value: object, path: str) -> None:
+ if value is not None:
+ raise ResponsesRequestEncodingError(
+ f"Responses cannot represent {path} cache_control"
+ )
diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.py
index 38c2bd30..f6672bf4 100644
--- a/src/free_claude_code/providers/openai_responses/transport.py
+++ b/src/free_claude_code/providers/openai_responses/transport.py
@@ -11,16 +11,15 @@ from openai.types.responses import ResponseStreamEvent
from openai.types.responses.response_create_params import ResponseCreateParamsStreaming
from free_claude_code.application.errors import InvalidRequestError
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec
from free_claude_code.core.diagnostics import extract_upstream_error_detail
from free_claude_code.core.failures import ExecutionFailure, FailureKind
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ ReplayCompatibilityScope,
+)
from free_claude_code.core.openai_responses import (
ResponsesConversionError,
- ResponsesEventDecoder,
- ResponsesStreamFailure,
- build_responses_provider_request,
)
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.core.trace import trace_event
@@ -35,11 +34,18 @@ from free_claude_code.providers.failure_policy import (
is_retryable_stream_error,
)
from free_claude_code.providers.http import ProviderAttemptScope, maybe_await_aclose
+from free_claude_code.providers.openai_compat import (
+ OpenAIToolNameCodec,
+ openai_replay_scope,
+)
from free_claude_code.providers.stream_recovery import (
RecoveryController,
RecoveryFailureAction,
)
+from .events import ResponsesEventDecoder, ResponsesStreamFailure
+from .request_codec import ResponsesRequestEncodingError, build_responses_request_body
+
class _TruncatedResponsesStream(RetryableProviderProtocolError):
"""A Responses stream ended without a terminal lifecycle event."""
@@ -79,43 +85,66 @@ class OpenAIResponsesTransport:
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
- self._build_body(request, reasoning=reasoning)
+ self._build_body(request, provider_model=provider_model, reasoning=reasoning)
def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
input_tokens: int,
request_id: str | None,
response_model: str,
reasoning: ReasoningPolicy,
) -> AsyncIterator[InferenceEvent]:
- body = self._build_body(request, reasoning=reasoning)
+ body = self._build_body(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ )
tool_names = OpenAIToolNameCodec.from_request(request)
+ replay_scope = openai_replay_scope(
+ self._provider_name,
+ provider_model,
+ replay_format="responses",
+ )
return self._run_stream(
body,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model,
tool_names=tool_names,
+ replay_scope=replay_scope,
)
- @staticmethod
def _build_body(
- request: MessagesRequest,
+ self,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> ResponseCreateParamsStreaming:
try:
return cast(
ResponseCreateParamsStreaming,
- build_responses_provider_request(request, reasoning=reasoning),
+ build_responses_request_body(
+ request,
+ provider_model=provider_model,
+ reasoning=reasoning,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=openai_replay_scope(
+ self._provider_name,
+ provider_model,
+ replay_format="responses",
+ ),
+ ),
)
- except ResponsesConversionError as exc:
+ except (ResponsesConversionError, ResponsesRequestEncodingError) as exc:
raise InvalidRequestError(str(exc)) from exc
async def _run_stream(
@@ -126,6 +155,7 @@ class OpenAIResponsesTransport:
request_id: str | None,
response_model: str,
tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope,
) -> AsyncIterator[InferenceEvent]:
execution = self._admission.start_execution(request_id=request_id)
provider_stream = self._run_execution(
@@ -134,6 +164,7 @@ class OpenAIResponsesTransport:
request_id=request_id,
response_model=response_model,
tool_names=tool_names,
+ replay_scope=replay_scope,
execution=execution,
)
try:
@@ -158,6 +189,7 @@ class OpenAIResponsesTransport:
request_id: str | None,
response_model: str,
tool_names: OpenAIToolNameCodec,
+ replay_scope: ReplayCompatibilityScope,
execution: ProviderExecution,
) -> AsyncIterator[InferenceEvent]:
recovery = RecoveryController()
@@ -180,6 +212,7 @@ class OpenAIResponsesTransport:
model=response_model,
input_tokens=input_tokens,
tool_names=tool_names,
+ replay_scope=replay_scope,
)
for event in stream_adapter.start():
for held in recovery.push(event):
diff --git a/src/free_claude_code/providers/opencode/provider.py b/src/free_claude_code/providers/opencode/provider.py
index d48f116d..298d5889 100644
--- a/src/free_claude_code/providers/opencode/provider.py
+++ b/src/free_claude_code/providers/opencode/provider.py
@@ -8,9 +8,7 @@ import httpx
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.model_metadata import ProviderModelInfo
-from free_claude_code.core.anthropic import ReasoningReplayMode
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import InferenceEvent, InferenceRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
@@ -20,6 +18,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
)
from free_claude_code.providers.openai_responses import OpenAIResponsesTransport
@@ -121,32 +120,42 @@ class OpenCodeProvider(OpenAIChatProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
"""Validate synchronously when a route snapshot is already warm."""
snapshot = self._catalog.current_snapshot
if snapshot is None:
return
- route = self._require_route(snapshot, request.model)
- routed = _routed_request(request, route)
+ route = self._require_route(snapshot, provider_model)
if route.transport is OpenCodeUpstreamTransport.RESPONSES:
- self._responses.preflight_stream(routed, reasoning=reasoning)
+ self._responses.preflight_stream(
+ request,
+ provider_model=route.upstream_model_id,
+ reasoning=reasoning,
+ )
return
- super().preflight_stream(routed, reasoning=reasoning)
+ super().preflight_stream(
+ request,
+ provider_model=route.upstream_model_id,
+ reasoning=reasoning,
+ )
def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> AsyncIterator[InferenceEvent]:
return self._dispatch_stream(
request,
+ provider_model=provider_model,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model or request.model,
@@ -155,31 +164,41 @@ class OpenCodeProvider(OpenAIChatProvider):
async def _dispatch_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
input_tokens: int,
request_id: str | None,
response_model: str,
reasoning: ReasoningPolicy,
) -> AsyncIterator[InferenceEvent]:
snapshot = await self._catalog.snapshot(request_id=request_id)
- route = self._require_route(snapshot, request.model)
- routed = _routed_request(request, route)
+ route = self._require_route(snapshot, provider_model)
selected_stream: AsyncIterator[InferenceEvent] | None = None
try:
if route.transport is OpenCodeUpstreamTransport.RESPONSES:
- self._responses.preflight_stream(routed, reasoning=reasoning)
+ self._responses.preflight_stream(
+ request,
+ provider_model=route.upstream_model_id,
+ reasoning=reasoning,
+ )
selected_stream = self._responses.stream_response(
- routed,
+ request,
+ provider_model=route.upstream_model_id,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model,
reasoning=reasoning,
)
else:
- super().preflight_stream(routed, reasoning=reasoning)
+ super().preflight_stream(
+ request,
+ provider_model=route.upstream_model_id,
+ reasoning=reasoning,
+ )
selected_stream = super().stream_response(
- routed,
+ request,
+ provider_model=route.upstream_model_id,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model,
@@ -227,13 +246,3 @@ def create_opencode_provider(
admission=admission,
catalog_client=catalog_client,
)
-
-
-def _routed_request(
- request: MessagesRequest,
- route: OpenCodeModelRoute,
-) -> MessagesRequest:
- return request.model_copy(
- update={"model": route.upstream_model_id},
- deep=True,
- )
diff --git a/src/free_claude_code/providers/vertex/client.py b/src/free_claude_code/providers/vertex/client.py
index 5eb207e5..4b156f48 100644
--- a/src/free_claude_code/providers/vertex/client.py
+++ b/src/free_claude_code/providers/vertex/client.py
@@ -6,7 +6,6 @@ from typing import Any
import httpx
from free_claude_code.application.model_metadata import ProviderModelInfo
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.providers.admission import (
ProviderAdmissionController,
ProviderOperationKind,
@@ -25,6 +24,7 @@ from free_claude_code.providers.model_listing import (
from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
)
from .auth import GoogleAccessTokenProvider
diff --git a/tests/api/model_fallback_support.py b/tests/api/model_fallback_support.py
index e01428ec..50d780ea 100644
--- a/tests/api/model_fallback_support.py
+++ b/tests/api/model_fallback_support.py
@@ -8,9 +8,8 @@ from fastapi.testclient import TestClient
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import MessagesRequest
from free_claude_code.core.failures import ExecutionFailure, FailureKind
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import InferenceEvent, InferenceRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from tests.api.support import create_test_app
from tests.inference_support import text_event_stream
@@ -49,26 +48,28 @@ class ControlledFallbackProvider:
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
- del reasoning
- self.preflight_models.append(request.model)
+ del request, reasoning
+ self.preflight_models.append(provider_model)
if self._preflight_error is not None:
raise self._preflight_error
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
) -> AsyncIterator[InferenceEvent]:
del input_tokens, request_id, reasoning
- self.stream_models.append(request.model)
+ self.stream_models.append(provider_model)
public_model = response_model or request.model
self.response_models.append(public_model)
try:
diff --git a/tests/api/test_api.py b/tests/api/test_api.py
index c2ed2a7b..640f5cac 100644
--- a/tests/api/test_api.py
+++ b/tests/api/test_api.py
@@ -4,6 +4,15 @@ import pytest
from fastapi.testclient import TestClient
from free_claude_code.core.failures import ExecutionFailure, FailureKind
+from free_claude_code.core.inference import (
+ InferenceRequest,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MessageItem,
+ MessageRole,
+ TextContent,
+)
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from tests.api.support import create_test_app
@@ -161,7 +170,7 @@ def test_auto_mode_classifier_without_stream_returns_json(client: TestClient):
assert body["type"] == "message"
assert body["usage"] == {"input_tokens": 0, "output_tokens": 0}
routed_request = _stream_response_calls[0][0][0]
- assert routed_request.stream is False
+ assert isinstance(routed_request, InferenceRequest)
assert _stream_response_calls[0][1]["reasoning"] == ReasoningPolicy.off()
@@ -261,13 +270,16 @@ def test_create_message_preserves_system_role_messages(client: TestClient):
assert response.status_code == 200
routed_request = _stream_response_calls[0][0][0]
- assert [message.role for message in routed_request.messages] == [
- "user",
- "system",
- "user",
- ]
- assert routed_request.messages[1].content == "system prompt"
- assert routed_request.system is None
+ assert routed_request.items == (
+ MessageItem("turn_0", MessageRole.USER, (TextContent("context"),)),
+ InstructionItem(
+ text="system prompt",
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TRANSCRIPT,
+ turn_id="turn_1",
+ ),
+ MessageItem("turn_2", MessageRole.USER, (TextContent("Hi"),)),
+ )
def test_model_mapping(client: TestClient):
@@ -283,7 +295,8 @@ def test_model_mapping(client: TestClient):
assert len(_stream_response_calls) == 1
args = _stream_response_calls[0][0]
kwargs = _stream_response_calls[0][1]
- assert args[0].model != "claude-3-haiku-20240307"
+ assert args[0].model == "claude-3-haiku-20240307"
+ assert kwargs["provider_model"] != args[0].model
assert kwargs["reasoning"] == ReasoningPolicy.provider_default()
diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.py
index 7752b793..f84bd51b 100644
--- a/tests/api/test_api_handlers.py
+++ b/tests/api/test_api_handlers.py
@@ -20,7 +20,13 @@ from free_claude_code.core.anthropic.models import (
TokenCountRequest,
)
from free_claude_code.core.failures import ExecutionFailure, FailureKind
-from free_claude_code.core.inference import InferenceEvent
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ InstructionItem,
+ MessageItem,
+ TextContent,
+)
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from tests.inference_support import text_event_stream
@@ -45,16 +51,20 @@ class FakeProvider:
*,
failure: ExecutionFailure | None = None,
) -> None:
- self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []
- self.requests: list[MessagesRequest] = []
+ self.preflight_calls: list[tuple[InferenceRequest, str, ReasoningPolicy]] = []
+ self.requests: list[InferenceRequest] = []
self.stream_kwargs: list[dict[str, Any]] = []
self.events = text_event_stream("ok") if events is None else events
self.failure = failure
def preflight_stream(
- self, request: MessagesRequest, *, reasoning: ReasoningPolicy
+ self,
+ request: InferenceRequest,
+ *,
+ provider_model: str,
+ reasoning: ReasoningPolicy,
) -> None:
- self.preflight_calls.append((request, reasoning))
+ self.preflight_calls.append((request, provider_model, reasoning))
async def cleanup(self) -> None:
return None
@@ -64,9 +74,10 @@ class FakeProvider:
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
@@ -75,6 +86,7 @@ class FakeProvider:
self.stream_kwargs.append(
{
"input_tokens": input_tokens,
+ "provider_model": provider_model,
"request_id": request_id,
"response_model": response_model,
"reasoning": reasoning,
@@ -126,7 +138,8 @@ async def test_messages_handler_passes_routed_request_and_stream_metadata() -> N
body = await _streaming_body_text(response)
assert "message_start" in body
- assert provider.requests[0].model == "test-model"
+ assert provider.requests[0].model == "nvidia_nim/test-model"
+ assert provider.stream_kwargs[0]["provider_model"] == "test-model"
assert provider.stream_kwargs[0]["input_tokens"] > 0
assert provider.stream_kwargs[0]["request_id"].startswith("req_")
assert provider.stream_kwargs[0]["response_model"] == "nvidia_nim/test-model"
@@ -142,8 +155,9 @@ async def test_messages_handler_preflight_invalid_request_stays_http_error(
class RejectPreflightProvider(FakeProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
raise InvalidRequestError("bad tool shape")
@@ -266,9 +280,10 @@ async def test_messages_handler_stream_false_provider_exception_keeps_status() -
class FailingProvider(FakeProvider):
async def stream_response(
self,
- request: Any,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
@@ -277,6 +292,7 @@ async def test_messages_handler_stream_false_provider_exception_keeps_status() -
self.stream_kwargs.append(
{
"input_tokens": input_tokens,
+ "provider_model": provider_model,
"request_id": request_id,
"response_model": response_model,
"reasoning": reasoning,
@@ -339,12 +355,16 @@ async def test_messages_handler_normalizes_safety_classifier_policy(
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()
+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.off()
- assert provider.requests[0].model == "test-model"
- assert provider.requests[0].system == system
- assert provider.preflight_calls[0][0].stop_sequences is None
- assert provider.requests[0].stop_sequences is None
+ assert provider.requests[0].model == "nvidia_nim/test-model"
+ assert provider.preflight_calls[0][1] == "test-model"
+ assert any(
+ isinstance(item, InstructionItem) and item.text == system
+ for item in provider.requests[0].items
+ )
+ assert provider.preflight_calls[0][0].stop_sequences == ()
+ assert provider.requests[0].stop_sequences == ()
assert request.stop_sequences == [classifier_stop_sequence]
assert _trace_events(
trace_mock, "free_claude_code.api.route.safety_classifier_policy"
@@ -387,9 +407,9 @@ async def test_messages_handler_preserves_thinking_for_non_classifier() -> None:
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
- assert provider.preflight_calls[0][1] == ReasoningPolicy.provider_default()
+ assert provider.preflight_calls[0][2] == ReasoningPolicy.provider_default()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()
- assert provider.requests[0].stop_sequences == ["</severity>"]
+ assert provider.requests[0].stop_sequences == ("</severity>",)
assert (
_trace_events(
trace_mock,
@@ -417,9 +437,9 @@ async def test_messages_handler_keeps_existing_no_thinking_for_classifier() -> N
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()
+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.off()
- assert provider.requests[0].stop_sequences is None
+ assert provider.requests[0].stop_sequences == ()
assert request.stop_sequences == ["</block>"]
assert _trace_events(
trace_mock, "free_claude_code.api.route.safety_classifier_policy"
@@ -455,8 +475,8 @@ async def test_messages_handler_forces_no_thinking_without_classifier_stop_hint(
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()
- assert provider.requests[0].stop_sequences is None
+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()
+ assert provider.requests[0].stop_sequences == ()
assert _trace_events(
trace_mock, "free_claude_code.api.route.safety_classifier_policy"
) == [
@@ -490,13 +510,13 @@ async def test_messages_handler_preserves_unowned_classifier_stop_sequences() ->
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
- assert provider.preflight_calls[0][1] == ReasoningPolicy.off()
- assert provider.preflight_calls[0][0].stop_sequences == [
+ assert provider.preflight_calls[0][2] == ReasoningPolicy.off()
+ assert provider.preflight_calls[0][0].stop_sequences == (
"custom",
"custom",
"tail",
- ]
- assert provider.requests[0].stop_sequences == ["custom", "custom", "tail"]
+ )
+ assert provider.requests[0].stop_sequences == ("custom", "custom", "tail")
assert request.stop_sequences == original_stops
@@ -522,6 +542,33 @@ async def test_messages_handler_optimization_intercepts_before_provider_executio
provider_resolver.assert_not_called()
+async def test_invalid_shortcut_shaped_request_is_rejected_before_interception() -> (
+ None
+):
+ provider_resolver = MagicMock()
+ handler = MessagesHandler(Settings(), provider_resolver=provider_resolver)
+ request = MessagesRequest.model_validate(
+ {
+ "model": "nvidia_nim/test-model",
+ "max_tokens": 100,
+ "messages": [{"role": "user", "content": "quota check"}],
+ "client_extension": True,
+ }
+ )
+
+ with (
+ patch(
+ "free_claude_code.api.handlers.messages.try_optimizations",
+ side_effect=AssertionError("invalid request reached local interception"),
+ ),
+ pytest.raises(InvalidRequestError, match=r"request\.client_extension"),
+ ):
+ await handler.create(request)
+
+ provider_resolver.assert_not_called()
+
+
@pytest.mark.asyncio
async def test_responses_handler_bypasses_message_only_optimizations() -> None:
provider = FakeProvider()
@@ -541,7 +588,14 @@ async def test_responses_handler_bypasses_message_only_optimizations() -> None:
assert isinstance(response, StreamingResponse)
body = await _streaming_body_text(response)
assert "response.completed" in body
- assert provider.requests[0].messages[0].content == "quota check"
+ assert provider.requests[0].message_count == 1
+ assert any(
+ isinstance(item, MessageItem)
+ and item.content
+ and isinstance(item.content[0], TextContent)
+ and item.content[0].text == "quota check"
+ for item in provider.requests[0].items
+ )
@pytest.mark.asyncio
@@ -561,7 +615,7 @@ async def test_responses_handler_does_not_apply_safety_classifier_policy() -> No
assert isinstance(response, StreamingResponse)
await _streaming_body_text(response)
- assert provider.preflight_calls[0][1] == ReasoningPolicy.provider_default()
+ assert provider.preflight_calls[0][2] == ReasoningPolicy.provider_default()
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy.provider_default()
assert (
_trace_events(
@@ -575,7 +629,7 @@ async def test_responses_handler_does_not_apply_safety_classifier_policy() -> No
def test_token_count_handler_routes_and_counts_tokens() -> None:
handler = TokenCountHandler(
Settings(),
- token_counter=lambda messages, system, tools: len(messages) + 41,
+ token_counter=lambda request: request.message_count + 41,
)
with patch("free_claude_code.api.handlers.token_count.trace_event") as trace:
diff --git a/tests/api/test_auth.py b/tests/api/test_auth.py
index f4ebab44..9afbdb41 100644
--- a/tests/api/test_auth.py
+++ b/tests/api/test_auth.py
@@ -19,7 +19,7 @@ def test_proxy_auth_requires_canonical_bearer_header():
"messages": [{"role": "user", "content": "hello"}],
}
- with patch("free_claude_code.api.routes.get_token_count", return_value=1):
+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=1):
r = client.post("/v1/messages/count_tokens", json=payload)
assert r.status_code == 401
assert r.json() == {"detail": "Missing proxy authentication token"}
@@ -59,7 +59,7 @@ def test_proxy_auth_ignores_conflicting_legacy_headers():
"messages": [{"role": "user", "content": "hello"}],
}
- with patch("free_claude_code.api.routes.get_token_count", return_value=2):
+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=2):
r = client.post(
"/v1/messages/count_tokens",
json=payload,
@@ -99,7 +99,7 @@ def test_proxy_auth_token_normalizes_configured_whitespace():
"messages": [{"role": "user", "content": "hello"}],
}
- with patch("free_claude_code.api.routes.get_token_count", return_value=3):
+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=3):
r = client.post(
"/v1/messages/count_tokens",
json=payload,
diff --git a/tests/api/test_execution_failure_contract.py b/tests/api/test_execution_failure_contract.py
index 770a5b4c..015eb2e0 100644
--- a/tests/api/test_execution_failure_contract.py
+++ b/tests/api/test_execution_failure_contract.py
@@ -9,11 +9,11 @@ import pytest
from fastapi.testclient import TestClient
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.inference import (
InferenceEvent,
+ InferenceRequest,
InferenceStreamLedger,
ResponseStarted,
)
@@ -79,22 +79,24 @@ class StalledProvider:
def preflight_stream(
self,
- _request: MessagesRequest,
+ _request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
- del reasoning
+ del provider_model, reasoning
async def stream_response(
self,
- _request: MessagesRequest,
+ _request: InferenceRequest,
*,
input_tokens: int,
+ provider_model: str,
request_id: str,
response_model: str,
reasoning: ReasoningPolicy,
) -> AsyncIterator[InferenceEvent]:
- del input_tokens, request_id, response_model, reasoning
+ del input_tokens, provider_model, request_id, response_model, reasoning
try:
await asyncio.Event().wait()
yield ResponseStarted("response_unreachable", "test-model")
diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.py
index 04184cf1..00496103 100644
--- a/tests/api/test_openai_responses.py
+++ b/tests/api/test_openai_responses.py
@@ -11,18 +11,26 @@ from free_claude_code.core.inference import (
FinishReason,
InferenceEvent,
InferenceStreamLedger,
+ MessageItem,
+ MessageRole,
+ ReasoningItem,
ReplayArtifact,
ReplayArtifactKind,
ReplayArtifactOrigin,
ReplayAttachment,
ResponseStarted,
+ TextContent,
+ ToolCallItem,
ToolCallKind,
+ ToolChoiceMode,
+ ToolResultItem,
)
from free_claude_code.core.reasoning import (
ReasoningControl,
ReasoningEffort,
ReasoningPolicy,
)
+from free_claude_code.core.replay_envelope import decode_replay_envelope
from tests.api.support import create_test_app
from tests.inference_support import reported_usage
@@ -122,10 +130,12 @@ def test_create_response_stream_routes_through_provider(
)
assert provider.preflight_stream.called
routed = provider.requests[0]
- assert routed.model == "test-model"
- assert routed.messages[0].role == "user"
- assert routed.messages[0].content == "Hello"
- assert routed.max_tokens == 32
+ assert routed.model == "nvidia_nim/test-model"
+ assert routed.items == (
+ MessageItem("turn_0", MessageRole.USER, (TextContent("Hello"),)),
+ )
+ assert routed.max_output_tokens == 32
+ assert provider.stream_kwargs[0]["provider_model"] == "test-model"
assert provider.stream_kwargs[0]["request_id"] == response.headers["request-id"]
@@ -182,7 +192,7 @@ def test_create_response_preflight_rejection_stays_an_ordinary_http_error() -> N
assert provider.requests == []
-def test_create_response_accepts_unknown_top_level_extensions(
+def test_create_response_rejects_unknown_top_level_extensions_before_provider(
responses_client: tuple[TestClient, FakeProvider],
) -> None:
client, provider = responses_client
@@ -196,8 +206,51 @@ def test_create_response_accepts_unknown_top_level_extensions(
},
)
- assert response.status_code == 200
- assert provider.requests[0].messages[0].content == "Hello"
+ assert response.status_code == 400
+ assert "provider_extension" in response.json()["error"]["message"]
+ assert provider.requests == []
+
+
+ "override",
+ [
+ {"store": True},
+ {"previous_response_id": "resp_1"},
+ {"include": []},
+ {"prompt_cache_key": ""},
+ {"reasoning": {"summary": "concise"}},
+ {
+ "tools": [{"type": "web_search"}],
+ "tool_choice": "required",
+ },
+ {"tool_choice": {"type": "web_search"}},
+ {"input": [{"type": "input_image", "image_url": "https://invalid"}]},
+ ],
+)
+def test_invalid_responses_semantics_fail_before_provider_resolution(
+ override: dict[str, object],
+) -> None:
+ provider = FakeProvider(_anthropic_text_stream("unused"))
+ app = create_test_app()
+ payload: dict[str, object] = {
+ "model": "nvidia_nim/test-model",
+ "input": "Hello",
+ }
+ payload.update(override)
+
+ with (
+ patch(
+ "free_claude_code.api.routes.resolve_provider",
+ return_value=provider,
+ ) as resolve_provider,
+ TestClient(app) as client,
+ ):
+ response = client.post("/v1/responses", json=payload)
+
+ assert response.status_code == 400
+ resolve_provider.assert_not_called()
+ provider.preflight_stream.assert_not_called()
+ assert provider.requests == []
def test_create_response_pre_start_provider_error_returns_openai_error() -> None:
@@ -284,7 +337,9 @@ def test_create_response_stream_bypasses_local_message_optimizations() -> None:
assert response.status_code == 200
completed = parse_sse_text(response.text)[-1].data["response"]
assert completed["output"][0]["content"][0]["text"] == "Provider response"
- assert provider.requests[0].messages[0].content == "quota check"
+ assert provider.requests[0].items == (
+ MessageItem("turn_0", MessageRole.USER, (TextContent("quota check"),)),
+ )
def test_create_response_stream_false_returns_openai_error(
@@ -416,7 +471,9 @@ def test_create_response_malformed_provider_function_call_fails_stream() -> None
def test_create_response_accepts_codex_namespace_tool_request() -> None:
- provider = FakeProvider(_anthropic_tool_stream(tool_name="mcp__node_repl__js"))
+ provider = FakeProvider(
+ _anthropic_tool_stream(tool_name="js", namespace="mcp__node_repl")
+ )
app = create_test_app()
with (
patch("free_claude_code.api.routes.resolve_provider", return_value=provider),
@@ -451,7 +508,9 @@ def test_create_response_accepts_codex_namespace_tool_request() -> None:
assert response.status_code == 200
routed = provider.requests[0]
- assert [tool.name for tool in routed.tools] == ["mcp__node_repl__js"]
+ assert [(tool.name, tool.namespace) for tool in routed.tools] == [
+ ("js", "mcp__node_repl")
+ ]
completed = parse_sse_text(response.text)[-1].data["response"]
call = completed["output"][0]
assert call["namespace"] == "mcp__node_repl"
@@ -459,7 +518,9 @@ def test_create_response_accepts_codex_namespace_tool_request() -> None:
def test_create_response_accepts_muse_code_request_shape() -> None:
- provider = FakeProvider(_anthropic_tool_stream(tool_name="muse__read_file"))
+ provider = FakeProvider(
+ _anthropic_tool_stream(tool_name="read_file", namespace="muse")
+ )
app = create_test_app()
with (
patch("free_claude_code.api.routes.resolve_provider", return_value=provider),
@@ -502,13 +563,16 @@ def test_create_response_accepts_muse_code_request_shape() -> None:
assert response.status_code == 200
routed = provider.requests[0]
- assert routed.max_tokens == 64
- assert routed.output_config == {"effort": "high"}
+ assert routed.max_output_tokens == 64
+ assert routed.reasoning.control is ReasoningControl.ON
+ assert routed.reasoning.effort is ReasoningEffort.HIGH
assert provider.stream_kwargs[0]["reasoning"] == ReasoningPolicy(
- control=ReasoningControl.DEFAULT,
+ control=ReasoningControl.ON,
effort=ReasoningEffort.HIGH,
)
- assert [tool.name for tool in routed.tools] == ["muse__read_file"]
+ assert [(tool.name, tool.namespace) for tool in routed.tools] == [
+ ("read_file", "muse")
+ ]
completed = parse_sse_text(response.text)[-1].data["response"]
call = completed["output"][0]
assert call["namespace"] == "muse"
@@ -520,6 +584,7 @@ def test_create_response_accepts_codex_custom_tool_request() -> None:
_anthropic_tool_stream(
tool_name="apply_patch",
partial_json='{"input":"*** Begin Patch"}',
+ kind=ToolCallKind.CUSTOM,
)
)
app = create_test_app()
@@ -548,7 +613,10 @@ def test_create_response_accepts_codex_custom_tool_request() -> None:
assert response.status_code == 200
routed = provider.requests[0]
assert [tool.name for tool in routed.tools] == ["apply_patch"]
- assert routed.tool_choice == {"type": "tool", "name": "apply_patch"}
+ assert routed.tool_choice is not None
+ assert routed.tool_choice.mode is ToolChoiceMode.SPECIFIC
+ assert routed.tool_choice.kind is ToolCallKind.CUSTOM
+ assert routed.tool_choice.name == "apply_patch"
events = parse_sse_text(response.text)
assert "response.custom_tool_call_input.delta" in [event.event for event in events]
completed = events[-1].data["response"]
@@ -637,16 +705,19 @@ def test_create_response_replays_prior_reasoning_as_reasoning_content() -> None:
assert response.status_code == 200
routed = provider.requests[0]
- assert routed.messages[0].role == "assistant"
- assert routed.messages[0].reasoning_content == "Need the tool."
- assert routed.messages[0].content[0].type == "tool_use"
- assert routed.messages[1].role == "user"
- assert routed.messages[1].content[0].type == "tool_result"
- assert routed.messages[2].role == "assistant"
- assert routed.messages[2].content == ""
- assert routed.messages[2].reasoning_content == "Use the result."
- assert routed.messages[3].role == "user"
- assert routed.messages[3].content == "continue"
+ assert routed.items == (
+ ReasoningItem("turn_0", "Need the tool."),
+ ToolCallItem(
+ turn_id="turn_0",
+ call_id="call_1",
+ kind=ToolCallKind.FUNCTION,
+ name="echo",
+ input={},
+ ),
+ ToolResultItem("turn_1", "call_1", "ok"),
+ ReasoningItem("turn_2", "Use the result."),
+ MessageItem("turn_3", MessageRole.USER, (TextContent("continue"),)),
+ )
def test_create_response_quarantines_malformed_prior_function_call() -> None:
@@ -681,9 +752,10 @@ def test_create_response_quarantines_malformed_prior_function_call() -> None:
assert response.status_code == 200
routed = provider.requests[0]
- assert [message.role for message in routed.messages] == ["user", "user"]
- assert routed.messages[0].content == "hello"
- assert routed.messages[1].content == "continue"
+ assert routed.items == (
+ MessageItem("turn_0", MessageRole.USER, (TextContent("hello"),)),
+ MessageItem("turn_1", MessageRole.USER, (TextContent("continue"),)),
+ )
completed = parse_sse_text(response.text)[-1].data["response"]
assert completed["output"][0]["content"][0]["text"] == "done"
@@ -695,7 +767,7 @@ def test_create_response_quarantines_malformed_prior_function_call() -> None:
(
{"effort": "low"},
ReasoningPolicy(
- control=ReasoningControl.DEFAULT,
+ control=ReasoningControl.ON,
effort=ReasoningEffort.LOW,
),
),
@@ -723,8 +795,8 @@ def test_create_response_preserves_and_resolves_reasoning_effort(
assert response.status_code == 200
routed = provider.requests[0]
- assert routed.thinking is None
- assert routed.output_config == reasoning
+ assert routed.reasoning.control is expected_policy.control
+ assert routed.reasoning.effort is expected_policy.effort
assert provider.stream_kwargs[0]["reasoning"] == expected_policy
assert provider.preflight_stream.call_args.kwargs["reasoning"] == expected_policy
@@ -747,16 +819,21 @@ def test_create_response_maps_redacted_thinking_to_encrypted_reasoning() -> None
assert response.status_code == 200
completed = parse_sse_text(response.text)[-1].data["response"]
- assert completed["output"] == [
- {
- "id": completed["output"][0]["id"],
- "type": "reasoning",
- "status": "completed",
- "summary": [],
- "encrypted_content": "opaque-redacted",
- }
- ]
- assert "content" not in completed["output"][0]
+ assert len(completed["output"]) == 1
+ output = completed["output"][0]
+ assert output["type"] == "reasoning"
+ assert output["status"] == "completed"
+ assert output["summary"] == []
+ artifacts = decode_replay_envelope(
+ output["encrypted_content"],
+ attachment=ReplayAttachment.REASONING,
+ )
+ assert artifacts is not None
+ assert len(artifacts) == 1
+ assert artifacts[0].origin is ReplayArtifactOrigin.ANTHROPIC
+ assert artifacts[0].kind is ReplayArtifactKind.REDACTED_THINKING
+ assert artifacts[0].payload == "opaque-redacted"
+ assert "content" not in output
def test_create_response_unsupported_tool_returns_openai_error(
@@ -776,7 +853,7 @@ def test_create_response_unsupported_tool_returns_openai_error(
assert response.status_code == 400
payload = response.json()
assert payload["error"]["type"] == "invalid_request_error"
- assert "Unsupported Responses tool type" in payload["error"]["message"]
+ assert "tools[0].type" in payload["error"]["message"]
def _anthropic_text_stream(
@@ -806,6 +883,9 @@ def _anthropic_text_stream(
def _anthropic_tool_stream(
tool_name: str = "echo",
partial_json: str = '{"value":"FCC"}',
+ *,
+ kind: ToolCallKind = ToolCallKind.FUNCTION,
+ namespace: str | None = None,
) -> list[InferenceEvent]:
ledger = InferenceStreamLedger("response_test", "test-model", 3)
events: list[InferenceEvent] = [ledger.start_response()]
@@ -814,7 +894,8 @@ def _anthropic_tool_stream(
0,
"toolu_1",
tool_name,
- kind=ToolCallKind.FUNCTION,
+ kind=kind,
+ namespace=namespace,
)
)
events.append(ledger.emit_tool_delta(0, partial_json))
diff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.py
index a75d70dc..79bea775 100644
--- a/tests/api/test_request_lifetime.py
+++ b/tests/api/test_request_lifetime.py
@@ -21,8 +21,11 @@ from free_claude_code.application.ports import (
TaskController,
)
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import MessagesRequest
-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ InferenceStreamLedger,
+)
from free_claude_code.core.reasoning import ReasoningPolicy
@@ -386,22 +389,24 @@ class _ControlledProvider:
def preflight_stream(
self,
- _request: MessagesRequest,
+ _request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
- del reasoning
+ del provider_model, reasoning
async def stream_response(
self,
- _request: MessagesRequest,
+ _request: InferenceRequest,
*,
input_tokens: int,
+ provider_model: str,
request_id: str,
response_model: str,
reasoning: ReasoningPolicy,
) -> AsyncIterator[InferenceEvent]:
- del input_tokens, response_model, reasoning
+ del input_tokens, provider_model, response_model, reasoning
self.request_ids.append(request_id)
try:
for chunk in self._chunks:
diff --git a/tests/api/test_request_utils.py b/tests/api/test_request_utils.py
index 9312238e..c2a8bc38 100644
--- a/tests/api/test_request_utils.py
+++ b/tests/api/test_request_utils.py
@@ -10,11 +10,27 @@ from free_claude_code.api.detection import (
is_quota_check_request,
is_title_generation_request,
)
-from free_claude_code.core.anthropic import get_token_count
from free_claude_code.core.anthropic.models import (
Message,
MessagesRequest,
- SystemContent,
+)
+from free_claude_code.core.inference import (
+ Base64MediaSource,
+ FunctionTool,
+ ImageContent,
+ InferenceItem,
+ InferenceRequest,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MessageItem,
+ MessageRole,
+ ReasoningItem,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolResultItem,
+ get_inference_token_count,
)
@@ -326,240 +342,145 @@ class TestPrefixDetectionRequest:
assert command == "ls -la"
-class TestGetTokenCount:
- """Tests for get_token_count function."""
-
- def test_empty_messages(self):
- """Test token count with empty messages."""
- count = get_token_count([])
- assert count >= 1 # Returns max(1, tokens)
-
- def test_simple_message(self):
- """Test token count with simple text message."""
- msg = MagicMock()
- msg.content = "Hello world"
-
- count = get_token_count([msg])
- assert count > 0
- # "Hello world" is ~2-3 tokens plus overhead
- assert count >= 3
-
- def test_special_token_text_is_counted_as_plain_text(self):
- """Tiktoken special-token strings should not break token estimates."""
- msg = MagicMock()
- msg.content = "<|endoftext|>"
-
- count = get_token_count([msg], system="<|endoftext|>")
- assert count > 0
-
- def test_message_with_system_prompt(self):
- """Test token count includes system prompt."""
- msg = MagicMock()
- msg.content = "Hello"
-
- count = get_token_count([msg], system="You are a helpful assistant")
- assert count > 0
-
- def test_message_with_list_content(self):
- """Test token count with list content blocks."""
- text_block = MagicMock()
- text_block.type = "text"
- text_block.text = "Hello world"
-
- msg = MagicMock()
- msg.content = [text_block]
-
- count = get_token_count([msg])
- assert count > 0
-
- def test_message_with_thinking_block(self):
- """Test token count includes thinking blocks."""
- thinking_block = MagicMock()
- thinking_block.type = "thinking"
- thinking_block.thinking = "Let me think about this..."
-
- msg = MagicMock()
- msg.content = [thinking_block]
+def _message(turn_id: str, text: str) -> MessageItem:
+ return MessageItem(
+ turn_id=turn_id,
+ role=MessageRole.USER,
+ content=(TextContent(text),),
+ )
- count = get_token_count([msg])
- assert count > 0
- def test_message_with_tool_use(self):
- """Test token count includes tool use blocks."""
- tool_block = MagicMock()
- tool_block.type = "tool_use"
- tool_block.name = "search"
- tool_block.input = {"query": "test"}
+def _token_request(
+ *items: InferenceItem,
+ tools: tuple[FunctionTool, ...] = (),
+) -> InferenceRequest:
+ return InferenceRequest(model="provider/model", items=items, tools=tools)
- msg = MagicMock()
- msg.content = [tool_block]
- count = get_token_count([msg])
- assert count > 0
+class TestGetInferenceTokenCount:
+ """Canonical token accounting uses the same transcript as execution."""
- def test_message_with_tool_result(self):
- """Test token count includes tool result blocks."""
- result_block = MagicMock()
- result_block.type = "tool_result"
- result_block.content = "Search results here"
+ def test_empty_request_has_nonzero_floor(self) -> None:
+ assert get_inference_token_count(_token_request()) == 1
- msg = MagicMock()
- msg.content = [result_block]
-
- count = get_token_count([msg])
- assert count > 0
-
- def test_message_with_tools(self):
- """Test token count includes tool definitions."""
- msg = MagicMock()
- msg.content = "Use the search tool"
-
- tool = MagicMock()
- tool.name = "search"
- tool.description = "Search for information"
- tool.input_schema = {"type": "object", "properties": {}}
-
- count = get_token_count([msg], tools=[tool])
- assert count > 0
-
- def test_system_as_list(self):
- """Test token count with system as list of blocks."""
- msg = MagicMock()
- msg.content = "Hello"
+ def test_plain_and_special_token_text_are_counted(self) -> None:
+ ordinary = get_inference_token_count(_token_request(_message("turn_0", "Hi")))
+ special = get_inference_token_count(
+ _token_request(_message("turn_0", "<|endoftext|>"))
+ )
- block = MagicMock()
- block.text = "System prompt"
+ assert ordinary > 0
+ assert special > 0
+
+ def test_top_level_instruction_contributes_content_and_overhead(self) -> None:
+ message = _message("turn_0", "Hello")
+ without_instruction = get_inference_token_count(_token_request(message))
+ with_instruction = get_inference_token_count(
+ _token_request(
+ InstructionItem(
+ text="You are a helpful assistant.",
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ ),
+ message,
+ )
+ )
- count = get_token_count([msg], system=[block])
- assert count > 0
+ assert with_instruction >= without_instruction + 4
- def test_tool_result_with_dict_content(self):
- """Test token count with tool result containing dict content."""
- result_block = MagicMock()
- result_block.type = "tool_result"
- result_block.content = {"result": "data"}
+ def test_transcript_instruction_contributes_to_same_turn(self) -> None:
+ message = _message("turn_0", "Hello")
+ instruction = InstructionItem(
+ text="New instructions",
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TRANSCRIPT,
+ turn_id="turn_1",
+ )
- msg = MagicMock()
- msg.content = [result_block]
+ assert get_inference_token_count(
+ _token_request(message, instruction)
+ ) > get_inference_token_count(_token_request(message))
+
+ def test_reasoning_tool_call_and_tool_result_are_counted(self) -> None:
+ request = _token_request(
+ _message("turn_0", "Use the search tool"),
+ ReasoningItem(turn_id="turn_1", reasoning="Need current information"),
+ ToolCallItem(
+ turn_id="turn_1",
+ call_id="call_abc123",
+ kind=ToolCallKind.FUNCTION,
+ name="search",
+ input={"query": "test"},
+ ),
+ ToolResultItem(
+ turn_id="turn_2",
+ call_id="call_abc123",
+ content={"result": "data"},
+ ),
+ )
- count = get_token_count([msg])
- assert count > 0
+ assert get_inference_token_count(request) > 0
+
+ def test_tool_definition_contributes_to_count(self) -> None:
+ message = _message("turn_0", "Use the search tool")
+ without_tool = get_inference_token_count(_token_request(message))
+ with_tool = get_inference_token_count(
+ _token_request(
+ message,
+ tools=(
+ FunctionTool(
+ name="search",
+ description="Search for information",
+ input_schema={"type": "object", "properties": {}},
+ ),
+ ),
+ )
+ )
- def test_multiple_messages_overhead(self):
- """Test that multiple messages include overhead."""
- msg1 = MagicMock()
- msg1.content = "Hi"
+ assert with_tool > without_tool
+
+ def test_multiple_messages_include_per_turn_overhead(self) -> None:
+ first = _message("turn_0", "Hi")
+ second = _message("turn_1", "Hello")
+
+ assert get_inference_token_count(
+ _token_request(first, second)
+ ) > get_inference_token_count(_token_request(first))
+
+ def test_base64_image_uses_media_floor(self) -> None:
+ request = _token_request(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(
+ ImageContent(
+ Base64MediaSource(
+ media_type="image/png",
+ data="x" * 3_000,
+ )
+ ),
+ ),
+ )
+ )
- msg2 = MagicMock()
- msg2.content = "Hello"
+ assert get_inference_token_count(request) >= 85
- count_single = get_token_count([msg1])
- count_double = get_token_count([msg1, msg2])
-
- # Double message should have more tokens (including overhead)
- assert count_double > count_single
-
- def test_inline_system_message_contributes_to_token_count(self):
- """Mid-conversation system content remains part of the counted transcript."""
- user_message = Message(role="user", content="Hello")
- inline_system = Message(role="system", content="New instructions")
-
- without_inline_system = get_token_count([user_message])
- with_inline_system = get_token_count([user_message, inline_system])
-
- assert with_inline_system > without_inline_system
-
- def test_per_message_overhead_four_tokens(self):
- """Per-message overhead is 4 tokens (was 3)."""
- msg = MagicMock()
- msg.content = "x" # Minimal content
- count = get_token_count([msg])
- # 1 msg * 4 overhead + content tokens
- assert count >= 5
-
- def test_system_overhead_added(self):
- """System prompt adds ~4 tokens overhead."""
- msg = MagicMock()
- msg.content = "Hi"
- count_no_sys = get_token_count([msg])
- count_with_sys = get_token_count([msg], system="You are helpful")
- assert count_with_sys >= count_no_sys + 4
-
- def test_system_as_typed_content_blocks(self):
- """Typed system content blocks are counted."""
- msg = MagicMock()
- msg.content = "Hi"
- count_no_sys = get_token_count([msg])
- system_blocks = [
- SystemContent(type="text", text="System prompt from typed block")
- ]
- count_with_system = get_token_count([msg], system=system_blocks)
- assert count_with_system > count_no_sys
-
- def test_tool_use_includes_id(self):
- """Tool use blocks count id field."""
- tool_block = MagicMock()
- tool_block.type = "tool_use"
- tool_block.name = "search"
- tool_block.input = {"q": "test"}
- tool_block.id = "call_abc123"
- msg = MagicMock()
- msg.content = [tool_block]
- count = get_token_count([msg])
- assert count > 0
-
- def test_tool_result_includes_tool_use_id(self):
- """Tool result blocks count tool_use_id field."""
- result_block = MagicMock()
- result_block.type = "tool_result"
- result_block.content = "ok"
- result_block.tool_use_id = "call_xyz"
- msg = MagicMock()
- msg.content = [result_block]
- count = get_token_count([msg])
- assert count > 0
-
- def test_unrecognized_block_type_fallback(self):
- """Unrecognized block types are tokenized via json.dumps fallback."""
- unknown_block = {"type": "custom", "spec": "data"}
- msg = MagicMock()
- msg.content = [unknown_block]
- count = get_token_count([msg])
- assert count > 0
-
- def test_message_with_image_block(self):
- """Test token count includes image blocks."""
- image_block = MagicMock()
- image_block.type = "image"
- image_block.source = {
- "type": "base64",
- "media_type": "image/png",
- "data": "x" * 3000,
- }
- msg = MagicMock()
- msg.content = [image_block]
- count = get_token_count([msg])
- assert count >= 85
-
- def test_image_block_with_dict_source(self):
- """Image block with dict-style source is counted."""
- image_block = {"type": "image", "source": {"data": "a" * 10000}}
- msg = MagicMock()
- msg.content = [image_block]
- count = get_token_count([msg])
- assert count >= 85
-
- def test_known_payload_structural_overhead(self):
- """Protocol overhead remains separate from plain-text estimation."""
+ def test_known_payload_structural_overhead(self) -> None:
system_text = "You are a helpful assistant."
user_text = "Hello, how are you?"
- msg = MagicMock()
- msg.content = user_text
+ request = _token_request(
+ InstructionItem(
+ text=system_text,
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ ),
+ _message("turn_0", user_text),
+ )
with patch(
- "free_claude_code.core.anthropic.tokens.estimate_text_tokens",
+ "free_claude_code.core.inference.tokens.estimate_text_tokens",
side_effect=len,
):
- count = get_token_count([msg], system=system_text)
+ count = get_inference_token_count(request)
assert count == len(system_text) + len(user_text) + 4 + 4
diff --git a/tests/api/test_routes_optimizations.py b/tests/api/test_routes_optimizations.py
index 84ec12e3..3ea5c3f1 100644
--- a/tests/api/test_routes_optimizations.py
+++ b/tests/api/test_routes_optimizations.py
@@ -128,7 +128,7 @@ def test_count_tokens_endpoint(client):
"messages": [{"role": "user", "content": "hello"}],
}
- with patch("free_claude_code.api.routes.get_token_count", return_value=5):
+ with patch("free_claude_code.api.routes.get_inference_token_count", return_value=5):
response = client.post("/v1/messages/count_tokens", json=payload)
assert response.status_code == 200
@@ -136,14 +136,14 @@ def test_count_tokens_endpoint(client):
def test_count_tokens_error_returns_500(client):
- """When get_token_count raises, count_tokens returns 500."""
+ """When canonical token counting raises, count_tokens returns 500."""
payload = {
"model": "claude-3-sonnet",
"messages": [{"role": "user", "content": "hello"}],
}
with patch(
- "free_claude_code.api.routes.get_token_count",
+ "free_claude_code.api.routes.get_inference_token_count",
side_effect=RuntimeError("token error"),
):
response = client.post("/v1/messages/count_tokens", json=payload)
diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.py
index c1f475a6..a2219867 100644
--- a/tests/api/test_web_server_tools.py
+++ b/tests/api/test_web_server_tools.py
@@ -33,7 +33,7 @@ from free_claude_code.application.routing import (
ModelRouter,
ProviderModelTarget,
ResolvedModelRoute,
- RoutedMessagesRequest,
+ RoutedInferenceRequest,
)
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.reasoning import ReasoningPreference
@@ -53,7 +53,9 @@ from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.inference import (
FinishReason,
InferenceEvent,
+ InferenceRequest,
InferenceStreamLedger,
+ ToolChoiceMode,
)
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.core.version import package_version
@@ -87,9 +89,9 @@ class FixedProviderModelRouter(ModelRouter):
self._fixed_provider_id = provider_id
self._fixed_provider_model = provider_model
- def resolve_messages_request(
- self, request: MessagesRequest
- ) -> RoutedMessagesRequest:
+ def resolve_inference_request(
+ self, request: InferenceRequest
+ ) -> RoutedInferenceRequest:
provider_model = self._fixed_provider_model or request.model
target = ProviderModelTarget(
provider_id=self._fixed_provider_id,
@@ -102,10 +104,8 @@ class FixedProviderModelRouter(ModelRouter):
fallbacks=(),
reasoning_preference=ReasoningPreference.OFF,
)
- routed = request.model_copy(deep=True)
- routed.model = resolved.primary.provider_model
- return RoutedMessagesRequest(
- request=routed,
+ return RoutedInferenceRequest(
+ request=request,
resolved=resolved,
reasoning=ReasoningPolicy.off(),
)
@@ -127,19 +127,24 @@ class ScriptedSelectionProvider:
self.failure_after_events = failure_after_events
self.wait_for = wait_for
self.started = asyncio.Event()
- self.requests: list[MessagesRequest] = []
+ self.requests: list[InferenceRequest] = []
self.stream_kwargs: list[dict[str, object]] = []
self.close_count = 0
def preflight_stream(
- self, request: MessagesRequest, *, reasoning: ReasoningPolicy
+ self,
+ request: InferenceRequest,
+ *,
+ provider_model: str,
+ reasoning: ReasoningPolicy,
) -> None:
return None
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
input_tokens: int,
request_id: str,
response_model: str,
@@ -149,6 +154,7 @@ class ScriptedSelectionProvider:
self.stream_kwargs.append(
{
"input_tokens": input_tokens,
+ "provider_model": provider_model,
"request_id": request_id,
"response_model": response_model,
"reasoning": reasoning,
@@ -506,13 +512,14 @@ async def test_automatic_web_search_replays_provider_response_when_declined(
assert provider.close_count == 1
assert len(provider.requests) == 1
translated = provider.requests[0]
- assert translated.model == "upstream-model"
- assert translated.tool_choice == {"type": "auto"}
- assert translated.tools is not None
+ assert translated.model == "claude-haiku-4-5-20251001"
+ assert translated.tool_choice is not None
+ assert translated.tool_choice.mode is ToolChoiceMode.AUTO
assert [tool.name for tool in translated.tools] == [HIDDEN_WEB_SEARCH_NAME]
assert provider.stream_kwargs == [
{
"input_tokens": provider.stream_kwargs[0]["input_tokens"],
+ "provider_model": "upstream-model",
"request_id": "req_automatic_declined",
"response_model": "claude-haiku-4-5-20251001",
"reasoning": ReasoningPolicy.off(),
diff --git a/tests/application/test_execution.py b/tests/application/test_execution.py
index 43076af8..ee413221 100644
--- a/tests/application/test_execution.py
+++ b/tests/application/test_execution.py
@@ -2,6 +2,7 @@
import asyncio
from collections.abc import AsyncIterator
+from dataclasses import FrozenInstanceError
from unittest.mock import MagicMock, patch
import pytest
@@ -11,13 +12,19 @@ from free_claude_code.application.execution import ProviderExecutor
from free_claude_code.application.routing import (
ProviderModelTarget,
ResolvedModelRoute,
- RoutedMessagesRequest,
+ RoutedInferenceRequest,
)
from free_claude_code.config.reasoning import ReasoningPreference
-from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.core.async_iterators import AsyncCloseable
from free_claude_code.core.failures import ExecutionFailure, FailureKind
-from free_claude_code.core.inference import InferenceEvent, TextDelta
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ MessageItem,
+ MessageRole,
+ TextContent,
+ TextDelta,
+)
from free_claude_code.core.reasoning import ReasoningPolicy
@@ -27,29 +34,32 @@ def _event(label: str) -> TextDelta:
class FakeProvider:
def __init__(self) -> None:
- self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []
+ self.preflight_calls: list[tuple[InferenceRequest, str, ReasoningPolicy]] = []
self.stream_calls: list[dict[str, object]] = []
self.stream_close_calls = 0
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
- self.preflight_calls.append((request, reasoning))
+ self.preflight_calls.append((request, provider_model, reasoning))
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
) -> AsyncIterator[InferenceEvent]:
self._record_stream_call(
request,
+ provider_model=provider_model,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model,
@@ -62,8 +72,9 @@ class FakeProvider:
def _record_stream_call(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
input_tokens: int,
request_id: str | None,
response_model: str | None,
@@ -72,6 +83,7 @@ class FakeProvider:
self.stream_calls.append(
{
"request": request,
+ "provider_model": provider_model,
"input_tokens": input_tokens,
"request_id": request_id,
"response_model": response_model,
@@ -108,15 +120,17 @@ class ControlledProvider(FakeProvider):
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
) -> AsyncIterator[InferenceEvent]:
self._record_stream_call(
request,
+ provider_model=provider_model,
input_tokens=input_tokens,
request_id=request_id,
response_model=response_model,
@@ -142,8 +156,9 @@ class ControlledProvider(FakeProvider):
class FailingPreflightProvider(FakeProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
raise ValueError("invalid provider request")
@@ -156,8 +171,9 @@ class ApplicationErrorPreflightProvider(FakeProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy,
) -> None:
raise self._error
@@ -166,9 +182,10 @@ class ApplicationErrorPreflightProvider(FakeProvider):
class FailingStreamConstructionProvider(FakeProvider):
def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy,
@@ -186,12 +203,18 @@ def _target(provider_id: str, provider_model: str) -> ProviderModelTarget:
def _routed_request(
*fallbacks: ProviderModelTarget,
-) -> RoutedMessagesRequest:
- request = MessagesRequest(
+) -> RoutedInferenceRequest:
+ request = InferenceRequest(
model="provider-model",
- messages=[Message(role="user", content="hello")],
+ items=(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("hello"),),
+ ),
+ ),
)
- return RoutedMessagesRequest(
+ return RoutedInferenceRequest(
request=request,
resolved=ResolvedModelRoute(
original_model="gateway-model",
@@ -211,7 +234,7 @@ def _executor_stream(
) -> AsyncIterator[InferenceEvent]:
executor = ProviderExecutor(
lambda _provider_id: provider,
- token_counter=lambda _messages, _system, _tools: 17,
+ token_counter=lambda _request: 17,
progress_timeout_seconds=timeout_seconds,
)
return executor.stream(
@@ -231,22 +254,25 @@ async def test_executor_uses_structural_provider_port_and_preflights_eagerly() -
executor = ProviderExecutor(
lambda _provider_id: provider,
progress_timeout_seconds=60.0,
- token_counter=lambda _messages, _system, _tools: 17,
+ token_counter=lambda _request: 17,
)
stream = executor.stream(
routed,
wire_api="messages",
raw_log_label="FULL_PAYLOAD",
- raw_log_payload=request.model_dump(),
+ raw_log_payload={},
request_id="req_application",
)
- assert provider.preflight_calls == [(request, ReasoningPolicy.on())]
+ assert provider.preflight_calls == [
+ (request, "provider-model", ReasoningPolicy.on())
+ ]
assert [chunk async for chunk in stream] == [_event("provider-event")]
assert provider.stream_calls == [
{
"request": request,
+ "provider_model": "provider-model",
"input_tokens": 17,
"request_id": "req_application",
"response_model": "gateway-model",
@@ -310,7 +336,7 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primary
executor = ProviderExecutor(
resolve,
- token_counter=lambda _messages, _system, _tools: 17,
+ token_counter=lambda _request: 17,
progress_timeout_seconds=60.0,
generation_id=7,
)
@@ -332,9 +358,11 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primary
assert order == ["fallback-resolved"]
assert primary.stream_close_calls == 1
assert fallback.stream_close_calls == 1
- assert fallback.preflight_calls[0][0].model == "fallback-model"
+ assert fallback.preflight_calls[0][0].model == "provider-model"
+ assert fallback.preflight_calls[0][1] == "fallback-model"
assert fallback.stream_calls[0] == {
"request": fallback.preflight_calls[0][0],
+ "provider_model": "fallback-model",
"input_tokens": 17,
"request_id": "req_fallback",
"response_model": "gateway-model",
@@ -559,31 +587,15 @@ async def test_lazy_fallback_preflight_application_error_stops_unchanged() -> No
@pytest.mark.asyncio
-async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:
- class MutatingProvider(ControlledProvider):
- async def stream_response(
- self,
- request: MessagesRequest,
- input_tokens: int = 0,
- *,
- request_id: str | None = None,
- response_model: str | None = None,
- reasoning: ReasoningPolicy,
- ) -> AsyncIterator[InferenceEvent]:
- request.messages[0].content = "mutated"
- async for chunk in super().stream_response(
- request,
- input_tokens,
- request_id=request_id,
- response_model=response_model,
- reasoning=reasoning,
- ):
- yield chunk
-
- primary = MutatingProvider([_execution_failure("primary")])
+async def test_candidate_request_is_immutable_and_models_are_explicit() -> None:
+ primary = ControlledProvider([_execution_failure("primary")])
fallback = FakeProvider()
providers = {"provider": primary, "fallback": fallback}
routed = _routed_request(_target("fallback", "model"))
+ field_name = "model"
+ with pytest.raises(FrozenInstanceError):
+ setattr(routed.request, field_name, "mutated")
+
executor = ProviderExecutor(
providers.__getitem__,
progress_timeout_seconds=60.0,
@@ -599,10 +611,11 @@ async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:
request_id="req_isolated",
)
]
- fallback_request = fallback.stream_calls[0]["request"]
- assert isinstance(fallback_request, MessagesRequest)
- assert fallback_request.messages[0].content == "hello"
- assert routed.request.messages[0].content == "hello"
+ assert primary.stream_calls[0]["request"] is routed.request
+ assert primary.stream_calls[0]["provider_model"] == "provider-model"
+ assert fallback.stream_calls[0]["request"] is routed.request
+ assert fallback.stream_calls[0]["provider_model"] == "model"
+ assert routed.request.model == "provider-model"
@pytest.mark.asyncio
@@ -612,7 +625,7 @@ async def test_closing_executor_stream_closes_provider_stream_once() -> None:
executor = ProviderExecutor(
lambda _provider_id: provider,
progress_timeout_seconds=60.0,
- token_counter=lambda _messages, _system, _tools: 17,
+ token_counter=lambda _request: 17,
)
stream = executor.stream(
routed,
@@ -642,7 +655,7 @@ async def test_stream_construction_failure_remains_deferred_to_iteration() -> No
executor = ProviderExecutor(
resolve,
progress_timeout_seconds=60.0,
- token_counter=lambda _messages, _system, _tools: 17,
+ token_counter=lambda _request: 17,
)
stream = executor.stream(
@@ -779,9 +792,9 @@ async def test_empty_chunks_do_not_renew_provider_progress() -> None:
@pytest.mark.asyncio
async def test_fallback_transition_does_not_reset_shared_progress_deadline() -> None:
- timeout_seconds = 0.2
+ timeout_seconds = 0.3
primary = ControlledProvider(
- [DelayStep(0.06), _execution_failure("primary overloaded")]
+ [DelayStep(0.12), _execution_failure("primary overloaded")]
)
fallback_wait = WaitStep()
fallback = ControlledProvider([fallback_wait])
@@ -809,7 +822,7 @@ async def test_fallback_transition_does_not_reset_shared_progress_deadline() ->
elapsed = loop.time() - started
assert fallback_wait.started.is_set()
assert exc_info.value.kind == FailureKind.TIMEOUT
- assert elapsed < 0.24
+ assert elapsed < 0.4
assert primary.stream_close_calls == fallback.stream_close_calls == 1
timeout_trace = next(
call.kwargs
diff --git a/tests/application/test_reasoning.py b/tests/application/test_reasoning.py
index fbbc527a..dbd99500 100644
--- a/tests/application/test_reasoning.py
+++ b/tests/application/test_reasoning.py
@@ -5,7 +5,7 @@ from free_claude_code.application.reasoning import (
resolve_reasoning_policy,
)
from free_claude_code.config.reasoning import ReasoningPreference
-from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import ClientReasoningIntent
from free_claude_code.core.reasoning import (
ReasoningControl,
ReasoningEffort,
@@ -13,24 +13,19 @@ from free_claude_code.core.reasoning import (
)
-def _request(**overrides) -> MessagesRequest:
- payload = {
- "model": "provider/model",
- "messages": [{"role": "user", "content": "hello"}],
- }
- payload.update(overrides)
- return MessagesRequest.model_validate(payload)
-
-
def test_client_without_reasoning_control_uses_provider_default() -> None:
- assert client_reasoning_policy(_request()) == ReasoningPolicy.provider_default()
+ assert (
+ client_reasoning_policy(ClientReasoningIntent())
+ == ReasoningPolicy.provider_default()
+ )
def test_client_reasoning_preserves_effort_and_exact_budget() -> None:
policy = client_reasoning_policy(
- _request(
- thinking={"type": "enabled", "budget_tokens": 4096},
- output_config={"effort": "xhigh"},
+ ClientReasoningIntent(
+ control=ReasoningControl.ON,
+ effort=ReasoningEffort.XHIGH,
+ budget_tokens=4096,
)
)
@@ -41,7 +36,7 @@ def test_client_reasoning_preserves_effort_and_exact_budget() -> None:
def test_named_effort_preserves_intent_without_exact_client_budget() -> None:
- policy = client_reasoning_policy(_request(output_config={"effort": "high"}))
+ policy = client_reasoning_policy(ClientReasoningIntent(effort=ReasoningEffort.HIGH))
assert policy == ReasoningPolicy(
control=ReasoningControl.DEFAULT,
@@ -51,21 +46,10 @@ def test_named_effort_preserves_intent_without_exact_client_budget() -> None:
assert policy.requests_reasoning is True
-def test_invalid_budget_does_not_implicitly_enable_reasoning() -> None:
- policy = client_reasoning_policy(_request(thinking={"budget_tokens": 0}))
-
- assert policy == ReasoningPolicy.provider_default()
-
-
- "messages_request",
- [
- _request(thinking={"type": "disabled"}),
- _request(output_config={"effort": "none"}),
- ],
-)
-def test_client_disable_is_explicit(messages_request: MessagesRequest) -> None:
- policy = client_reasoning_policy(messages_request)
+def test_client_disable_is_explicit() -> None:
+ policy = client_reasoning_policy(
+ ClientReasoningIntent(control=ReasoningControl.OFF)
+ )
assert policy.control is ReasoningControl.OFF
assert policy.output_enabled is False
@@ -74,9 +58,9 @@ def test_client_disable_is_explicit(messages_request: MessagesRequest) -> None:
def test_disabled_thinking_preserves_independent_effort_intent() -> None:
policy = client_reasoning_policy(
- _request(
- thinking={"type": "disabled"},
- output_config={"effort": "medium"},
+ ClientReasoningIntent(
+ control=ReasoningControl.OFF,
+ effort=ReasoningEffort.MEDIUM,
)
)
@@ -89,7 +73,7 @@ def test_disabled_thinking_preserves_independent_effort_intent() -> None:
def test_fixed_route_effort_overrides_client_disable() -> None:
policy = resolve_reasoning_policy(
- _request(thinking={"type": "disabled"}),
+ ClientReasoningIntent(control=ReasoningControl.OFF),
ReasoningPreference.MAX,
)
@@ -98,7 +82,10 @@ def test_fixed_route_effort_overrides_client_disable() -> None:
def test_fixed_off_overrides_client_enable() -> None:
policy = resolve_reasoning_policy(
- _request(thinking={"type": "enabled", "budget_tokens": 1024}),
+ ClientReasoningIntent(
+ control=ReasoningControl.ON,
+ budget_tokens=1024,
+ ),
ReasoningPreference.OFF,
)
@@ -106,16 +93,16 @@ def test_fixed_off_overrides_client_enable() -> None:
def test_client_preference_preserves_client_policy() -> None:
- request = _request(output_config={"effort": "low"})
+ intent = ClientReasoningIntent(effort=ReasoningEffort.LOW)
assert resolve_reasoning_policy(
- request, ReasoningPreference.CLIENT
- ) == client_reasoning_policy(request)
+ intent, ReasoningPreference.CLIENT
+ ) == client_reasoning_policy(intent)
def test_unresolved_inherit_is_rejected() -> None:
with pytest.raises(ValueError, match="must be resolved"):
- resolve_reasoning_policy(_request(), ReasoningPreference.INHERIT)
+ resolve_reasoning_policy(ClientReasoningIntent(), ReasoningPreference.INHERIT)
@pytest.mark.parametrize("budget", [0, -1, True])
diff --git a/tests/application/test_routing.py b/tests/application/test_routing.py
index 009b7c90..13013fa5 100644
--- a/tests/application/test_routing.py
+++ b/tests/application/test_routing.py
@@ -7,11 +7,7 @@ from free_claude_code.application.routing import ModelRouter
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.reasoning import ReasoningPreference
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic.models import (
- Message,
- MessagesRequest,
- TokenCountRequest,
-)
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort
@@ -31,6 +27,10 @@ def settings():
return settings
+def _request(model: str) -> InferenceRequest:
+ return InferenceRequest(model=model, items=())
+
+
def test_model_router_resolves_default_model(settings):
resolved = ModelRouter(settings).resolve("claude-3-opus")
@@ -45,14 +45,10 @@ def test_model_router_resolves_default_model(settings):
def test_model_router_applies_opus_override(settings):
settings.model_opus = "open_router/deepseek/deepseek-r1"
- request = MessagesRequest(
- model="claude-opus-4-20250514",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
- routed = ModelRouter(settings).resolve_messages_request(request)
+ request = _request("claude-opus-4-20250514")
+ routed = ModelRouter(settings).resolve_inference_request(request)
- assert routed.request.model == "deepseek/deepseek-r1"
+ assert routed.request.model == "claude-opus-4-20250514"
assert (
routed.resolved.primary.provider_model_ref == "open_router/deepseek/deepseek-r1"
)
@@ -64,15 +60,9 @@ def test_model_router_applies_opus_override(settings):
def test_model_router_applies_fable_override(settings):
settings.model_fable = "open_router/anthropic/claude-fable-5"
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="claude-fable-5",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
- )
+ routed = ModelRouter(settings).resolve_inference_request(_request("claude-fable-5"))
- assert routed.request.model == "anthropic/claude-fable-5"
+ assert routed.request.model == "claude-fable-5"
assert (
routed.resolved.primary.provider_model_ref
== "open_router/anthropic/claude-fable-5"
@@ -110,30 +100,22 @@ def test_model_router_resolves_route_reasoning_preferences(settings):
def test_model_router_applies_haiku_override(settings):
settings.model_haiku = "lmstudio/qwen2.5-7b"
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="claude-3-haiku-20240307",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("claude-3-haiku-20240307")
)
- assert routed.request.model == "qwen2.5-7b"
+ assert routed.request.model == "claude-3-haiku-20240307"
assert routed.resolved.primary.provider_model_ref == "lmstudio/qwen2.5-7b"
def test_model_router_applies_sonnet_override(settings):
settings.model_sonnet = "nvidia_nim/meta/llama-3.3-70b-instruct"
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="claude-sonnet-4-20250514",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("claude-sonnet-4-20250514")
)
- assert routed.request.model == "meta/llama-3.3-70b-instruct"
+ assert routed.request.model == "claude-sonnet-4-20250514"
assert (
routed.resolved.primary.provider_model_ref
== "nvidia_nim/meta/llama-3.3-70b-instruct"
@@ -141,15 +123,11 @@ def test_model_router_applies_sonnet_override(settings):
def test_model_router_routes_prefixed_provider_model_directly(settings):
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="deepseek/deepseek-chat",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("deepseek/deepseek-chat")
)
- assert routed.request.model == "deepseek-chat"
+ assert routed.request.model == "deepseek/deepseek-chat"
assert routed.resolved.original_model == "deepseek/deepseek-chat"
assert routed.resolved.primary.provider_id == "deepseek"
assert routed.resolved.primary.provider_model == "deepseek-chat"
@@ -157,59 +135,43 @@ def test_model_router_routes_prefixed_provider_model_directly(settings):
def test_model_router_routes_explicit_opencode_zen_prefix(settings):
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="opencode_zen/kimi-k2.6",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("opencode_zen/kimi-k2.6")
)
- assert routed.request.model == "kimi-k2.6"
+ assert routed.request.model == "opencode_zen/kimi-k2.6"
assert routed.resolved.primary.provider_id == "opencode_zen"
assert routed.resolved.primary.provider_model_ref == "opencode_zen/kimi-k2.6"
def test_model_router_routes_wafer_provider_model_directly(settings):
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="wafer/DeepSeek-V4-Pro",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("wafer/DeepSeek-V4-Pro")
)
- assert routed.request.model == "DeepSeek-V4-Pro"
+ assert routed.request.model == "wafer/DeepSeek-V4-Pro"
assert routed.resolved.primary.provider_id == "wafer"
assert routed.resolved.primary.provider_model == "DeepSeek-V4-Pro"
assert routed.resolved.primary.provider_model_ref == "wafer/DeepSeek-V4-Pro"
def test_model_router_routes_minimax_provider_model_directly(settings):
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="minimax/MiniMax-M3",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("minimax/MiniMax-M3")
)
- assert routed.request.model == "MiniMax-M3"
+ assert routed.request.model == "minimax/MiniMax-M3"
assert routed.resolved.primary.provider_id == "minimax"
assert routed.resolved.primary.provider_model == "MiniMax-M3"
assert routed.resolved.primary.provider_model_ref == "minimax/MiniMax-M3"
def test_model_router_routes_gateway_encoded_provider_model_directly(settings):
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro")
)
- assert routed.request.model == "deepseek-ai/deepseek-v4-pro"
+ assert routed.request.model == "anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"
assert (
routed.resolved.original_model
== "anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"
@@ -223,15 +185,14 @@ def test_model_router_routes_gateway_encoded_provider_model_directly(settings):
def test_model_router_routes_no_thinking_gateway_model_directly(settings):
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro",
- max_tokens=100,
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro")
)
- assert routed.request.model == "deepseek-ai/deepseek-v4-pro"
+ assert (
+ routed.request.model
+ == "claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro"
+ )
assert (
routed.resolved.original_model
== "claude-3-freecc-no-thinking/nvidia_nim/deepseek-ai/deepseek-v4-pro"
@@ -245,11 +206,8 @@ def test_direct_provider_model_uses_root_policy_without_model_name_guessing(sett
settings.reasoning_policy = ReasoningPreference.LOW
settings.reasoning_opus = ReasoningPreference.MAX
- routed = ModelRouter(settings).resolve_messages_request(
- MessagesRequest(
- model="open_router/anthropic/claude-opus-4",
- messages=[Message(role="user", content="hello")],
- )
+ routed = ModelRouter(settings).resolve_inference_request(
+ _request("open_router/anthropic/claude-opus-4")
)
assert routed.resolved.primary.provider_id == "open_router"
@@ -260,13 +218,11 @@ def test_direct_provider_model_uses_root_policy_without_model_name_guessing(sett
def test_model_router_routes_token_count_request(settings):
settings.model_haiku = "lmstudio/qwen2.5-7b"
- request = TokenCountRequest(
- model="claude-3-haiku-20240307",
- messages=[Message(role="user", content="hello")],
- )
+ request = _request("claude-3-haiku-20240307")
routed = ModelRouter(settings).resolve_token_count_request(request)
- assert routed.request.model == "qwen2.5-7b"
+ assert routed.request.model == "claude-3-haiku-20240307"
+ assert routed.resolved.primary.provider_model == "qwen2.5-7b"
assert request.model == "claude-3-haiku-20240307"
diff --git a/tests/contracts/test_import_boundaries.py b/tests/contracts/test_import_boundaries.py
index 9b4bf9ff..d9d6a5fe 100644
--- a/tests/contracts/test_import_boundaries.py
+++ b/tests/contracts/test_import_boundaries.py
@@ -500,6 +500,56 @@ def test_core_does_not_import_provider_transport_sdks() -> None:
assert sorted(offenders) == []
+def test_application_and_providers_do_not_import_protocol_request_models() -> None:
+ forbidden_symbols = {
+ "Message",
+ "MessagesRequest",
+ "SystemContent",
+ "TokenCountRequest",
+ "Tool",
+ }
+ owner_modules = {
+ "free_claude_code.core.anthropic",
+ "free_claude_code.core.anthropic.models",
+ }
+ offenders: list[str] = []
+ for root in (_PACKAGE_ROOT / "application", _PACKAGE_ROOT / "providers"):
+ for path in root.rglob("*.py"):
+ tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+ relative = path.relative_to(_REPO_ROOT).as_posix()
+ for node in ast.walk(tree):
+ if (
+ not isinstance(node, ast.ImportFrom)
+ or node.module not in owner_modules
+ ):
+ continue
+ offenders.extend(
+ f"{relative}:{node.lineno}: {node.module}.{alias.name}"
+ for alias in node.names
+ if alias.name in forbidden_symbols
+ )
+
+ assert sorted(offenders) == []
+
+
+def test_removed_request_bridge_modules_do_not_return() -> None:
+ removed_modules = {
+ "core/anthropic/conversion.py",
+ "core/anthropic/openai_tool_names.py",
+ "core/anthropic/request_serialization.py",
+ "core/anthropic/request_snapshot.py",
+ "core/anthropic/streaming/recovery.py",
+ "core/anthropic/tokens.py",
+ "core/openai_responses/adapter.py",
+ "core/openai_responses/input.py",
+ "core/openai_responses/provider_events.py",
+ "core/openai_responses/provider_input.py",
+ "core/openai_responses/tools.py",
+ }
+
+ assert all(not (_PACKAGE_ROOT / module).exists() for module in removed_modules)
+
+
def test_providers_do_not_own_wire_error_type_literals() -> None:
wire_types = {
"api_error",
diff --git a/tests/core/anthropic/test_models.py b/tests/core/anthropic/test_models.py
index 39f789d9..1298f76e 100644
--- a/tests/core/anthropic/test_models.py
+++ b/tests/core/anthropic/test_models.py
@@ -1,9 +1,10 @@
import pytest
from pydantic import ValidationError
-from free_claude_code.core.anthropic.conversion import (
- OpenAIConversionError,
- build_base_request_body,
+from free_claude_code.core.anthropic.ingress import (
+ AnthropicIngressError,
+ messages_to_inference_request,
+ token_count_to_inference_request,
)
from free_claude_code.core.anthropic.models import (
ContentBlockDocument,
@@ -12,6 +13,23 @@ from free_claude_code.core.anthropic.models import (
MessagesRequest,
TokenCountRequest,
)
+from free_claude_code.core.inference import (
+ CacheTTL,
+ DocumentContent,
+ ImageContent,
+ InstructionItem,
+ MessageItem,
+ ReasoningItem,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+ TextContent,
+ ToolCallItem,
+)
+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort
+from free_claude_code.core.replay_envelope import encode_replay_envelope
def test_messages_request_parses_without_model_mapping_side_effects():
@@ -118,7 +136,7 @@ def test_messages_request_preserves_inline_system_block_metadata():
}
-def test_messages_request_ignores_internal_routing_fields_when_supplied():
+def test_messages_ingress_rejects_internal_routing_fields_when_supplied() -> None:
request = MessagesRequest.model_validate(
{
"model": "target-model",
@@ -130,8 +148,8 @@ def test_messages_request_ignores_internal_routing_fields_when_supplied():
)
assert request.model == "target-model"
- assert "original_model" not in request.model_dump()
- assert "resolved_provider_model" not in request.model_dump()
+ with pytest.raises(AnthropicIngressError, match="original_model"):
+ messages_to_inference_request(request)
def test_token_count_request_parses_without_model_mapping_side_effects():
@@ -295,9 +313,7 @@ def test_content_block_descriptions_remain_in_the_public_schema() -> None:
)
-def test_messages_request_dump_preserves_public_defaults_and_excludes_internal_fields() -> (
- None
-):
+def test_messages_ingress_rejects_unknown_fields_after_permissive_wire_parse() -> None:
request = MessagesRequest.model_validate(
{
"model": "model",
@@ -310,18 +326,11 @@ def test_messages_request_dump_preserves_public_defaults_and_excludes_internal_f
}
)
- dumped = request.model_dump(exclude_none=True)
-
- assert dumped == {
- "model": "model",
- "messages": [{"role": "user", "content": "hello"}],
- "stream": False,
- "thinking": {"enabled": True, "type": "adaptive"},
- "client_extension": {"enabled": True},
- }
+ with pytest.raises(AnthropicIngressError, match="client_extension"):
+ messages_to_inference_request(request)
-def test_token_count_request_accepts_extras_but_excludes_internal_fields() -> None:
+def test_token_count_ingress_rejects_unknown_internal_fields() -> None:
request = TokenCountRequest.model_validate(
{
"model": "model",
@@ -333,15 +342,11 @@ def test_token_count_request_accepts_extras_but_excludes_internal_fields() -> No
}
)
- assert request.model_extra == {"client_extension": "accepted"}
- assert request.model_dump(exclude_none=True) == {
- "model": "model",
- "messages": [{"role": "user", "content": "hello"}],
- "client_extension": "accepted",
- }
+ with pytest.raises(AnthropicIngressError, match="client_extension"):
+ token_count_to_inference_request(request)
-def test_openai_conversion_rejects_unknown_top_level_anthropic_extensions() -> None:
+def test_anthropic_ingress_rejects_unknown_top_level_extensions() -> None:
request = MessagesRequest.model_validate(
{
"model": "model",
@@ -350,5 +355,323 @@ def test_openai_conversion_rejects_unknown_top_level_anthropic_extensions() -> N
}
)
- with pytest.raises(OpenAIConversionError, match="client_extension"):
- build_base_request_body(request)
+ with pytest.raises(AnthropicIngressError, match="client_extension"):
+ messages_to_inference_request(request)
+
+
+def test_messages_ingress_preserves_cache_controls_at_supported_locations() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "system": [
+ {
+ "type": "text",
+ "text": "Top-level",
+ "cache_control": {"type": "ephemeral", "ttl": "5m"},
+ }
+ ],
+ "messages": [
+ {
+ "role": "system",
+ "content": [
+ {
+ "type": "text",
+ "text": "Inline",
+ "cache_control": {"type": "ephemeral", "ttl": "1h"},
+ }
+ ],
+ },
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "text",
+ "text": "Inspect",
+ "cache_control": {"type": "ephemeral"},
+ },
+ {
+ "type": "image",
+ "source": {
+ "type": "url",
+ "url": "https://example.invalid/image.png",
+ },
+ "cache_control": {"type": "ephemeral"},
+ },
+ {
+ "type": "document",
+ "source": {"type": "file", "file_id": "file_1"},
+ "cache_control": {"type": "ephemeral"},
+ },
+ ],
+ },
+ ],
+ "tools": [
+ {
+ "name": "lookup",
+ "input_schema": {"type": "object"},
+ "cache_control": {"type": "ephemeral"},
+ }
+ ],
+ }
+ )
+
+ canonical = messages_to_inference_request(request)
+
+ top_level, inline, *message_items = canonical.items
+ assert isinstance(top_level, InstructionItem)
+ assert top_level.cache_control is not None
+ assert top_level.cache_control.ttl is CacheTTL.FIVE_MINUTES
+ assert isinstance(inline, InstructionItem)
+ assert inline.cache_control is not None
+ assert inline.cache_control.ttl is CacheTTL.ONE_HOUR
+ assert all(isinstance(item, MessageItem) for item in message_items)
+ content = tuple(
+ item.content[0] for item in message_items if isinstance(item, MessageItem)
+ )
+ assert [type(part) for part in content] == [
+ TextContent,
+ ImageContent,
+ DocumentContent,
+ ]
+ text, image, document = content
+ assert isinstance(text, TextContent)
+ assert isinstance(image, ImageContent)
+ assert isinstance(document, DocumentContent)
+ assert text.cache_control is not None
+ assert image.cache_control is not None
+ assert document.cache_control is not None
+ assert canonical.tools[0].cache_control is not None
+
+
+def test_messages_ingress_normalizes_known_no_op_controls() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [{"role": "user", "content": "Hello"}],
+ "context_management": {
+ "edits": [{"type": "clear_thinking_20251015", "keep": "all"}]
+ },
+ "output_config": {"effort": "high"},
+ "mcp_servers": [],
+ }
+ )
+
+ canonical = messages_to_inference_request(request)
+
+ assert canonical.reasoning.control is ReasoningControl.DEFAULT
+ assert canonical.reasoning.effort is ReasoningEffort.HIGH
+
+
+def test_messages_ingress_normalizes_claude_thinking_display_hint() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [{"role": "user", "content": "Hello"}],
+ "thinking": {"type": "adaptive", "display": "omitted"},
+ }
+ )
+
+ canonical = messages_to_inference_request(request)
+
+ assert canonical.reasoning.control is ReasoningControl.ON
+
+
[email protected]("display", [None, "", "shown", False, {"mode": "omitted"}])
+def test_messages_ingress_rejects_unknown_thinking_display_values(
+ display: object,
+) -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [{"role": "user", "content": "Hello"}],
+ "thinking": {"type": "adaptive", "display": display},
+ }
+ )
+
+ with pytest.raises(AnthropicIngressError, match=r"thinking\.display"):
+ messages_to_inference_request(request)
+
+
+def test_messages_replay_carriers_restore_reasoning_and_tool_artifacts() -> None:
+ scope = ReplayCompatibilityScope("provider:model")
+ reasoning_artifact = ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI,
+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,
+ attachment=ReplayAttachment.REASONING,
+ scope=scope,
+ payload="opaque-reasoning",
+ )
+ tool_artifact = ReplayArtifact(
+ origin=ReplayArtifactOrigin.GOOGLE,
+ kind=ReplayArtifactKind.THOUGHT_SIGNATURE,
+ attachment=ReplayAttachment.TOOL_CALL,
+ scope=scope,
+ payload="opaque-tool",
+ )
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "thinking",
+ "thinking": "summary",
+ "signature": encode_replay_envelope((reasoning_artifact,)),
+ },
+ {
+ "type": "tool_use",
+ "id": "call_1",
+ "name": "lookup",
+ "input": {},
+ "extra_content": {
+ "fcc_replay": encode_replay_envelope((tool_artifact,))
+ },
+ },
+ ],
+ }
+ ],
+ "tools": [{"name": "lookup", "input_schema": {"type": "object"}}],
+ }
+ )
+
+ canonical = messages_to_inference_request(request)
+ reasoning = next(
+ item for item in canonical.items if isinstance(item, ReasoningItem)
+ )
+ tool_call = next(item for item in canonical.items if isinstance(item, ToolCallItem))
+
+ assert reasoning.artifacts == (reasoning_artifact,)
+ assert tool_call.artifacts == (tool_artifact,)
+
+
+ ("override", "match"),
+ [
+ (
+ {
+ "context_management": {
+ "edits": [{"type": "clear_thinking_20251015", "keep": "last"}]
+ }
+ },
+ "context_management",
+ ),
+ ({"output_config": {"format": {"type": "json"}}}, "output_config.format"),
+ (
+ {"mcp_servers": [{"type": "url", "url": "https://example.invalid"}]},
+ "mcp_servers",
+ ),
+ ({"thinking": {"type": "future"}}, "thinking.type"),
+ (
+ {"thinking": {"type": "adaptive", "client_extension": True}},
+ "thinking.client_extension",
+ ),
+ (
+ {
+ "messages": [
+ {
+ "role": "user",
+ "content": "Hello",
+ "client_extension": True,
+ }
+ ]
+ },
+ "messages\\[0\\].client_extension",
+ ),
+ (
+ {
+ "system": [
+ {
+ "type": "text",
+ "text": "System",
+ "cache_control": {"type": "ephemeral", "ttl": "2h"},
+ }
+ ]
+ },
+ "system\\[0\\].cache_control.ttl",
+ ),
+ (
+ {
+ "messages": [
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "text",
+ "text": "Hello",
+ "cache_control": {"type": "persistent"},
+ }
+ ],
+ }
+ ]
+ },
+ "cache_control.type",
+ ),
+ (
+ {
+ "messages": [
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "image",
+ "source": {
+ "type": "url",
+ "url": "https://example.invalid/image.png",
+ "caption": "silently dropped",
+ },
+ }
+ ],
+ }
+ ]
+ },
+ "source.caption",
+ ),
+ (
+ {
+ "messages": [
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "document",
+ "source": {
+ "type": "file",
+ "file_id": "file_1",
+ "filename": "ignored.pdf",
+ },
+ }
+ ],
+ }
+ ]
+ },
+ "source.filename",
+ ),
+ (
+ {
+ "tools": [
+ {
+ "name": "lookup",
+ "input_schema": {"type": "object"},
+ "client_extension": True,
+ }
+ ]
+ },
+ "tools\\[0\\].client_extension",
+ ),
+ ],
+)
+def test_messages_ingress_rejects_active_or_unknown_nested_semantics(
+ override: dict[str, object],
+ match: str,
+) -> None:
+ payload: dict[str, object] = {
+ "model": "model",
+ "messages": [{"role": "user", "content": "Hello"}],
+ }
+ payload.update(override)
+ request = MessagesRequest.model_validate(payload)
+
+ with pytest.raises(AnthropicIngressError, match=match):
+ messages_to_inference_request(request)
diff --git a/tests/core/anthropic/test_openai_tool_names.py b/tests/core/anthropic/test_openai_tool_names.py
index 908aae01..1646768b 100644
--- a/tests/core/anthropic/test_openai_tool_names.py
+++ b/tests/core/anthropic/test_openai_tool_names.py
@@ -1,25 +1,27 @@
import re
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec
+import pytest
+
+from free_claude_code.core.anthropic.ingress import AnthropicIngressError
+from free_claude_code.core.inference import InferenceRequest
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+from tests.providers.request_factory import make_messages_request
_PORTABLE_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
-def _request(*names: str) -> MessagesRequest:
- return MessagesRequest.model_validate(
- {
- "model": "test-model",
- "messages": [{"role": "user", "content": "hello"}],
- "tools": [
- {
- "name": name,
- "description": "test",
- "input_schema": {"type": "object"},
- }
- for name in names
- ],
- }
+def _request(*names: str) -> InferenceRequest:
+ return make_messages_request(
+ "test-model",
+ messages=[{"role": "user", "content": "hello"}],
+ tools=[
+ {
+ "name": name,
+ "description": "test",
+ "input_schema": {"type": "object"},
+ }
+ for name in names
+ ],
)
@@ -98,44 +100,41 @@ def test_codec_collects_forced_choice_and_history_names_without_mutation() -> No
declared = "safe_tool"
forced = "mcp__forced__" + "f" * 70
historical = "mcp__historical__" + "h" * 70
- request = MessagesRequest.model_validate(
- {
- "model": "test-model",
- "messages": [
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "call_1",
- "name": historical,
- "input": {},
- }
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_1",
- "content": "done",
- }
- ],
- },
- ],
- "tools": [{"name": declared, "input_schema": {"type": "object"}}],
- "tool_choice": {"type": "tool", "name": forced},
- }
+ request = make_messages_request(
+ "test-model",
+ messages=[
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "tool_use",
+ "id": "call_1",
+ "name": historical,
+ "input": {},
+ }
+ ],
+ },
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "tool_result",
+ "tool_use_id": "call_1",
+ "content": "done",
+ }
+ ],
+ },
+ ],
+ tools=[{"name": declared, "input_schema": {"type": "object"}}],
+ tool_choice={"type": "tool", "name": forced},
)
- snapshot = request.model_dump()
codec = OpenAIToolNameCodec.from_request(request)
assert codec.encode(declared) == declared
assert codec.decode(codec.encode(forced)) == forced
assert codec.decode(codec.encode(historical)) == historical
- assert request.model_dump() == snapshot
+ assert request.model == "test-model"
def test_only_generated_aliases_are_decoded_and_prefixes_are_detected() -> None:
@@ -152,8 +151,6 @@ def test_only_generated_aliases_are_decoded_and_prefixes_are_detected() -> None:
assert codec.decode("unknown_tool") == "unknown_tool"
-def test_empty_name_retains_existing_invalid_identity() -> None:
- codec = OpenAIToolNameCodec.from_request(_request(""))
-
- assert codec.encode("") == ""
- assert codec.decode("") == ""
+def test_empty_tool_name_is_rejected_before_codec_construction() -> None:
+ with pytest.raises(AnthropicIngressError, match="non-empty"):
+ _request("")
diff --git a/tests/core/anthropic/test_request_serialization.py b/tests/core/anthropic/test_request_serialization.py
index 3a9ffbba..612b6ea7 100644
--- a/tests/core/anthropic/test_request_serialization.py
+++ b/tests/core/anthropic/test_request_serialization.py
@@ -1,6 +1,5 @@
-"""Anthropic request parsing and public-field serialization."""
+"""Anthropic public-wire parsing contracts."""
-from free_claude_code.core.anthropic import dump_messages_request
from free_claude_code.core.anthropic.models import (
ContentBlockServerToolUse,
ContentBlockText,
@@ -10,55 +9,6 @@ from free_claude_code.core.anthropic.models import (
)
-def test_dump_preserves_public_fields_and_nested_extensions() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "m",
- "max_tokens": 20,
- "messages": [
- {
- "role": "user",
- "content": [
- {
- "type": "text",
- "text": "hi",
- "cache_control": {"type": "ephemeral"},
- }
- ],
- }
- ],
- "context_management": {"edits": [{"type": "clear"}]},
- "output_config": {"some": "hint"},
- }
- )
-
- body = dump_messages_request(request)
-
- assert body["messages"][0]["content"][0]["cache_control"] == {"type": "ephemeral"}
- assert body["context_management"] == {"edits": [{"type": "clear"}]}
- assert body["output_config"] == {"some": "hint"}
-
-
-def test_dump_excludes_unknown_client_hints_and_fcc_routing_state() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "m",
- "messages": [{"role": "user", "content": "x"}],
- "reasoning_effort": "none",
- "unknown_client_hint": {"mode": "local"},
- }
- )
- request.original_model = "claude"
- request.resolved_provider_model = "upstream"
-
- body = dump_messages_request(request)
-
- assert "reasoning_effort" not in body
- assert "unknown_client_hint" not in body
- assert "original_model" not in body
- assert "resolved_provider_model" not in body
-
-
def test_pydantic_discriminator_still_distinguishes_blocks() -> None:
message = Message.model_validate(
{
diff --git a/tests/core/anthropic/test_stream_repair.py b/tests/core/anthropic/test_stream_repair.py
index 9b42c665..698dd699 100644
--- a/tests/core/anthropic/test_stream_repair.py
+++ b/tests/core/anthropic/test_stream_repair.py
@@ -1,6 +1,6 @@
-"""Neutral Anthropic continuation and tool-repair helpers."""
+"""OpenAI Chat continuation and tool-repair helpers."""
-from free_claude_code.core.anthropic.streaming import (
+from free_claude_code.providers.openai_chat.recovery import (
ToolSchema,
accept_tool_json_repair,
continuation_suffix,
diff --git a/tests/core/anthropic/test_text_tools.py b/tests/core/anthropic/test_text_tools.py
index 82107cf7..88993365 100644
--- a/tests/core/anthropic/test_text_tools.py
+++ b/tests/core/anthropic/test_text_tools.py
@@ -1,10 +1,8 @@
import pytest
-from free_claude_code.core.anthropic import (
- FunctionTagToolParser,
- OpenAIToolNameCodec,
-)
-from free_claude_code.core.anthropic import tools as tool_parsers
+from free_claude_code.providers.openai_chat import function_tags as tool_parsers
+from free_claude_code.providers.openai_chat.function_tags import FunctionTagToolParser
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
from tests.providers.request_factory import make_messages_request
diff --git a/tests/core/openai_responses/test_conversion.py b/tests/core/openai_responses/test_conversion.py
index 5adac9ba..2bc4bdd0 100644
--- a/tests/core/openai_responses/test_conversion.py
+++ b/tests/core/openai_responses/test_conversion.py
@@ -1,22 +1,43 @@
-from typing import Any
-
import pytest
+from free_claude_code.core.inference import (
+ CustomTool,
+ CustomToolFormatType,
+ FunctionTool,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MessageItem,
+ MessageRole,
+ ReasoningItem,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoiceMode,
+ ToolResultItem,
+)
from free_claude_code.core.openai_responses import (
- OpenAIResponsesAdapter,
OpenAIResponsesRequest,
+ ResponsesConversionError,
+ responses_to_inference_request,
)
+from free_claude_code.core.reasoning import ReasoningControl, ReasoningEffort
+from free_claude_code.core.replay_envelope import encode_replay_envelope
-_ADAPTER = OpenAIResponsesAdapter()
-_CONVERSION_ERROR = OpenAIResponsesAdapter.ConversionError
+def _ingest(payload: dict[str, object]):
+ return responses_to_inference_request(
+ OpenAIResponsesRequest.model_validate(payload)
+ ).request
-def _to_anthropic_payload(request: dict[str, Any]) -> dict[str, Any]:
- return _ADAPTER.to_anthropic_payload(OpenAIResponsesRequest.model_validate(request))
-
-def test_responses_string_input_converts_to_anthropic_message() -> None:
- payload = _to_anthropic_payload(
+def test_responses_string_input_becomes_canonical_instruction_and_message() -> None:
+ request = _ingest(
{
"model": "nvidia_nim/test-model",
"instructions": "System instructions",
@@ -28,20 +49,41 @@ def test_responses_string_input_converts_to_anthropic_message() -> None:
}
)
- assert payload["model"] == "nvidia_nim/test-model"
- assert payload["system"] == "System instructions"
- assert payload["messages"] == [{"role": "user", "content": "Hello"}]
- assert payload["max_tokens"] == 64
- assert payload["temperature"] == 0.2
- assert payload["top_p"] == 0.9
- assert payload["metadata"] == {"trace": "abc"}
-
-
[email protected]("effort", ["none", "low", "medium", "high", "xhigh"])
-def test_responses_reasoning_effort_is_preserved_for_application_policy(
+ assert request.model == "nvidia_nim/test-model"
+ assert request.items == (
+ InstructionItem(
+ text="System instructions",
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ ),
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("Hello"),),
+ ),
+ )
+ assert request.max_output_tokens == 64
+ assert request.temperature == 0.2
+ assert request.top_p == 0.9
+ assert request.metadata == {"trace": "abc"}
+
+
+ ("effort", "control", "expected_effort"),
+ [
+ ("none", ReasoningControl.OFF, None),
+ ("low", ReasoningControl.ON, ReasoningEffort.LOW),
+ ("medium", ReasoningControl.ON, ReasoningEffort.MEDIUM),
+ ("high", ReasoningControl.ON, ReasoningEffort.HIGH),
+ ("xhigh", ReasoningControl.ON, ReasoningEffort.XHIGH),
+ ],
+)
+def test_responses_reasoning_effort_becomes_canonical_intent(
effort: str,
+ control: ReasoningControl,
+ expected_effort: ReasoningEffort | None,
) -> None:
- payload = _to_anthropic_payload(
+ request = _ingest(
{
"model": "nvidia_nim/test-model",
"input": "Hello",
@@ -49,12 +91,12 @@ def test_responses_reasoning_effort_is_preserved_for_application_policy(
}
)
- assert payload["output_config"] == {"effort": effort}
- assert "thinking" not in payload
+ assert request.reasoning.control is control
+ assert request.reasoning.effort is expected_effort
-def test_responses_messages_tools_and_tool_results_convert() -> None:
- payload = _to_anthropic_payload(
+def test_responses_messages_tools_and_results_preserve_semantics() -> None:
+ request = _ingest(
{
"model": "deepseek/deepseek-chat",
"input": [
@@ -89,195 +131,137 @@ def test_responses_messages_tools_and_tool_results_convert() -> None:
"type": "object",
"properties": {"value": {"type": "string"}},
},
+ "strict": True,
}
],
"tool_choice": {"type": "function", "name": "echo"},
}
)
- assert payload["system"] == "Developer rules"
- assert payload["messages"] == [
- {"role": "user", "content": [{"type": "text", "text": "Use the tool"}]},
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "call_1",
- "name": "echo",
- "input": {"value": "FCC"},
- }
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_1",
- "content": "FCC",
- }
- ],
- },
- ]
- assert payload["tools"] == [
- {
- "name": "echo",
- "description": "Echo a value",
- "input_schema": {
+ assert request.items == (
+ InstructionItem(
+ text="Developer rules",
+ origin=InstructionOrigin.DEVELOPER,
+ placement=InstructionPlacement.TRANSCRIPT,
+ turn_id="turn_0",
+ ),
+ MessageItem(
+ turn_id="turn_1",
+ role=MessageRole.USER,
+ content=(TextContent("Use the tool"),),
+ ),
+ ToolCallItem(
+ turn_id="turn_2",
+ call_id="call_1",
+ kind=ToolCallKind.FUNCTION,
+ name="echo",
+ input={"value": "FCC"},
+ ),
+ ToolResultItem(
+ turn_id="turn_3",
+ call_id="call_1",
+ content="FCC",
+ ),
+ )
+ assert request.tools == (
+ FunctionTool(
+ name="echo",
+ description="Echo a value",
+ input_schema={
"type": "object",
"properties": {"value": {"type": "string"}},
},
- }
- ]
- assert payload["tool_choice"] == {"type": "tool", "name": "echo"}
+ strict=True,
+ ),
+ )
+ assert request.tool_choice is not None
+ assert request.tool_choice.mode is ToolChoiceMode.SPECIFIC
+ assert request.tool_choice.name == "echo"
-def test_responses_tool_choice_none_disables_forwarded_tools() -> None:
- payload = _to_anthropic_payload(
+def test_none_choice_retains_definitions_but_disables_tool_calls() -> None:
+ request = _ingest(
{
- "model": "deepseek/deepseek-chat",
+ "model": "model",
"input": "Reply without tools",
"tools": [
{
"type": "function",
"name": "echo",
- "parameters": {
- "type": "object",
- "properties": {"value": {"type": "string"}},
- },
+ "parameters": {"type": "object", "properties": {}},
}
],
"tool_choice": "none",
}
)
- assert "tools" not in payload
- assert "tool_choice" not in payload
+ assert [tool.name for tool in request.tools] == ["echo"]
+ assert request.tool_choice is not None
+ assert request.tool_choice.mode is ToolChoiceMode.NONE
-def test_responses_namespace_tools_flatten_for_anthropic() -> None:
- payload = _to_anthropic_payload(
+def test_passive_responses_controls_are_accepted_only_at_the_settled_values() -> None:
+ request = _ingest(
{
- "model": "nvidia_nim/test-model",
- "input": "Use JS",
- "tools": [
- {
- "type": "namespace",
- "name": "mcp__node_repl",
- "description": "Node tools",
- "tools": [
- {
- "type": "function",
- "name": "js",
- "description": "Run JavaScript",
- "parameters": {
- "type": "object",
- "properties": {"code": {"type": "string"}},
- "required": ["code"],
- },
- }
- ],
- }
- ],
- "tool_choice": {
- "type": "function",
- "namespace": "mcp__node_repl",
- "name": "js",
- },
+ "model": "model",
+ "input": "Hello",
+ "stream": True,
+ "store": False,
+ "previous_response_id": None,
+ "include": ["reasoning.encrypted_content"],
+ "prompt_cache_key": "session-1",
+ "reasoning": {"summary": "auto"},
}
)
- assert payload["tools"] == [
- {
- "name": "mcp__node_repl__js",
- "description": "Run JavaScript",
- "input_schema": {
- "type": "object",
- "properties": {"code": {"type": "string"}},
- "required": ["code"],
- },
- }
- ]
- assert payload["tool_choice"] == {"type": "tool", "name": "mcp__node_repl__js"}
+ assert request.model == "model"
+ assert request.reasoning.control is ReasoningControl.DEFAULT
-def test_responses_namespaced_tool_choice_type_tool_flattens_for_anthropic() -> None:
- payload = _to_anthropic_payload(
- {
- "model": "nvidia_nim/test-model",
- "input": "Use JS",
- "tools": [
- {
- "type": "namespace",
- "name": "mcp__node_repl",
- "tools": [
- {
- "type": "function",
- "name": "js",
- "parameters": {"type": "object", "properties": {}},
- }
- ],
- }
- ],
- "tool_choice": {
- "type": "tool",
- "namespace": "mcp__node_repl",
- "name": "js",
+ ("override", "match"),
+ [
+ ({"stream": False}, "stream=false"),
+ ({"store": True}, "store=true"),
+ ({"previous_response_id": "resp_1"}, "previous_response_id"),
+ ({"include": []}, "include must be exactly"),
+ (
+ {
+ "include": [
+ "reasoning.encrypted_content",
+ "reasoning.encrypted_content",
+ ]
},
- }
- )
-
- assert payload["tool_choice"] == {"type": "tool", "name": "mcp__node_repl__js"}
-
-
-def test_responses_custom_tool_converts_to_anthropic_string_tool() -> None:
- payload = _to_anthropic_payload(
- {
- "model": "nvidia_nim/test-model",
- "input": "Use apply_patch",
- "tools": [
- {
- "type": "custom",
- "name": "apply_patch",
- "description": "Apply a repo patch",
- "format": {
- "type": "grammar",
- "syntax": "lark",
- "definition": "start: /.+/",
- },
- }
- ],
- "tool_choice": {"type": "custom", "name": "apply_patch"},
- }
- )
+ "include must be exactly",
+ ),
+ (
+ {"include": ["reasoning.encrypted_content", "message.output_text"]},
+ "include must be exactly",
+ ),
+ ({"include": ["reasoning.encrypted_contents"]}, "include must be exactly"),
+ ({"prompt_cache_key": ""}, "prompt_cache_key"),
+ ({"prompt_cache_key": " "}, "prompt_cache_key"),
+ ({"prompt_cache_key": 42}, "prompt_cache_key"),
+ ({"reasoning": {"summary": "concise"}}, "reasoning.summary"),
+ ({"reasoning": {"summary": []}}, "reasoning.summary"),
+ ({"provider_extension": True}, "request.provider_extension"),
+ ],
+)
+def test_responses_passive_field_near_misses_are_rejected(
+ override: dict[str, object],
+ match: str,
+) -> None:
+ payload: dict[str, object] = {"model": "model", "input": "Hello"}
+ payload.update(override)
- assert payload["tools"] == [
- {
- "name": "apply_patch",
- "description": (
- "Apply a repo patch\n\n"
- "Custom tool input format: grammar (lark): start: /.+/"
- ),
- "input_schema": {
- "type": "object",
- "properties": {
- "input": {
- "type": "string",
- "description": "Free-form input for the custom tool.",
- }
- },
- "required": ["input"],
- },
- }
- ]
- assert payload["tool_choice"] == {"type": "tool", "name": "apply_patch"}
+ with pytest.raises(ResponsesConversionError, match=match):
+ _ingest(payload)
-def test_responses_namespaced_custom_tool_flattens_for_anthropic() -> None:
- payload = _to_anthropic_payload(
+def test_namespace_and_custom_tool_identity_remain_structured() -> None:
+ request = _ingest(
{
- "model": "nvidia_nim/test-model",
+ "model": "model",
"input": "Use shell",
"tools": [
{
@@ -301,17 +285,26 @@ def test_responses_namespaced_custom_tool_flattens_for_anthropic() -> None:
}
)
- assert payload["tools"][0]["name"] == "mcp__shell__exec"
- assert payload["tools"][0]["description"] == (
- "Run shell text\n\nCustom tool input format: unconstrained text."
+ assert request.tools == (
+ CustomTool(
+ name="exec",
+ description="Run shell text",
+ format=request.tools[0].format,
+ namespace="mcp__shell",
+ ),
)
- assert payload["tool_choice"] == {"type": "tool", "name": "mcp__shell__exec"}
+ assert isinstance(request.tools[0], CustomTool)
+ assert request.tools[0].format.type is CustomToolFormatType.TEXT
+ assert request.tool_choice is not None
+ assert request.tool_choice.kind is ToolCallKind.CUSTOM
+ assert request.tool_choice.name == "exec"
+ assert request.tool_choice.namespace == "mcp__shell"
-def test_responses_passive_codex_built_in_tools_are_ignored() -> None:
- payload = _to_anthropic_payload(
+def test_passive_hosted_tools_are_removed_but_executable_tools_remain() -> None:
+ request = _ingest(
{
- "model": "nvidia_nim/test-model",
+ "model": "model",
"input": "Hello",
"tools": [
{"type": "web_search", "external_web_access": True},
@@ -326,215 +319,115 @@ def test_responses_passive_codex_built_in_tools_are_ignored() -> None:
}
)
- assert payload["tools"] == [
- {"name": "echo", "input_schema": {"type": "object", "properties": {}}}
- ]
+ assert [tool.name for tool in request.tools] == ["echo"]
-def test_responses_namespaced_prior_function_call_flattens_tool_use_name() -> None:
- payload = _to_anthropic_payload(
- {
- "model": "nvidia_nim/test-model",
- "input": [
- {
- "type": "function_call",
- "call_id": "call_1",
- "namespace": "mcp__node_repl",
- "name": "js",
- "arguments": '{"code":"1+1"}',
- },
- {
- "type": "function_call_output",
- "call_id": "call_1",
- "output": "2",
- },
- ],
- }
- )
-
- assert payload["messages"][0]["content"][0]["name"] == "mcp__node_repl__js"
+ ("raw_choice", "expected_mode"),
+ [
+ (None, None),
+ ("auto", ToolChoiceMode.AUTO),
+ ("none", ToolChoiceMode.NONE),
+ ("required", ToolChoiceMode.REQUIRED),
+ ({"type": "function", "name": "echo"}, ToolChoiceMode.SPECIFIC),
+ ],
+)
+def test_ambient_and_executable_tool_combinations_preserve_client_choice(
+ raw_choice: object,
+ expected_mode: ToolChoiceMode | None,
+) -> None:
+ payload: dict[str, object] = {
+ "model": "model",
+ "input": "Hello",
+ "tools": [
+ {"type": "web_search"},
+ {"type": "image_generation"},
+ {"type": "tool_search"},
+ {
+ "type": "function",
+ "name": "echo",
+ "parameters": {"type": "object"},
+ },
+ ],
+ }
+ if raw_choice is not None:
+ payload["tool_choice"] = raw_choice
+ request = _ingest(payload)
-def test_responses_prior_custom_tool_call_flattens_tool_use_name() -> None:
- payload = _to_anthropic_payload(
- {
- "model": "nvidia_nim/test-model",
- "input": [
- {
- "type": "custom_tool_call",
- "call_id": "call_1",
- "namespace": "mcp__shell",
- "name": "exec",
- "input": "printf FCC",
- },
- {
- "type": "custom_tool_call_output",
- "call_id": "call_1",
- "output": "FCC",
- },
- ],
- }
- )
+ assert [tool.name for tool in request.tools] == ["echo"]
+ assert (
+ request.tool_choice.mode if request.tool_choice is not None else None
+ ) is expected_mode
- assert payload["messages"] == [
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "call_1",
- "name": "mcp__shell__exec",
- "input": {"input": "printf FCC"},
- }
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_1",
- "content": "FCC",
- }
- ],
- },
- ]
+ ("raw_choice", "expected_mode"),
+ [
+ (None, None),
+ ("auto", ToolChoiceMode.AUTO),
+ ("none", ToolChoiceMode.NONE),
+ ],
+)
+def test_ambient_only_tools_are_safe_no_ops_when_not_required(
+ raw_choice: object,
+ expected_mode: ToolChoiceMode | None,
+) -> None:
+ payload: dict[str, object] = {
+ "model": "model",
+ "input": "Hello",
+ "tools": [{"type": "web_search"}, {"type": "tool_search"}],
+ }
+ if raw_choice is not None:
+ payload["tool_choice"] = raw_choice
-def test_responses_groups_consecutive_prior_tool_calls() -> None:
- payload = _to_anthropic_payload(
- {
- "model": "nvidia_nim/test-model",
- "input": [
- {
- "type": "function_call",
- "call_id": "call_1",
- "name": "echo",
- "arguments": '{"value":"FCC"}',
- },
- {
- "type": "custom_tool_call",
- "call_id": "call_2",
- "name": "apply_patch",
- "input": "*** Begin Patch",
- },
- ],
- }
- )
+ request = _ingest(payload)
- assert payload["messages"] == [
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "call_1",
- "name": "echo",
- "input": {"value": "FCC"},
- },
- {
- "type": "tool_use",
- "id": "call_2",
- "name": "apply_patch",
- "input": {"input": "*** Begin Patch"},
- },
- ],
- }
- ]
+ assert request.tools == ()
+ assert (
+ request.tool_choice.mode if request.tool_choice is not None else None
+ ) is expected_mode
-def test_responses_groups_consecutive_prior_tool_outputs() -> None:
- payload = _to_anthropic_payload(
+def test_prior_custom_call_preserves_kind_namespace_and_raw_input() -> None:
+ request = _ingest(
{
- "model": "nvidia_nim/test-model",
+ "model": "model",
"input": [
{
- "type": "function_call",
+ "type": "custom_tool_call",
"call_id": "call_1",
- "name": "echo",
- "arguments": '{"value":"FCC"}',
- },
- {
- "type": "function_call",
- "call_id": "call_2",
- "name": "echo",
- "arguments": '{"value":"Codex"}',
+ "namespace": "mcp__shell",
+ "name": "exec",
+ "input": "printf FCC",
},
{
- "type": "function_call_output",
+ "type": "custom_tool_call_output",
"call_id": "call_1",
"output": "FCC",
},
- {
- "type": "function_call_output",
- "call_id": "call_2",
- "output": "Codex",
- },
],
}
)
- assert len(payload["messages"]) == 2
- assert payload["messages"][0]["role"] == "assistant"
- assert len(payload["messages"][0]["content"]) == 2
- assert payload["messages"][1] == {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_1",
- "content": "FCC",
- },
- {
- "type": "tool_result",
- "tool_use_id": "call_2",
- "content": "Codex",
- },
- ],
- }
+ call, result = request.items
+ assert isinstance(call, ToolCallItem)
+ assert call.kind is ToolCallKind.CUSTOM
+ assert call.namespace == "mcp__shell"
+ assert call.input == "printf FCC"
+ assert isinstance(result, ToolResultItem)
+ assert result.call_id == call.call_id
-def test_responses_reasoning_between_tool_call_and_output_attaches_to_tool_message() -> (
- None
-):
- payload = _to_anthropic_payload(
+def test_reasoning_stays_attached_to_the_following_tool_turn() -> None:
+ request = _ingest(
{
- "model": "nvidia_nim/test-model",
+ "model": "model",
"input": [
- {
- "type": "function_call",
- "call_id": "call_1",
- "name": "echo",
- "arguments": '{"value":"FCC"}',
- },
{
"type": "reasoning",
"content": [{"type": "reasoning_text", "text": "Need the result."}],
},
- {
- "type": "function_call_output",
- "call_id": "call_1",
- "output": "FCC",
- },
- ],
- }
- )
-
- assert payload["messages"][0]["reasoning_content"] == "Need the result."
- assert payload["messages"][0]["content"][0]["id"] == "call_1"
- assert payload["messages"][1]["content"][0]["tool_use_id"] == "call_1"
-
-
-def test_responses_encrypted_reasoning_attaches_before_tool_call() -> None:
- payload = _to_anthropic_payload(
- {
- "model": "openai/gpt-test",
- "input": [
- {
- "type": "reasoning",
- "summary": [{"type": "summary_text", "text": "Need the result."}],
- "encrypted_content": "opaque-reasoning",
- },
{
"type": "function_call",
"call_id": "call_1",
@@ -550,62 +443,44 @@ def test_responses_encrypted_reasoning_attaches_before_tool_call() -> None:
}
)
- assistant = payload["messages"][0]
- assert assistant["reasoning_content"] == "Need the result."
- assert assistant["content"] == [
- {"type": "redacted_thinking", "data": "opaque-reasoning"},
- {
- "type": "tool_use",
- "id": "call_1",
- "name": "echo",
- "input": {"value": "FCC"},
- },
- ]
- assert payload["messages"][1]["content"][0]["tool_use_id"] == "call_1"
-
-
-def test_responses_empty_reasoning_attaches_to_prior_tool_call() -> None:
- payload = _to_anthropic_payload(
+ reasoning, call, result = request.items
+ assert isinstance(reasoning, ReasoningItem)
+ assert isinstance(call, ToolCallItem)
+ assert reasoning.turn_id == call.turn_id
+ assert reasoning.reasoning == "Need the result."
+ assert isinstance(result, ToolResultItem)
+
+
+def test_responses_encrypted_reasoning_carrier_restores_scoped_artifacts() -> None:
+ artifact = ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,
+ kind=ReplayArtifactKind.REASONING_DETAILS,
+ attachment=ReplayAttachment.REASONING,
+ scope=ReplayCompatibilityScope("provider:model"),
+ payload=[{"type": "reasoning.text", "text": "opaque"}],
+ )
+ request = _ingest(
{
- "model": "nvidia_nim/test-model",
+ "model": "model",
"input": [
- {
- "type": "function_call",
- "call_id": "call_1",
- "name": "echo",
- "arguments": '{"value":"FCC"}',
- },
{
"type": "reasoning",
- "content": [{"type": "reasoning_text", "text": ""}],
- },
- {
- "type": "function_call_output",
- "call_id": "call_1",
- "output": "FCC",
+ "encrypted_content": encode_replay_envelope((artifact,)),
},
+ {"role": "assistant", "content": "Done"},
+ {"role": "user", "content": "Continue"},
],
}
)
- assert payload["messages"][0]["reasoning_content"] == ""
+ reasoning = next(item for item in request.items if isinstance(item, ReasoningItem))
+ assert reasoning.artifacts == (artifact,)
-def test_responses_unsupported_tool_type_is_clear() -> None:
- with pytest.raises(_CONVERSION_ERROR, match="Unsupported Responses tool type"):
- _to_anthropic_payload(
- {
- "model": "nvidia_nim/test-model",
- "input": "Hello",
- "tools": [{"type": "web_search_preview"}],
- }
- )
-
-
-def test_responses_malformed_prior_function_call_is_quarantined() -> None:
- payload = _to_anthropic_payload(
+def test_malformed_prior_call_quarantines_only_it_and_matching_output() -> None:
+ request = _ingest(
{
- "model": "nvidia_nim/test-model",
+ "model": "model",
"input": [
{"role": "user", "content": "hello"},
{
@@ -635,38 +510,26 @@ def test_responses_malformed_prior_function_call_is_quarantined() -> None:
}
)
- assert payload["messages"] == [
- {"role": "user", "content": "hello"},
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "call_good",
- "name": "echo",
- "input": {"value": "ok"},
- }
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_good",
- "content": "ok",
- }
- ],
- },
- {"role": "user", "content": "continue"},
- ]
+ assert all(
+ not isinstance(item, ToolCallItem | ToolResultItem)
+ or item.call_id != "call_bad"
+ for item in request.items
+ )
+ assert any(
+ isinstance(item, ToolCallItem) and item.call_id == "call_good"
+ for item in request.items
+ )
+ assert any(
+ isinstance(item, ToolResultItem) and item.call_id == "call_good"
+ for item in request.items
+ )
-def test_responses_malformed_only_function_call_still_has_no_routable_message() -> None:
- with pytest.raises(_CONVERSION_ERROR, match="must contain a message"):
- _to_anthropic_payload(
+def test_malformed_only_call_has_no_routable_message() -> None:
+ with pytest.raises(ResponsesConversionError, match="must contain a message"):
+ _ingest(
{
- "model": "nvidia_nim/test-model",
+ "model": "model",
"input": [
{
"type": "function_call",
@@ -682,3 +545,54 @@ def test_responses_malformed_only_function_call_still_has_no_routable_message()
],
}
)
+
+
+ ("payload", "match"),
+ [
+ (
+ {
+ "model": "model",
+ "input": "Hello",
+ "tools": [{"type": "web_search_preview"}],
+ },
+ "tools\\[0\\]\\.type",
+ ),
+ (
+ {
+ "model": "model",
+ "input": "Hello",
+ "tools": [{"type": "web_search"}],
+ "tool_choice": "required",
+ },
+ "needs at least one executable",
+ ),
+ (
+ {
+ "model": "model",
+ "input": "Hello",
+ "tool_choice": {"type": "web_search"},
+ },
+ "cannot be selected explicitly",
+ ),
+ ],
+)
+def test_unsupported_or_active_hosted_tool_semantics_are_rejected(
+ payload: dict[str, object],
+ match: str,
+) -> None:
+ with pytest.raises(ResponsesConversionError, match=match):
+ _ingest(payload)
+
+
[email protected]("part_type", ["input_image", "input_file", "computer_call"])
+def test_unsupported_responses_input_types_are_rejected_explicitly(
+ part_type: str,
+) -> None:
+ with pytest.raises(ResponsesConversionError, match=part_type):
+ _ingest(
+ {
+ "model": "model",
+ "input": [{"type": part_type, "image_url": "https://example.invalid"}],
+ }
+ )
diff --git a/tests/core/openai_responses/test_provider_input.py b/tests/core/openai_responses/test_provider_input.py
index 5b2b7978..4480e1e4 100644
--- a/tests/core/openai_responses/test_provider_input.py
+++ b/tests/core/openai_responses/test_provider_input.py
@@ -2,99 +2,154 @@ import json
import pytest
-from free_claude_code.application.reasoning import client_reasoning_policy
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.openai_responses import (
- OpenAIResponsesAdapter,
- OpenAIResponsesRequest,
-)
-from free_claude_code.core.openai_responses.errors import ResponsesConversionError
-from free_claude_code.core.openai_responses.provider_input import (
- build_responses_provider_request,
+from free_claude_code.core.inference import (
+ Base64MediaSource,
+ CacheControl,
+ CustomTool,
+ CustomToolFormat,
+ CustomToolFormatType,
+ DocumentContent,
+ FileMediaSource,
+ FunctionTool,
+ ImageContent,
+ InferenceRequest,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MessageItem,
+ MessageRole,
+ OpenAIChatExtension,
+ ReasoningItem,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoice,
+ ToolChoiceMode,
+ ToolResultItem,
)
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+from free_claude_code.providers.openai_responses.request_codec import (
+ ResponsesRequestEncodingError,
+ build_responses_request_body,
+)
-_KEEP_ALL_THINKING_EDIT = {
- "type": "clear_thinking_20251015",
- "keep": "all",
-}
+_SCOPE = ReplayCompatibilityScope("openai_responses:test-model")
-def test_build_responses_provider_request_preserves_multiturn_protocol() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "max_tokens": 4096,
- "system": "System instructions",
- "messages": [
- {
- "role": "assistant",
- "content": [
- {"type": "thinking", "thinking": "summary"},
- {"type": "redacted_thinking", "data": "opaque"},
- {"type": "text", "text": "Calling a tool"},
- {
- "type": "tool_use",
- "id": "call_1",
- "name": "lookup",
- "input": {"q": "value"},
- },
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_1",
- "content": {"answer": 42},
- },
- {"type": "text", "text": "Continue"},
- {
- "type": "image",
- "source": {
- "type": "base64",
- "media_type": "image/png",
- "data": "aGVsbG8=",
- },
- },
- ],
+def _body(
+ request: InferenceRequest,
+ *,
+ scope: ReplayCompatibilityScope = _SCOPE,
+ reasoning: ReasoningPolicy = ReasoningPolicy.provider_default(),
+) -> dict[str, object]:
+ return build_responses_request_body(
+ request,
+ provider_model="test-model",
+ reasoning=reasoning,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=scope,
+ )
+
+
+def test_responses_request_codec_preserves_multiturn_canonical_semantics() -> None:
+ request = InferenceRequest(
+ model="gateway-model",
+ max_output_tokens=4_096,
+ items=(
+ InstructionItem(
+ text="System instructions",
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ ),
+ ReasoningItem(
+ turn_id="turn_0",
+ reasoning="summary",
+ artifacts=(
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI,
+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,
+ attachment=ReplayAttachment.REASONING,
+ payload="opaque",
+ scope=_SCOPE,
+ ),
+ ),
+ ),
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.ASSISTANT,
+ content=(TextContent("Calling a tool"),),
+ ),
+ ToolCallItem(
+ turn_id="turn_0",
+ call_id="call_1",
+ kind=ToolCallKind.FUNCTION,
+ name="lookup",
+ input={"q": "value"},
+ ),
+ ToolResultItem(
+ turn_id="turn_1",
+ call_id="call_1",
+ content={"answer": 42},
+ ),
+ MessageItem(
+ turn_id="turn_1",
+ role=MessageRole.USER,
+ content=(
+ TextContent("Continue"),
+ ImageContent(
+ Base64MediaSource(
+ media_type="image/png",
+ data="aGVsbG8=",
+ )
+ ),
+ ),
+ ),
+ ),
+ tools=(
+ FunctionTool(
+ name="lookup",
+ description="Look up a value",
+ input_schema={
+ "type": "object",
+ "properties": {"q": {"type": "string"}},
},
- ],
- "tools": [
- {
- "name": "lookup",
- "description": "Look up a value",
- "input_schema": {
- "type": "object",
- "properties": {"q": {"type": "string"}},
- },
- }
- ],
- "tool_choice": {"type": "tool", "name": "lookup"},
- }
+ ),
+ ),
+ tool_choice=ToolChoice(
+ ToolChoiceMode.SPECIFIC,
+ kind=ToolCallKind.FUNCTION,
+ name="lookup",
+ ),
)
- body = build_responses_provider_request(
+ body = _body(
request,
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),
)
- assert body["model"] == "gpt-test"
+ assert body["model"] == "test-model"
assert body["instructions"] == "System instructions"
- assert body["max_output_tokens"] == 4096
+ assert body["max_output_tokens"] == 4_096
assert body["stream"] is True
assert body["store"] is False
assert body["include"] == ["reasoning.encrypted_content"]
assert body["reasoning"] == {"effort": "xhigh", "summary": "auto"}
assert body["tool_choice"] == {"type": "function", "name": "lookup"}
- assert body["input"][0] == {
+ input_items = body["input"]
+ assert isinstance(input_items, list)
+ assert input_items[0] == {
"type": "reasoning",
"summary": [{"type": "summary_text", "text": "summary"}],
"encrypted_content": "opaque",
}
- assert body["input"][1]["role"] == "assistant"
- assert body["input"][2] == {
+ assert input_items[1]["role"] == "assistant"
+ assert input_items[2] == {
"type": "function_call",
"call_id": "call_1",
"name": "lookup",
@@ -102,427 +157,224 @@ def test_build_responses_provider_request_preserves_multiturn_protocol() -> None
{"q": "value"}, ensure_ascii=False, separators=(",", ":")
),
}
- assert body["input"][3] == {
+ assert input_items[3] == {
"type": "function_call_output",
"call_id": "call_1",
"output": '{"answer": 42}',
}
- assert body["input"][4]["content"][1] == {
+ assert input_items[4]["content"][1] == {
"type": "input_image",
"image_url": "data:image/png;base64,aGVsbG8=",
}
-def test_build_responses_provider_request_accepts_claude_client_controls() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "thinking": {"type": "adaptive", "display": "omitted"},
- "context_management": {"edits": [_KEEP_ALL_THINKING_EDIT]},
- "output_config": {"effort": "high"},
- }
- )
- snapshot = request.model_dump()
-
- body = build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
- )
-
- assert body["reasoning"] == {"effort": "high", "summary": "auto"}
- assert "context_management" not in body
- assert "output_config" not in body
- assert request.model_dump() == snapshot
-
-
-def test_build_responses_provider_request_materializes_auto_tool_choice() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "Use the echo tool."}],
- "tools": [
- {
- "name": "echo",
- "description": "Echo a value.",
- "input_schema": {
- "type": "object",
- "properties": {"value": {"type": "string"}},
- "required": ["value"],
- },
- }
- ],
- }
+def test_only_scope_matched_reasoning_artifact_is_replayed() -> None:
+ request = InferenceRequest(
+ model="gateway-model",
+ items=(
+ ReasoningItem(
+ turn_id="turn_0",
+ reasoning="summary",
+ artifacts=(
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI,
+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,
+ attachment=ReplayAttachment.REASONING,
+ payload="opaque",
+ scope=_SCOPE,
+ ),
+ ),
+ ),
+ MessageItem(
+ turn_id="turn_1",
+ role=MessageRole.USER,
+ content=(TextContent("Continue"),),
+ ),
+ ),
)
- body = build_responses_provider_request(
+ matching = _body(request)
+ incompatible = _body(
request,
- reasoning=ReasoningPolicy.off(),
+ scope=ReplayCompatibilityScope("openai_responses:other-model"),
)
- assert body["tool_choice"] == "auto"
-
-
-def test_build_responses_provider_request_omits_choice_without_tools() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "Hello"}],
- }
+ matching_input = matching["input"]
+ incompatible_input = incompatible["input"]
+ assert isinstance(matching_input, list)
+ assert isinstance(incompatible_input, list)
+ assert matching_input[0]["encrypted_content"] == "opaque"
+ assert "encrypted_content" not in incompatible_input[0]
+
+
+def test_namespaced_and_custom_tool_identity_is_encoded_once() -> None:
+ request = InferenceRequest(
+ model="gateway-model",
+ items=(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("Use tools"),),
+ ),
+ ),
+ tools=(
+ FunctionTool(
+ name="lookup",
+ namespace="mcp__db",
+ description=None,
+ input_schema={"type": "object"},
+ ),
+ CustomTool(
+ name="patch",
+ namespace="repo",
+ description="Apply a patch",
+ format=CustomToolFormat(
+ CustomToolFormatType.GRAMMAR,
+ syntax="lark",
+ definition="start: /.+/",
+ ),
+ ),
+ ),
+ tool_choice=ToolChoice(
+ ToolChoiceMode.SPECIFIC,
+ kind=ToolCallKind.CUSTOM,
+ name="patch",
+ namespace="repo",
+ ),
)
- body = build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.off(),
- )
+ body = _body(request)
- assert "tools" not in body
- assert "tool_choice" not in body
+ tools = body["tools"]
+ assert isinstance(tools, list)
+ assert [tool["name"] for tool in tools] == ["mcp__db__lookup", "repo__patch"]
+ assert body["tool_choice"] == {"type": "custom", "name": "repo__patch"}
-def test_build_responses_provider_request_uses_resolved_reasoning_policy() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "output_config": {"effort": "low"},
- }
+def test_auto_choice_is_materialized_only_when_tools_exist() -> None:
+ message = MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("Hello"),),
)
-
- body = build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.on(effort=ReasoningEffort.MAX),
+ without_tools = _body(InferenceRequest(model="model", items=(message,)))
+ with_tools = _body(
+ InferenceRequest(
+ model="model",
+ items=(message,),
+ tools=(
+ FunctionTool(
+ name="echo",
+ description=None,
+ input_schema={"type": "object"},
+ ),
+ ),
+ )
)
- assert body["reasoning"] == {"effort": "max", "summary": "auto"}
+ assert "tool_choice" not in without_tools
+ assert with_tools["tool_choice"] == "auto"
- "context_management",
- [
- None,
- {},
- {"edits": []},
- {"edits": [_KEEP_ALL_THINKING_EDIT]},
- {"edits": [_KEEP_ALL_THINKING_EDIT, _KEEP_ALL_THINKING_EDIT]},
- ],
-)
-def test_build_responses_provider_request_accepts_noop_context_management(
- context_management: dict[str, object] | None,
-) -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "context_management": context_management,
- }
+def test_resolved_reasoning_policy_is_the_only_upstream_reasoning_owner() -> None:
+ request = InferenceRequest(
+ model="model",
+ items=(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("Hello"),),
+ ),
+ ),
)
- body = build_responses_provider_request(
+ assert _body(request, reasoning=ReasoningPolicy.off())["reasoning"] == {
+ "effort": "none"
+ }
+ assert _body(
request,
- reasoning=ReasoningPolicy.provider_default(),
- )
-
- assert "context_management" not in body
-
-
- "context_management",
- [
- {"edits": [{"type": "clear_thinking_20251015"}]},
- {
- "edits": [
- {
- "type": "clear_thinking_20251015",
- "keep": {"type": "thinking_turns", "value": 2},
- }
- ]
- },
- {"edits": [{"type": "clear_tool_uses_20250919"}]},
- {"edits": [{"type": "unknown_edit", "keep": "all"}]},
- {
- "edits": [
- {
- **_KEEP_ALL_THINKING_EDIT,
- "extra": True,
- }
- ]
- },
- {"edits": [], "extra": True},
- {"edits": None},
- {"edits": {}},
- {"edits": "not-a-list"},
- ],
-)
-def test_build_responses_provider_request_rejects_active_or_malformed_context(
- context_management: dict[str, object],
-) -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "context_management": context_management,
- }
- )
-
- with pytest.raises(ResponsesConversionError, match="context_management"):
- build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.provider_default(),
- )
+ reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ )["reasoning"] == {"effort": "high", "summary": "auto"}
@pytest.mark.parametrize(
- ("effort", "reasoning", "expected"),
+ ("canonical", "match"),
[
(
- "high",
- ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
- {"effort": "high", "summary": "auto"},
+ InferenceRequest(
+ model="model",
+ items=(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("Hello"),),
+ ),
+ ),
+ stop_sequences=("stop",),
+ ),
+ "stop_sequences",
),
- ("none", ReasoningPolicy.off(), {"effort": "none"}),
- ("future", ReasoningPolicy.provider_default(), None),
- ],
-)
-def test_build_responses_provider_request_accepts_application_owned_effort(
- effort: str,
- reasoning: ReasoningPolicy,
- expected: dict[str, str] | None,
-) -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "output_config": {"effort": effort},
- }
- )
-
- body = build_responses_provider_request(request, reasoning=reasoning)
-
- assert body.get("reasoning") == expected
- assert "output_config" not in body
-
-
- ("output_config", "unsupported_path"),
- [
- ({"format": {"type": "json_schema"}}, "output_config.format"),
(
- {"effort": "high", "format": {"type": "json_schema"}},
- "output_config.format",
+ InferenceRequest(
+ model="model",
+ items=(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(DocumentContent(FileMediaSource("file_1")),),
+ ),
+ ),
+ ),
+ "document",
+ ),
+ (
+ InferenceRequest(
+ model="model",
+ items=(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("Hello", CacheControl()),),
+ ),
+ ),
+ ),
+ "cache_control",
+ ),
+ (
+ InferenceRequest(
+ model="model",
+ items=(
+ MessageItem(
+ turn_id="turn_0",
+ role=MessageRole.USER,
+ content=(TextContent("Hello"),),
+ ),
+ ),
+ extensions=(OpenAIChatExtension({"extension": True}),),
+ ),
+ "extensions",
),
- ({"future_control": True}, "output_config.future_control"),
- ],
-)
-def test_build_responses_provider_request_rejects_unconsumed_output_config(
- output_config: dict[str, object],
- unsupported_path: str,
-) -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "output_config": output_config,
- }
- )
-
- with pytest.raises(ResponsesConversionError, match=unsupported_path):
- build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.provider_default(),
- )
-
-
-def test_responses_provider_request_uses_one_portable_tool_alias() -> None:
- original = "mcp__responses_provider__" + "x" * 70
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "call_1",
- "name": original,
- "input": {"q": "value"},
- }
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_1",
- "content": "done",
- }
- ],
- },
- ],
- "tools": [
- {
- "name": original,
- "description": "Long tool",
- "input_schema": {"type": "object"},
- },
- {"name": "safe_tool", "input_schema": {"type": "object"}},
- ],
- "tool_choice": {"type": "tool", "name": original},
- }
- )
- snapshot = request.model_dump()
-
- body = build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.provider_default(),
- )
-
- alias = body["tools"][0]["name"]
- assert alias != original
- assert len(alias) <= 64
- assert body["tools"][1]["name"] == "safe_tool"
- assert body["tool_choice"] == {"type": "function", "name": alias}
- function_call = next(
- item for item in body["input"] if item["type"] == "function_call"
- )
- assert function_call["name"] == alias
- assert function_call["call_id"] == "call_1"
- assert function_call["arguments"] == '{"q":"value"}'
- assert request.model_dump() == snapshot
-
-
-def test_responses_round_trip_preserves_encrypted_reasoning_and_tool_ids() -> None:
- adapter = OpenAIResponsesAdapter()
- ingress = OpenAIResponsesRequest.model_validate(
- {
- "model": "openai/gpt-test",
- "input": [
- {
- "type": "reasoning",
- "summary": [{"type": "summary_text", "text": "Use a tool."}],
- "encrypted_content": "opaque-reasoning",
- },
- {
- "type": "function_call",
- "call_id": "call_stable",
- "name": "lookup",
- "arguments": '{"q":"value"}',
- },
- {
- "type": "function_call_output",
- "call_id": "call_stable",
- "output": "done",
- },
- ],
- }
- )
- anthropic = MessagesRequest.model_validate(adapter.to_anthropic_payload(ingress))
-
- body = build_responses_provider_request(
- anthropic,
- reasoning=ReasoningPolicy.provider_default(),
- )
-
- assert body["input"][:3] == [
- {
- "type": "reasoning",
- "summary": [{"type": "summary_text", "text": "Use a tool."}],
- "encrypted_content": "opaque-reasoning",
- },
- {
- "type": "function_call",
- "call_id": "call_stable",
- "name": "lookup",
- "arguments": '{"q":"value"}',
- },
- {
- "type": "function_call_output",
- "call_id": "call_stable",
- "output": "done",
- },
- ]
-
-
-def test_responses_reasoning_round_trip_reaches_provider_request() -> None:
- adapter = OpenAIResponsesAdapter()
- ingress = OpenAIResponsesRequest.model_validate(
- {
- "model": "openai/gpt-test",
- "input": "hello",
- "reasoning": {"effort": "high"},
- }
- )
- anthropic = MessagesRequest.model_validate(adapter.to_anthropic_payload(ingress))
-
- body = build_responses_provider_request(
- anthropic,
- reasoning=client_reasoning_policy(anthropic),
- )
-
- assert body["reasoning"] == {"effort": "high", "summary": "auto"}
- assert "output_config" not in body
-
-
- ("field", "value"),
- [
- ("stop_sequences", ["stop"]),
- ("top_k", 4),
- ("mcp_servers", [{"name": "server"}]),
- ("extra_body", {"unknown": True}),
],
)
-def test_build_responses_provider_request_rejects_lossy_fields(
- field: str, value: object
+def test_unrepresentable_canonical_semantics_are_rejected_before_io(
+ canonical: InferenceRequest,
+ match: str,
) -> None:
- payload = {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- field: value,
- }
-
- with pytest.raises(ResponsesConversionError, match=field):
- build_responses_provider_request(
- MessagesRequest.model_validate(payload),
- reasoning=ReasoningPolicy.provider_default(),
- )
-
-
-def test_build_responses_provider_request_rejects_provider_managed_tools() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "tools": [
- {
- "name": "web_search",
- "type": "web_search_20250305",
- "input_schema": {"type": "object"},
- }
- ],
- }
- )
-
- with pytest.raises(ResponsesConversionError, match="web_search_20250305"):
- build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.provider_default(),
- )
-
-
-def test_build_responses_provider_request_rejects_unknown_request_fields() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "gpt-test",
- "messages": [{"role": "user", "content": "hello"}],
- "future_field": True,
- }
+ with pytest.raises(ResponsesRequestEncodingError, match=match):
+ _body(canonical)
+
+
+def test_codec_requires_a_conversational_input_item() -> None:
+ request = InferenceRequest(
+ model="model",
+ items=(
+ InstructionItem(
+ text="System only",
+ origin=InstructionOrigin.SYSTEM,
+ placement=InstructionPlacement.TOP_LEVEL,
+ ),
+ ),
)
- with pytest.raises(ResponsesConversionError, match="future_field"):
- build_responses_provider_request(
- request,
- reasoning=ReasoningPolicy.provider_default(),
- )
+ with pytest.raises(ResponsesRequestEncodingError, match="conversational input"):
+ _body(request)
diff --git a/tests/core/openai_responses/test_provider_stream.py b/tests/core/openai_responses/test_provider_stream.py
index 79c2a1cf..0fa35f8f 100644
--- a/tests/core/openai_responses/test_provider_stream.py
+++ b/tests/core/openai_responses/test_provider_stream.py
@@ -1,23 +1,31 @@
import pytest
-from free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec
from free_claude_code.core.anthropic.stream_contracts import (
assert_anthropic_stream_contract,
parse_sse_text,
thinking_content,
)
-from free_claude_code.core.openai_responses.provider_events import (
+from free_claude_code.core.inference import (
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+)
+from free_claude_code.core.replay_envelope import decode_replay_envelope
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+from free_claude_code.providers.openai_responses.events import (
ResponsesEventDecoder,
ResponsesStreamFailure,
)
from tests.inference_support import present_anthropic
+_REPLAY_SCOPE = ReplayCompatibilityScope("openai_responses:test-model")
+
def test_responses_decoder_preserves_reasoning_tools_usage_and_ids() -> None:
stream = ResponsesEventDecoder(
response_id="response_test",
model="openai/gpt-test",
input_tokens=12,
+ replay_scope=_REPLAY_SCOPE,
)
output = stream.start()
output.extend(
@@ -111,7 +119,15 @@ def test_responses_decoder_preserves_reasoning_tools_usage_and_ids() -> None:
for event in events
if event.event == "content_block_start"
]
- assert {"type": "redacted_thinking", "data": "opaque"} in starts
+ redacted = next(block for block in starts if block["type"] == "redacted_thinking")
+ assert isinstance(redacted["data"], str)
+ artifacts = decode_replay_envelope(
+ redacted["data"],
+ attachment=ReplayAttachment.REASONING,
+ )
+ assert artifacts is not None
+ assert [artifact.payload for artifact in artifacts] == ["opaque"]
+ assert [artifact.scope for artifact in artifacts] == [_REPLAY_SCOPE]
assert {
"type": "tool_use",
"id": "call_1",
@@ -150,6 +166,7 @@ def test_responses_decoder_ignores_invalid_cache_partitions(
response_id="response_test",
model="openai/gpt-test",
input_tokens=12,
+ replay_scope=_REPLAY_SCOPE,
)
output = stream.start()
output.extend(
@@ -183,6 +200,7 @@ def test_responses_decoder_surfaces_failed_event() -> None:
response_id="response_test",
model="gpt-test",
input_tokens=0,
+ replay_scope=_REPLAY_SCOPE,
)
with pytest.raises(ResponsesStreamFailure, match="capacity") as exc_info:
@@ -212,6 +230,7 @@ def test_responses_decoder_restores_added_and_done_only_tool_names() -> None:
model="gpt-test",
input_tokens=0,
tool_names=codec,
+ replay_scope=_REPLAY_SCOPE,
)
output = stream.start()
output.extend(
diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.py
index d4d0f082..6723cdbf 100644
--- a/tests/core/openai_responses/test_sse.py
+++ b/tests/core/openai_responses/test_sse.py
@@ -17,11 +17,12 @@ from free_claude_code.core.inference import (
ReplayAttachment,
ResponseStarted,
)
-from free_claude_code.core.openai_responses import OpenAIResponsesRequest
+from free_claude_code.core.openai_responses import ResponsesPresentationSnapshot
from free_claude_code.core.openai_responses.presenter import (
ResponsesEventPresenter,
iter_responses_sse_from_events,
)
+from free_claude_code.core.replay_envelope import decode_replay_envelope
from tests.inference_support import reported_usage, text_event_stream
@@ -57,14 +58,15 @@ class _CloseTrackingEvents:
raise self._close_error
-def _request(**overrides: object) -> OpenAIResponsesRequest:
- payload: dict[str, object] = {
- "model": "nvidia_nim/test-model",
- "input": "hello",
- "stream": True,
- }
- payload.update(overrides)
- return OpenAIResponsesRequest.model_validate(payload)
+def _snapshot() -> ResponsesPresentationSnapshot:
+ return ResponsesPresentationSnapshot(
+ model="nvidia_nim/test-model",
+ parallel_tool_calls=True,
+ tool_choice="auto",
+ temperature=None,
+ top_p=None,
+ max_output_tokens=None,
+ )
async def _aiter(events: list[InferenceEvent]) -> AsyncIterator[InferenceEvent]:
@@ -77,7 +79,7 @@ async def _collect(events: list[InferenceEvent]) -> list[str]:
chunk
async for chunk in iter_responses_sse_from_events(
_aiter(events),
- _request(),
+ _snapshot(),
)
]
@@ -149,7 +151,14 @@ async def test_reasoning_replay_and_tool_call_remain_semantic_until_presented()
final = parsed[-1].data["response"]
reasoning, tool = final["output"]
assert reasoning["type"] == "reasoning"
- assert reasoning["encrypted_content"] == "opaque"
+ encrypted = reasoning["encrypted_content"]
+ assert isinstance(encrypted, str)
+ artifacts = decode_replay_envelope(
+ encrypted,
+ attachment=ReplayAttachment.REASONING,
+ )
+ assert artifacts is not None
+ assert [artifact.payload for artifact in artifacts] == ["opaque"]
assert tool == {
"id": tool["id"],
"type": "function_call",
@@ -195,7 +204,7 @@ async def test_pre_start_failure_is_not_hidden_in_a_responses_envelope() -> None
source = _CloseTrackingEvents([], iteration_error=failure)
with pytest.raises(ExecutionFailure) as exc_info:
- [chunk async for chunk in iter_responses_sse_from_events(source, _request())]
+ [chunk async for chunk in iter_responses_sse_from_events(source, _snapshot())]
assert exc_info.value is failure
assert source.close_calls == 1
@@ -219,7 +228,7 @@ async def test_post_start_failure_becomes_one_terminal_response_event() -> None:
chunk
async for chunk in iter_responses_sse_from_events(
source,
- _request(),
+ _snapshot(),
on_post_start_terminal_failure=observed.append,
)
]
@@ -237,7 +246,7 @@ async def test_post_start_failure_becomes_one_terminal_response_event() -> None:
@pytest.mark.asyncio
async def test_early_consumer_close_closes_canonical_source_once() -> None:
source = _CloseTrackingEvents(text_event_stream("hello"))
- stream = iter_responses_sse_from_events(source, _request())
+ stream = iter_responses_sse_from_events(source, _snapshot())
assert parse_sse_text(await anext(stream))[0].event == "response.created"
assert isinstance(stream, AsyncCloseable)
@@ -247,7 +256,7 @@ async def test_early_consumer_close_closes_canonical_source_once() -> None:
def test_presenter_rejects_events_after_terminal_completion() -> None:
- presenter = ResponsesEventPresenter(_request())
+ presenter = ResponsesEventPresenter(_snapshot())
for event in text_event_stream("done"):
presenter.present(event)
diff --git a/tests/core/test_protocol_model_ownership.py b/tests/core/test_protocol_model_ownership.py
index 4b5921b6..08c61a40 100644
--- a/tests/core/test_protocol_model_ownership.py
+++ b/tests/core/test_protocol_model_ownership.py
@@ -2,6 +2,9 @@
import subprocess
import sys
+from dataclasses import FrozenInstanceError
+
+import pytest
from free_claude_code.core.anthropic import (
MessagesRequest as PublicMessagesRequest,
@@ -11,6 +14,23 @@ from free_claude_code.core.anthropic import (
TokenCountResponse,
)
from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import (
+ FunctionTool,
+ InferenceRequest,
+ MessageItem,
+ MessageRole,
+ OpenAIChatExtension,
+ ReasoningItem,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolResultItem,
+ inference_request_snapshot,
+)
from free_claude_code.core.openai_responses import (
OpenAIResponsesRequest as PublicOpenAIResponsesRequest,
)
@@ -53,6 +73,116 @@ def test_anthropic_response_models_are_protocol_owned() -> None:
assert TokenCountResponse.__module__ == "free_claude_code.core.anthropic.models"
+def test_wire_request_models_do_not_carry_internal_route_state() -> None:
+ internal_fields = {
+ "original_model",
+ "provider_model",
+ "resolved_provider_model",
+ "resolved_reasoning",
+ }
+
+ assert internal_fields.isdisjoint(MessagesRequest.model_fields)
+ assert internal_fields.isdisjoint(OpenAIResponsesRequest.model_fields)
+
+
+def test_canonical_request_owns_recursive_copies_and_is_frozen() -> None:
+ arguments = {"nested": {"value": 1}}
+ result = {"items": ["first"]}
+ schema = {"type": "object", "properties": {"value": {"type": "integer"}}}
+ metadata = {"trace": {"enabled": True}}
+ extension = {"service": {"tier": "free"}}
+ request = InferenceRequest(
+ model="client-model",
+ items=(
+ MessageItem("turn_0", MessageRole.USER, (TextContent("Hello"),)),
+ ToolCallItem(
+ "turn_1",
+ "call_1",
+ ToolCallKind.FUNCTION,
+ "lookup",
+ arguments,
+ ),
+ ToolResultItem("turn_2", "call_1", result),
+ ),
+ tools=(FunctionTool("lookup", None, schema),),
+ metadata=metadata,
+ extensions=(OpenAIChatExtension(extension),),
+ )
+
+ arguments["nested"] = {"value": 2}
+ result["items"] = ["changed"]
+ schema["properties"] = {}
+ metadata["trace"] = {"enabled": False}
+ extension["service"] = {"tier": "paid"}
+
+ call = request.items[1]
+ tool_result = request.items[2]
+ assert isinstance(call, ToolCallItem)
+ assert call.input == {"nested": {"value": 1}}
+ assert isinstance(tool_result, ToolResultItem)
+ assert tool_result.content == {"items": ("first",)}
+ tool = request.tools[0]
+ assert isinstance(tool, FunctionTool)
+ assert tool.input_schema["properties"] == {"value": {"type": "integer"}}
+ assert request.metadata == {"trace": {"enabled": True}}
+ assert request.openai_chat_extension is not None
+ assert request.openai_chat_extension.extra_body == {"service": {"tier": "free"}}
+ field_name = "model"
+ with pytest.raises(FrozenInstanceError):
+ setattr(request, field_name, "other-model")
+
+
+def test_canonical_request_snapshot_contains_structure_but_no_client_payloads() -> None:
+ request = InferenceRequest(
+ model="public-model",
+ items=(
+ MessageItem(
+ "turn_0",
+ MessageRole.USER,
+ (TextContent("private-prompt"),),
+ ),
+ ReasoningItem(
+ "turn_1",
+ "private-reasoning",
+ artifacts=(
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI,
+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,
+ attachment=ReplayAttachment.REASONING,
+ payload="private-replay",
+ ),
+ ),
+ ),
+ ToolCallItem(
+ "turn_1",
+ "call_1",
+ ToolCallKind.FUNCTION,
+ "lookup",
+ {"secret": "private-tool-arguments"},
+ ),
+ ),
+ tools=(FunctionTool("lookup", None, {"type": "object"}),),
+ metadata={"secret": "private-metadata"},
+ extensions=(OpenAIChatExtension({"secret": "private-extra-body"}),),
+ )
+
+ snapshot = inference_request_snapshot(request)
+ rendered = repr(snapshot)
+
+ assert snapshot["item_count"] == 3
+ assert snapshot["message_count"] == 2
+ assert snapshot["tool_count"] == 1
+ for secret in (
+ "private-prompt",
+ "private-reasoning",
+ "private-replay",
+ "private-tool-arguments",
+ "private-metadata",
+ "private-extra-body",
+ ):
+ assert secret not in rendered
+
+
def test_protocol_facades_are_import_order_independent() -> None:
import_orders = (
(
diff --git a/tests/core/test_replay_envelope.py b/tests/core/test_replay_envelope.py
new file mode 100644
index 00000000..7c304cc2
--- /dev/null
+++ b/tests/core/test_replay_envelope.py
@@ -0,0 +1,285 @@
+import base64
+import json
+from collections.abc import Mapping
+
+import pytest
+
+from free_claude_code.core.inference import (
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+)
+from free_claude_code.core.replay_envelope import (
+ REPLAY_ENVELOPE_PREFIX,
+ ReplayEnvelopeError,
+ decode_replay_envelope,
+ encode_replay_envelope,
+)
+
+
+def _carrier(payload: object) -> str:
+ raw = json.dumps(payload, separators=(",", ":")).encode()
+ token = base64.urlsafe_b64encode(raw).decode().rstrip("=")
+ return f"{REPLAY_ENVELOPE_PREFIX}{token}"
+
+
+def _artifact_payload(
+ *,
+ origin: str = "openai",
+ kind: str = "encrypted_reasoning",
+ attachment: str = "reasoning",
+ scope: object = "openai_responses:model",
+ payload: object = "opaque",
+) -> dict[str, object]:
+ return {
+ "origin": origin,
+ "kind": kind,
+ "attachment": attachment,
+ "scope": scope,
+ "payload": payload,
+ }
+
+
+ ("kind", "attachment"),
+ [
+ (ReplayArtifactKind.THINKING_SIGNATURE, ReplayAttachment.REASONING),
+ (ReplayArtifactKind.REDACTED_THINKING, ReplayAttachment.REASONING),
+ (ReplayArtifactKind.ENCRYPTED_REASONING, ReplayAttachment.REASONING),
+ (ReplayArtifactKind.REASONING_DETAILS, ReplayAttachment.REASONING),
+ (ReplayArtifactKind.THOUGHT_SIGNATURE, ReplayAttachment.TOOL_CALL),
+ (ReplayArtifactKind.TOOL_EXTRA_CONTENT, ReplayAttachment.TOOL_CALL),
+ ],
+)
+def test_each_replay_artifact_kind_round_trips(
+ kind: ReplayArtifactKind,
+ attachment: ReplayAttachment,
+) -> None:
+ artifact = ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,
+ kind=kind,
+ attachment=attachment,
+ scope=ReplayCompatibilityScope("provider:model"),
+ payload={"opaque": [kind.value, 1, True, None]},
+ )
+
+ assert decode_replay_envelope(
+ encode_replay_envelope((artifact,)), attachment=attachment
+ ) == (artifact,)
+
+
+ "attachment",
+ [ReplayAttachment.REASONING, ReplayAttachment.TOOL_CALL],
+)
+def test_multiple_artifacts_keep_order_and_encode_deterministically(
+ attachment: ReplayAttachment,
+) -> None:
+ origins = tuple(ReplayArtifactOrigin)
+ kinds = (
+ (
+ ReplayArtifactKind.THINKING_SIGNATURE,
+ ReplayArtifactKind.REDACTED_THINKING,
+ ReplayArtifactKind.ENCRYPTED_REASONING,
+ ReplayArtifactKind.REASONING_DETAILS,
+ )
+ if attachment is ReplayAttachment.REASONING
+ else (
+ ReplayArtifactKind.THOUGHT_SIGNATURE,
+ ReplayArtifactKind.TOOL_EXTRA_CONTENT,
+ )
+ )
+ artifacts = tuple(
+ ReplayArtifact(
+ origin=origins[index % len(origins)],
+ kind=kind,
+ attachment=attachment,
+ scope=(ReplayCompatibilityScope("provider:model") if index else None),
+ payload={"index": index},
+ )
+ for index, kind in enumerate(kinds)
+ )
+
+ first = encode_replay_envelope(artifacts)
+ second = encode_replay_envelope(artifacts)
+
+ assert first == second
+ assert decode_replay_envelope(first, attachment=attachment) == artifacts
+
+
+def test_legacy_raw_replay_value_is_not_claimed_by_the_envelope_codec() -> None:
+ assert (
+ decode_replay_envelope(
+ "provider-owned-opaque-value",
+ attachment=ReplayAttachment.REASONING,
+ )
+ is None
+ )
+
+
+def test_empty_artifact_sequence_cannot_be_encoded() -> None:
+ with pytest.raises(ValueError, match="at least one artifact"):
+ encode_replay_envelope(())
+
+
+ ("value", "match"),
+ [
+ (REPLAY_ENVELOPE_PREFIX, "payload is empty"),
+ (f"{REPLAY_ENVELOPE_PREFIX}*", "valid base64url"),
+ (
+ f"{REPLAY_ENVELOPE_PREFIX}"
+ + base64.urlsafe_b64encode(b"\xff").decode().rstrip("="),
+ "valid UTF-8 JSON",
+ ),
+ (
+ f"{REPLAY_ENVELOPE_PREFIX}"
+ + base64.urlsafe_b64encode(b"{").decode().rstrip("="),
+ "valid UTF-8 JSON",
+ ),
+ (_carrier([]), "top-level schema"),
+ (_carrier({"version": 1}), "top-level schema"),
+ (_carrier({"version": 2, "artifacts": []}), "version is unsupported"),
+ (
+ _carrier({"version": 1, "artifacts": []}),
+ "artifacts must be a non-empty list",
+ ),
+ (
+ _carrier({"version": 1, "artifacts": ["opaque"]}),
+ "artifacts\\[0\\] has an invalid schema",
+ ),
+ (
+ _carrier(
+ {
+ "version": 1,
+ "artifacts": [{**_artifact_payload(), "extra": True}],
+ }
+ ),
+ "artifacts\\[0\\] has an invalid schema",
+ ),
+ (
+ _carrier(
+ {
+ "version": 1,
+ "artifacts": [_artifact_payload(origin="unknown")],
+ }
+ ),
+ "unknown artifact value",
+ ),
+ (
+ _carrier(
+ {
+ "version": 1,
+ "artifacts": [_artifact_payload(kind="unknown")],
+ }
+ ),
+ "unknown artifact value",
+ ),
+ (
+ _carrier(
+ {
+ "version": 1,
+ "artifacts": [_artifact_payload(attachment="unknown")],
+ }
+ ),
+ "unknown artifact value",
+ ),
+ (
+ _carrier(
+ {
+ "version": 1,
+ "artifacts": [_artifact_payload(scope="")],
+ }
+ ),
+ "scope must be null or a non-empty string",
+ ),
+ (
+ _carrier(
+ {
+ "version": 1,
+ "artifacts": [_artifact_payload(scope=42)],
+ }
+ ),
+ "scope must be null or a non-empty string",
+ ),
+ (
+ _carrier(
+ {
+ "version": 1,
+ "artifacts": [_artifact_payload(payload=float("nan"))],
+ }
+ ),
+ "payload is not valid JSON",
+ ),
+ ],
+)
+def test_malformed_envelopes_fail_with_stable_safe_errors(
+ value: str,
+ match: str,
+) -> None:
+ with pytest.raises(ReplayEnvelopeError, match=match):
+ decode_replay_envelope(value, attachment=ReplayAttachment.REASONING)
+
+
+def test_carrier_attachment_must_match_every_artifact() -> None:
+ value = _carrier(
+ {
+ "version": 1,
+ "artifacts": [_artifact_payload(attachment="tool_call")],
+ }
+ )
+
+ with pytest.raises(ReplayEnvelopeError, match="does not match its carrier"):
+ decode_replay_envelope(value, attachment=ReplayAttachment.REASONING)
+
+
+def test_encode_rejects_non_finite_json_numbers() -> None:
+ artifact = ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI,
+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,
+ attachment=ReplayAttachment.REASONING,
+ payload=float("inf"),
+ )
+
+ with pytest.raises(ValueError, match="Out of range float values"):
+ encode_replay_envelope((artifact,))
+
+
+def test_encoded_and_decoded_size_limits_are_enforced() -> None:
+ artifact = ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI,
+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,
+ attachment=ReplayAttachment.REASONING,
+ payload="x" * 1_048_576,
+ )
+ with pytest.raises(ValueError, match="size limit"):
+ encode_replay_envelope((artifact,))
+
+ oversized = base64.urlsafe_b64encode(b"x" * 1_048_577).decode().rstrip("=")
+ with pytest.raises(ReplayEnvelopeError, match="size limit"):
+ decode_replay_envelope(
+ f"{REPLAY_ENVELOPE_PREFIX}{oversized}",
+ attachment=ReplayAttachment.REASONING,
+ )
+
+
+def test_errors_and_logs_do_not_expose_replay_payload(
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ secret = "private-replay-material"
+ raw_artifact = _artifact_payload(payload={"secret": secret})
+ assert isinstance(raw_artifact, Mapping)
+ value = _carrier(
+ {
+ "version": 1,
+ "artifacts": [{**raw_artifact, "unexpected": True}],
+ }
+ )
+
+ with pytest.raises(ReplayEnvelopeError) as captured:
+ decode_replay_envelope(value, attachment=ReplayAttachment.REASONING)
+
+ assert secret not in str(captured.value)
+ assert secret not in caplog.text
diff --git a/tests/providers/request_factory.py b/tests/providers/request_factory.py
index bce4cff2..9cb2af41 100644
--- a/tests/providers/request_factory.py
+++ b/tests/providers/request_factory.py
@@ -1,15 +1,34 @@
-"""Concrete Anthropic request factory for provider tests."""
-
-from typing import Any
+"""Canonical request factories for provider tests."""
+from free_claude_code.core.anthropic import messages_to_inference_request
from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest
+
+type ProviderTestRequest = MessagesRequest | InferenceRequest
+
+
+def canonical_request(request: ProviderTestRequest) -> InferenceRequest:
+ """Cross the production Messages ingress at a provider-test boundary."""
+
+ if isinstance(request, InferenceRequest):
+ return request
+ return messages_to_inference_request(request)
def make_messages_request(
- model: str = "test-model", **overrides: Any
+ model: str = "test-model", **overrides: object
+) -> InferenceRequest:
+ """Build canonical provider input through the real Messages ingress."""
+
+ return messages_to_inference_request(make_messages_wire_request(model, **overrides))
+
+
+def make_messages_wire_request(
+ model: str = "test-model", **overrides: object
) -> MessagesRequest:
- """Build a real Messages request with provider-test defaults."""
- data: dict[str, Any] = {
+ """Build a real Messages wire request with provider-test defaults."""
+
+ data: dict[str, object] = {
"model": model,
"messages": [{"role": "user", "content": "Hello"}],
"max_tokens": 100,
diff --git a/tests/providers/support.py b/tests/providers/support.py
index f6a7e372..d5a99a80 100644
--- a/tests/providers/support.py
+++ b/tests/providers/support.py
@@ -7,6 +7,7 @@ from openai import AsyncOpenAI
from free_claude_code.application.reasoning import client_reasoning_policy
from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
@@ -14,6 +15,7 @@ from free_claude_code.providers.openai_chat import (
OpenAIChatProvider,
create_openai_chat_provider,
)
+from tests.providers.request_factory import canonical_request
REASONING_DEFAULT = ReasoningPolicy.provider_default()
REASONING_ON = ReasoningPolicy.on()
@@ -112,7 +114,9 @@ def profiled_provider(
)
-def reasoning_for(request: MessagesRequest) -> ReasoningPolicy:
+def reasoning_for(
+ request: MessagesRequest | InferenceRequest,
+) -> ReasoningPolicy:
"""Resolve provider-test input through the production client boundary."""
- return client_reasoning_policy(request)
+ return client_reasoning_policy(canonical_request(request).reasoning)
diff --git a/tests/providers/test_agnes.py b/tests/providers/test_agnes.py
index 53e62e26..2e0c7699 100644
--- a/tests/providers/test_agnes.py
+++ b/tests/providers/test_agnes.py
@@ -14,6 +14,7 @@ from free_claude_code.config.provider_catalog import AGNES_DEFAULT_BASE
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -89,8 +90,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images(
)
body = agnes_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "agnes-2.0-flash"
@@ -117,7 +119,9 @@ def test_build_request_body_encodes_documented_thinking_control(
) -> None:
request = _request()
- body = agnes_provider._build_request_body(request, reasoning=reasoning)
+ body = agnes_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
assert body["extra_body"] == {"chat_template_kwargs": {"enable_thinking": enabled}}
@@ -128,8 +132,9 @@ def test_build_request_body_omits_thinking_control_for_provider_default(
request = _request()
body = agnes_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(request).model,
)
assert "extra_body" not in body
@@ -153,8 +158,9 @@ def test_build_request_body_replays_reasoning_in_content_not_undocumented_field(
)
body = agnes_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistant = body["messages"][1]
@@ -172,7 +178,11 @@ def test_build_request_body_rejects_caller_reasoning_override(
request = _request(extra_body={field: "caller-owned"})
with pytest.raises(InvalidRequestError, match="must not override reasoning"):
- agnes_provider._build_request_body(request, reasoning=REASONING_ON)
+ agnes_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
@pytest.mark.asyncio
diff --git a/tests/providers/test_azure_openai.py b/tests/providers/test_azure_openai.py
index edbda2be..cbc565d7 100644
--- a/tests/providers/test_azure_openai.py
+++ b/tests/providers/test_azure_openai.py
@@ -7,7 +7,7 @@ import pytest
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.openai_chat import OpenAIChatProvider
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -63,8 +63,9 @@ def test_request_uses_deployment_name_modern_token_field_tools_and_reasoning() -
)
body = _provider()._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(request).model,
)
assert body["model"] == AZURE_OPENAI_DEPLOYMENT
@@ -89,12 +90,21 @@ def test_reasoning_uses_azure_supported_provider_vocabulary(
expected: str,
) -> None:
body = _provider()._build_request_body(
- make_messages_request(
- AZURE_OPENAI_DEPLOYMENT,
- temperature=None,
- top_p=None,
+ canonical_request(
+ make_messages_request(
+ AZURE_OPENAI_DEPLOYMENT,
+ temperature=None,
+ top_p=None,
+ )
),
reasoning=policy,
+ provider_model=(
+ make_messages_request(
+ AZURE_OPENAI_DEPLOYMENT,
+ temperature=None,
+ top_p=None,
+ )
+ ).model,
)
assert body["reasoning_effort"] == expected
@@ -117,7 +127,9 @@ def test_reasoning_history_replays_as_portable_think_tags() -> None:
],
)
- body = _provider()._build_request_body(request)
+ body = _provider()._build_request_body(
+ canonical_request(request), provider_model=(request).model
+ )
assistant = next(
message for message in body["messages"] if message["role"] == "assistant"
)
diff --git a/tests/providers/test_bedrock.py b/tests/providers/test_bedrock.py
index d7562ce2..d629d7db 100644
--- a/tests/providers/test_bedrock.py
+++ b/tests/providers/test_bedrock.py
@@ -8,7 +8,7 @@ import pytest
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.provider_catalog import BEDROCK_DEFAULT_BASE
from free_claude_code.providers.openai_chat import OpenAIChatProvider
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -75,7 +75,9 @@ def test_request_uses_portable_chat_fields_without_invented_reasoning() -> None:
],
)
- body = _provider()._build_request_body(request)
+ body = _provider()._build_request_body(
+ canonical_request(request), provider_model=(request).model
+ )
assert body["model"] == BEDROCK_MODEL
assert body["messages"][0] == {"role": "system", "content": "System prompt"}
@@ -116,7 +118,9 @@ def test_reasoning_history_replays_as_portable_think_tags() -> None:
],
)
- body = _provider()._build_request_body(request)
+ body = _provider()._build_request_body(
+ canonical_request(request), provider_model=(request).model
+ )
assistant = next(
message for message in body["messages"] if message["role"] == "assistant"
)
diff --git a/tests/providers/test_cerebras.py b/tests/providers/test_cerebras.py
index dd5ed871..6e988ae8 100644
--- a/tests/providers/test_cerebras.py
+++ b/tests/providers/test_cerebras.py
@@ -6,7 +6,7 @@ import pytest
from free_claude_code.config.provider_catalog import CEREBRAS_DEFAULT_BASE
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -89,7 +89,9 @@ def test_default_base_url_constant():
def test_build_request_body_basic(cerebras_provider):
"""Basic request body conversion attaches system message from Claude request."""
req = make_request()
- body = cerebras_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = cerebras_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert body["model"] == "llama3.1-8b"
assert body["messages"][0]["role"] == "system"
@@ -97,7 +99,10 @@ def test_build_request_body_basic(cerebras_provider):
def test_build_request_body_replays_reasoning_as_tagged_content(cerebras_provider):
- body = cerebras_provider._build_request_body(make_reasoning_tool_history_request())
+ body = cerebras_provider._build_request_body(
+ canonical_request(make_reasoning_tool_history_request()),
+ provider_model=(make_reasoning_tool_history_request()).model,
+ )
assistant = next(
message for message in body["messages"] if message["role"] == "assistant"
@@ -129,7 +134,9 @@ def test_replay_is_independent_of_current_turn_reasoning_control():
admission=immediate_admission(),
)
body = provider._build_request_body(
- make_reasoning_tool_history_request(), reasoning=REASONING_OFF
+ canonical_request(make_reasoning_tool_history_request()),
+ reasoning=REASONING_OFF,
+ provider_model=(make_reasoning_tool_history_request()).model,
)
assistant = next(
@@ -153,7 +160,11 @@ def test_build_request_body_remaps_max_tokens_preserves_message_name(cerebras_pr
"max_tokens": 42,
}
req = make_request()
- body = cerebras_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = cerebras_provider._build_request_body(
+ canonical_request(req),
+ reasoning=reasoning_for(req),
+ provider_model=(req).model,
+ )
assert body["messages"][0].get("name") == "alice"
assert body.get("max_tokens") is None
@@ -170,7 +181,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(cerebras_prov
"max_completion_tokens": 77,
"max_tokens": 999,
}
- body = cerebras_provider._build_request_body(make_request())
+ body = cerebras_provider._build_request_body(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
assert body["max_completion_tokens"] == 77
assert "max_tokens" not in body
@@ -179,7 +192,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(cerebras_prov
def test_build_request_body_preserves_caller_extra_body(cerebras_provider):
req = make_request(extra_body={"clear_thinking": False})
- body = cerebras_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = cerebras_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
eb = body.get("extra_body")
assert isinstance(eb, dict)
@@ -212,7 +227,11 @@ async def test_stream_response_text(cerebras_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(cerebras_provider.stream_response(req))
+ events = await collect_anthropic(
+ cerebras_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"text_delta"' in event and "Hello back!" in event for event in events
@@ -245,7 +264,11 @@ async def test_stream_response_reasoning(cerebras_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(cerebras_provider.stream_response(req))
+ events = await collect_anthropic(
+ cerebras_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"thinking_delta"' in event and "Thinking..." in event for event in events
diff --git a/tests/providers/test_chutes.py b/tests/providers/test_chutes.py
index 9d89497c..68e027f1 100644
--- a/tests/providers/test_chutes.py
+++ b/tests/providers/test_chutes.py
@@ -12,6 +12,7 @@ from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -65,7 +66,9 @@ def test_preserves_upstream_reasoning_default(
}
)
- body = chutes_provider._build_request_body(request, reasoning=reasoning)
+ body = chutes_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
assert "reasoning_effort" not in body
assert "reasoning" not in body
@@ -108,8 +111,9 @@ def test_does_not_replay_reasoning_but_preserves_tool_history(
)
body = chutes_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistant = body["messages"][1]
diff --git a/tests/providers/test_cline_pass.py b/tests/providers/test_cline_pass.py
index d07e9e90..1cb43dad 100644
--- a/tests/providers/test_cline_pass.py
+++ b/tests/providers/test_cline_pass.py
@@ -9,6 +9,7 @@ import httpx2
import pytest
from openai import AsyncOpenAI
+from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.provider_catalog import CLINE_DEFAULT_BASE
from free_claude_code.core.anthropic.models import MessagesRequest
@@ -17,11 +18,14 @@ from free_claude_code.core.anthropic.stream_contracts import (
text_content,
thinking_content,
)
+from free_claude_code.core.inference import ReplayAttachment
from free_claude_code.core.json_types import JsonObject, JsonValue
from free_claude_code.core.reasoning import ReasoningPolicy
+from free_claude_code.core.replay_envelope import decode_replay_envelope
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_DEFAULT,
REASONING_OFF,
@@ -178,12 +182,12 @@ def test_build_request_body_preserves_nested_model_images_tools_and_results(
}
],
tool_choice={"type": "tool", "name": "inspect_image"},
- extra_body={"provider_option": "must-not-pass-through"},
)
body = cline_pass_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.on(),
+ provider_model=(request).model,
)
assert body["model"] == "cline-pass/kimi-k3"
@@ -203,7 +207,7 @@ def test_build_request_body_preserves_nested_model_images_tools_and_results(
"type": "function",
"function": {
"name": "inspect_image",
- "arguments": '{"detail": "high"}',
+ "arguments": '{"detail":"high"}',
},
}
]
@@ -220,6 +224,19 @@ def test_build_request_body_preserves_nested_model_images_tools_and_results(
assert "extra_body" not in body
+def test_build_request_body_rejects_caller_extra_body(
+ cline_pass_provider: OpenAIChatProvider,
+) -> None:
+ request = _request(extra_body={"provider_option": "must-not-pass-through"})
+
+ with pytest.raises(InvalidRequestError, match="does not support caller extra_body"):
+ cline_pass_provider._build_request_body(
+ canonical_request(request),
+ reasoning=ReasoningPolicy.provider_default(),
+ provider_model=request.model,
+ )
+
+
@pytest.mark.parametrize(
"reasoning",
[REASONING_DEFAULT, REASONING_OFF, REASONING_ON],
@@ -229,8 +246,9 @@ def test_build_request_body_adds_no_undocumented_reasoning_control_or_default_ca
reasoning: ReasoningPolicy,
) -> None:
body = cline_pass_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=reasoning,
+ provider_model=(_request()).model,
)
assert "max_tokens" not in body
@@ -246,7 +264,7 @@ def test_build_request_body_adds_no_undocumented_reasoning_control_or_default_ca
assert field not in body
-def test_build_request_body_replays_only_opaque_reasoning_details(
+def test_build_request_body_omits_legacy_unscoped_reasoning_details(
cline_pass_provider: OpenAIChatProvider,
) -> None:
detail: JsonObject = {
@@ -272,15 +290,16 @@ def test_build_request_body_replays_only_opaque_reasoning_details(
)
body = cline_pass_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.on(),
+ provider_model=(request).model,
)
assistant = next(
message for message in body["messages"] if message["role"] == "assistant"
)
assert assistant["content"] == "I will inspect it."
- assert assistant["reasoning_details"] == [detail]
+ assert "reasoning_details" not in assistant
assert "reasoning" not in assistant
assert "reasoning_content" not in assistant
assert (
@@ -317,8 +336,9 @@ async def test_stream_uses_upstream_sse_and_preserves_reasoning_details(
event_text = "".join(
await collect_anthropic(
cline_pass_provider.stream_response(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(),
+ provider_model=(_request()).model,
)
)
)
@@ -337,7 +357,15 @@ async def test_stream_uses_upstream_sse_and_preserves_reasoning_details(
and event.data.get("content_block", {}).get("type") == "redacted_thinking"
]
assert len(redacted_blocks) == 1
- assert json.loads(redacted_blocks[0]["data"]) == detail
+ artifacts = decode_replay_envelope(
+ redacted_blocks[0]["data"],
+ attachment=ReplayAttachment.REASONING,
+ )
+ assert artifacts is not None
+ assert len(artifacts) == 1
+ assert isinstance(artifacts[0].payload, str)
+ assert json.loads(artifacts[0].payload) == detail
+ assert all(artifact.scope is not None for artifact in artifacts)
assert stream.closed
diff --git a/tests/providers/test_cloudflare.py b/tests/providers/test_cloudflare.py
index be2e5cf8..4734e52a 100644
--- a/tests/providers/test_cloudflare.py
+++ b/tests/providers/test_cloudflare.py
@@ -18,6 +18,7 @@ from free_claude_code.providers.cloudflare import (
cloudflare_ai_base_url,
)
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -128,7 +129,9 @@ def test_build_request_body_preserves_literal_cf_model_id_and_controls_thinking(
)
body = cloudflare_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "@cf/moonshotai/kimi-k2.6"
@@ -149,7 +152,9 @@ def test_build_request_body_disabled_thinking_sets_cloudflare_template_flag(
)
body = cloudflare_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["chat_template_kwargs"]["thinking"] is False
@@ -167,7 +172,9 @@ def test_build_request_body_preserves_user_extra_body_without_overriding_thinkin
)
body = cloudflare_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["chat_template_kwargs"]["thinking"] is False
@@ -226,7 +233,9 @@ async def test_stream_uses_openai_chat_completions(
return_value=_stream(_chunk(delta)),
) as mock_create:
events = await collect_anthropic(
- cloudflare_provider.stream_response(_request())
+ cloudflare_provider.stream_response(
+ canonical_request(_request()), provider_model=(_request()).model
+ )
)
parsed = parse_sse_text("".join(events))
@@ -257,7 +266,9 @@ async def test_stream_maps_cloudflare_reasoning_delta_to_thinking(
return_value=_stream(_chunk(delta)),
):
events = await collect_anthropic(
- cloudflare_provider.stream_response(_request())
+ cloudflare_provider.stream_response(
+ canonical_request(_request()), provider_model=(_request()).model
+ )
)
parsed = parse_sse_text("".join(events))
@@ -307,7 +318,11 @@ async def test_stream_maps_openai_tool_calls_to_tool_use(
new_callable=AsyncMock,
return_value=_stream(_chunk(delta, finish_reason="tool_calls")),
):
- events = await collect_anthropic(cloudflare_provider.stream_response(request))
+ events = await collect_anthropic(
+ cloudflare_provider.stream_response(
+ canonical_request(request), provider_model=(request).model
+ )
+ )
parsed = parse_sse_text("".join(events))
assert any(
diff --git a/tests/providers/test_codestral.py b/tests/providers/test_codestral.py
index f3fbe398..dc48a4da 100644
--- a/tests/providers/test_codestral.py
+++ b/tests/providers/test_codestral.py
@@ -6,7 +6,7 @@ import pytest
from free_claude_code.config.provider_catalog import CODESTRAL_DEFAULT_BASE
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -57,7 +57,9 @@ def test_default_base_url():
def test_build_request_body_basic(codestral_provider):
"""Basic request body conversion works for Codestral."""
req = make_request()
- body = codestral_provider._build_request_body(req)
+ body = codestral_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
assert body["model"] == "devstral-small-latest"
assert body["messages"][0]["role"] == "system"
@@ -76,7 +78,9 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():
admission=immediate_admission(),
)
req = make_request()
- body = provider._build_request_body(req)
+ body = provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
roles = [m.get("role") for m in body.get("messages", [])]
assert "assistant_reasoning_content" not in roles
@@ -108,7 +112,11 @@ async def test_stream_response_text(codestral_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(codestral_provider.stream_response(req))
+ events = await collect_anthropic(
+ codestral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"text_delta"' in event and "Hello back!" in event for event in events
@@ -141,7 +149,11 @@ async def test_stream_response_reasoning_content(codestral_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(codestral_provider.stream_response(req))
+ events = await collect_anthropic(
+ codestral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"thinking_delta"' in event and "Thinking..." in event for event in events
diff --git a/tests/providers/test_cohere.py b/tests/providers/test_cohere.py
index 978a46b3..80e553e6 100644
--- a/tests/providers/test_cohere.py
+++ b/tests/providers/test_cohere.py
@@ -8,7 +8,7 @@ import pytest
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.provider_catalog import COHERE_DEFAULT_BASE
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -82,7 +82,9 @@ def test_build_request_body_sanitizes_documented_unsupported_fields(cohere_provi
"parallel_tool_calls": True,
}
- body = cohere_provider._build_request_body(make_request())
+ body = cohere_provider._build_request_body(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
assert body["messages"][0].get("name") is None
assert body["max_tokens"] == 42
@@ -105,7 +107,9 @@ def test_build_request_body_sanitizes_documented_unsupported_fields(cohere_provi
def test_build_request_body_maps_reasoning_on_to_high(cohere_provider):
request = make_request()
body = cohere_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["reasoning_effort"] == "high"
@@ -128,7 +132,9 @@ def test_build_request_body_preserves_replayed_reasoning_content(cohere_provider
request = make_request()
body = cohere_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"] == [
@@ -154,7 +160,11 @@ def test_build_request_body_maps_reasoning_off_to_none():
)
request = make_request(thinking={"type": "disabled"})
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["reasoning_effort"] == "none"
@@ -169,7 +179,9 @@ def test_build_request_body_promotes_allowed_extra_body(cohere_provider):
}
)
- body = cohere_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = cohere_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert body["frequency_penalty"] == 0.1
assert body["presence_penalty"] == 0.2
@@ -182,7 +194,11 @@ def test_build_request_body_rejects_unsupported_extra_body(cohere_provider):
req = make_request(extra_body={"documents": [{"text": "x"}]})
with pytest.raises(InvalidRequestError, match="Unsupported"):
- cohere_provider._build_request_body(req, reasoning=reasoning_for(req))
+ cohere_provider._build_request_body(
+ canonical_request(req),
+ reasoning=reasoning_for(req),
+ provider_model=(req).model,
+ )
@pytest.mark.asyncio
@@ -209,7 +225,9 @@ async def test_stream_response_text(cohere_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- cohere_provider.stream_response(make_request())
+ cohere_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
@@ -244,7 +262,9 @@ async def test_stream_response_tool_call(cohere_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- cohere_provider.stream_response(make_request())
+ cohere_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
@@ -279,7 +299,9 @@ async def test_stream_response_reasoning_content(cohere_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- cohere_provider.stream_response(make_request())
+ cohere_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
diff --git a/tests/providers/test_converter.py b/tests/providers/test_converter.py
index b24f2c6f..10935045 100644
--- a/tests/providers/test_converter.py
+++ b/tests/providers/test_converter.py
@@ -1,270 +1,220 @@
-import json
+"""Contracts for canonical-to-OpenAI Chat request encoding."""
import pytest
-from free_claude_code.core.anthropic import (
- AnthropicToOpenAIConverter,
+from free_claude_code.application.errors import InvalidRequestError
+from free_claude_code.core.anthropic import messages_to_inference_request
+from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.inference import (
+ CacheControl,
+ CustomTool,
+ CustomToolFormat,
+ CustomToolFormatType,
+ DocumentContent,
+ FunctionTool,
+ InferenceRequest,
+ InstructionItem,
+ InstructionOrigin,
+ InstructionPlacement,
+ MessageItem,
+ MessageRole,
+ ReasoningItem,
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+ ReplayCompatibilityScope,
+ TextContent,
+ ToolCallItem,
+ ToolCallKind,
+ ToolChoice,
+ ToolChoiceMode,
+ ToolResultItem,
+ UrlMediaSource,
+)
+from free_claude_code.core.json_types import JsonValue
+from free_claude_code.core.reasoning import ReasoningPolicy
+from free_claude_code.providers.openai_chat import (
+ OpenAIChatRequestPolicy,
+ build_openai_chat_request_body,
+)
+from free_claude_code.providers.openai_chat.request_codec import (
OpenAIConversionError,
ReasoningReplayMode,
build_base_request_body,
is_synthetic_openai_tool_turn_boundary,
+ serialize_tool_result_content,
)
-from free_claude_code.core.anthropic.models import MessagesRequest
-
-# --- Mock Classes ---
-
-
-class MockMessage:
- def __init__(self, role, content, reasoning_content=None):
- self.role = role
- self.content = content
- self.reasoning_content = reasoning_content
-
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
-class MockBlock:
- def __init__(self, **kwargs):
- for k, v in kwargs.items():
- setattr(self, k, v)
- self._data = kwargs
- def get(self, key, default=None):
- return self._data.get(key, default)
-
-
-class MockTool:
- def __init__(self, name, description, input_schema=None):
- self.name = name
- self.description = description
- self.input_schema = input_schema
-
-
-# --- System Prompt Tests ---
-
-
-def test_convert_system_prompt_str():
- system = "You are a helpful assistant."
- result = AnthropicToOpenAIConverter.convert_system_prompt(system)
- assert result == {"role": "system", "content": system}
+def _canonical(**overrides: object) -> InferenceRequest:
+ payload: dict[str, object] = {
+ "model": "client-model",
+ "messages": [{"role": "user", "content": "Hello"}],
+ }
+ payload.update(overrides)
+ return messages_to_inference_request(MessagesRequest.model_validate(payload))
+
+
+def _body(
+ request: InferenceRequest,
+ *,
+ provider_model: str = "upstream-model",
+ replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
+ replay_scope: ReplayCompatibilityScope | None = None,
+ default_max_tokens: int | None = None,
+) -> dict[str, object]:
+ body: dict[str, object] = {}
+ body.update(
+ build_base_request_body(
+ request,
+ provider_model=provider_model,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=replay_scope,
+ default_max_tokens=default_max_tokens,
+ reasoning_replay=replay,
+ )
+ )
+ return body
-def test_convert_system_prompt_list_text():
- system = [
- MockBlock(type="text", text="Part 1"),
- MockBlock(type="text", text="Part 2"),
- ]
- result = AnthropicToOpenAIConverter.convert_system_prompt(system)
- assert result == {"role": "system", "content": "Part 1\n\nPart 2"}
+def _object(value: object) -> dict[str, object]:
+ assert isinstance(value, dict)
+ return value
-def test_convert_system_prompt_none():
- assert AnthropicToOpenAIConverter.convert_system_prompt(None) is None
+def _objects(value: object) -> list[dict[str, object]]:
+ assert isinstance(value, list)
+ assert all(isinstance(item, dict) for item in value)
+ return value
-def test_openai_build_uses_only_top_level_system_role() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "model",
- "system": "Conversation-wide instructions",
- "messages": [
- {"role": "user", "content": "First question"},
- {"role": "system", "content": "Instructions from this point"},
- {"role": "system", "content": "A second reminder"},
- {"role": "assistant", "content": "First answer"},
- {"role": "user", "content": "Second question"},
- {"role": "system", "content": "A final reminder"},
- ],
- }
+def test_top_level_and_inline_instructions_preserve_order() -> None:
+ request = _canonical(
+ system="Conversation-wide instructions",
+ messages=[
+ {"role": "user", "content": "First question"},
+ {"role": "system", "content": "Instructions from this point"},
+ {"role": "assistant", "content": "First answer"},
+ {"role": "user", "content": "Second question"},
+ ],
)
- body = build_base_request_body(request)
-
- assert body["messages"] == [
+ assert _body(request)["messages"] == [
{"role": "system", "content": "Conversation-wide instructions"},
{
"role": "user",
- "content": (
- "First question\n\nInstructions from this point\n\nA second reminder"
- ),
+ "content": "First question\n\nInstructions from this point",
},
{"role": "assistant", "content": "First answer"},
- {"role": "user", "content": "Second question\n\nA final reminder"},
+ {"role": "user", "content": "Second question"},
]
-def test_openai_build_demotes_inline_system_text_blocks_without_repositioning() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "model",
- "messages": [
- {"role": "user", "content": "Before"},
- {
- "role": "system",
- "content": [
- {"type": "text", "text": "First instruction"},
- {"type": "text", "text": "Second instruction"},
- ],
- },
- ],
- }
- )
+def test_provider_model_is_explicit_and_request_is_immutable() -> None:
+ request = _canonical(max_tokens=321, temperature=0.4, top_p=0.8)
- body = build_base_request_body(request)
+ body = _body(request, provider_model="provider/selected")
- assert body["messages"] == [
- {
- "role": "user",
- "content": "Before\n\nFirst instruction\n\nSecond instruction",
- }
- ]
+ assert body["model"] == "provider/selected"
+ assert body["max_tokens"] == 321
+ assert body["temperature"] == 0.4
+ assert body["top_p"] == 0.8
+ assert request.model == "client-model"
-def test_inline_system_message_preserves_existing_openai_cache_prefix() -> None:
- prefix_request = MessagesRequest.model_validate(
- {
- "model": "model",
- "system": "Conversation-wide instructions",
- "messages": [
- {"role": "user", "content": "First question"},
- {"role": "assistant", "content": "First answer"},
- ],
- }
+def test_default_output_cap_only_applies_when_client_omits_it() -> None:
+ assert (
+ _body(_canonical(max_tokens=None), default_max_tokens=777)["max_tokens"] == 777
)
- continued_request = MessagesRequest.model_validate(
- {
- "model": "model",
- "system": "Conversation-wide instructions",
- "messages": [
- {"role": "user", "content": "First question"},
- {"role": "assistant", "content": "First answer"},
- {"role": "user", "content": "Second question"},
- {
- "role": "system",
- "content": (
- "<system-reminder>Instructions from this point"
- "</system-reminder>"
- ),
- },
- ],
- }
+ assert (
+ _body(_canonical(max_tokens=123), default_max_tokens=777)["max_tokens"] == 123
)
- prefix = build_base_request_body(prefix_request)["messages"]
- continued = build_base_request_body(continued_request)["messages"]
- assert continued[: len(prefix)] == prefix
- assert continued[len(prefix) :] == [
- {
- "role": "user",
- "content": (
- "Second question\n\n<system-reminder>Instructions from this point"
- "</system-reminder>"
- ),
- }
- ]
+def test_chat_policy_must_explicitly_consume_or_reject_caller_extra_body() -> None:
+ request = _canonical(extra_body={"provider_option": True})
+ policy = OpenAIChatRequestPolicy(
+ provider_name="TEST",
+ reasoning_replay=ReasoningReplayMode.THINK_TAGS,
+ )
+ with pytest.raises(InvalidRequestError, match="does not support caller extra_body"):
+ build_openai_chat_request_body(
+ request,
+ provider_model="upstream-model",
+ reasoning=ReasoningPolicy.provider_default(),
+ policy=policy,
+ tool_names=OpenAIToolNameCodec.from_request(request),
+ replay_scope=None,
+ )
-def test_inline_system_message_coalesces_with_multimodal_user_content() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "model",
- "messages": [
- {"role": "user", "content": "Existing context."},
- {
- "role": "user",
- "content": [
- {
- "type": "image",
- "source": {
- "type": "url",
- "url": "https://example.com/image.png",
- },
+
+def test_user_text_and_image_parts_are_encoded_without_reordering() -> None:
+ request = _canonical(
+ messages=[
+ {
+ "role": "user",
+ "content": [
+ {"type": "text", "text": "Inspect"},
+ {
+ "type": "image",
+ "source": {
+ "type": "url",
+ "url": "https://example.invalid/image.png",
},
- {"type": "text", "text": "Inspect this image."},
- ],
- },
- {"role": "system", "content": "Focus on correctness."},
- ],
- }
+ },
+ {"type": "text", "text": "carefully"},
+ ],
+ }
+ ]
)
- body = build_base_request_body(request)
-
- assert body["messages"] == [
+ assert _body(request)["messages"] == [
{
"role": "user",
"content": [
- {"type": "text", "text": "Existing context."},
+ {"type": "text", "text": "Inspect"},
{
"type": "image_url",
- "image_url": {"url": "https://example.com/image.png"},
- },
- {
- "type": "text",
- "text": "Inspect this image.\n\nFocus on correctness.",
+ "image_url": {"url": "https://example.invalid/image.png"},
},
+ {"type": "text", "text": "carefully"},
],
}
]
-def test_inline_system_message_follows_completed_tool_result() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "model",
- "messages": [
- {"role": "user", "content": "Use the tool"},
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "call_1",
- "name": "Read",
- "input": {},
- }
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "call_1",
- "content": "done",
- }
- ],
- },
- {"role": "system", "content": "New instructions"},
- ],
- }
+def test_document_content_is_rejected_instead_of_dropped() -> None:
+ request = InferenceRequest(
+ model="client-model",
+ items=(
+ MessageItem(
+ "turn_0",
+ MessageRole.USER,
+ (DocumentContent(UrlMediaSource("https://example.invalid/a.pdf")),),
+ ),
+ ),
)
- body = build_base_request_body(request)
-
- assert [message["role"] for message in body["messages"]] == [
- "user",
- "assistant",
- "tool",
- "assistant",
- "user",
- ]
- assert body["messages"][3] == {"role": "assistant", "content": " "}
- assert body["messages"][-1]["content"] == "New instructions"
+ with pytest.raises(OpenAIConversionError, match="document content"):
+ _body(request)
-def test_openai_build_rejects_non_text_inline_system_blocks() -> None:
- request = MessagesRequest.model_validate(
+def test_assistant_media_is_rejected_at_ingress() -> None:
+ wire = MessagesRequest.model_validate(
{
- "model": "model",
+ "model": "client-model",
"messages": [
{
- "role": "system",
+ "role": "assistant",
"content": [
{
"type": "image",
"source": {
"type": "url",
- "url": "https://example.com/a.png",
+ "url": "https://example.invalid/image.png",
},
}
],
@@ -273,1475 +223,373 @@ def test_openai_build_rejects_non_text_inline_system_blocks() -> None:
}
)
- with pytest.raises(
- OpenAIConversionError,
- match="inline Anthropic system message content block 'image' without data loss",
- ):
- build_base_request_body(request)
+ with pytest.raises(ValueError, match="assistant images"):
+ messages_to_inference_request(wire)
-def test_openai_build_rejects_empty_inline_system_content() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "model",
- "messages": [{"role": "system", "content": []}],
- }
+ ("mode", "reasoning_field", "visible"),
+ [
+ (ReasoningReplayMode.THINK_TAGS, None, "<think>\nWork\n</think>\n\nDone"),
+ (ReasoningReplayMode.REASONING_CONTENT, "reasoning_content", "Done"),
+ (ReasoningReplayMode.REASONING, "reasoning", "Done"),
+ (ReasoningReplayMode.DISABLED, None, "Done"),
+ ],
+)
+def test_reasoning_replay_modes(
+ mode: ReasoningReplayMode,
+ reasoning_field: str | None,
+ visible: str,
+) -> None:
+ request = _canonical(
+ messages=[
+ {"role": "user", "content": "Solve"},
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "Work"},
+ {"type": "text", "text": "Done"},
+ ],
+ },
+ ]
)
- with pytest.raises(OpenAIConversionError, match="contain text"):
- build_base_request_body(request)
-
-
-# --- Tool Conversion Tests ---
+ assistant = _objects(_body(request, replay=mode)["messages"])[1]
+
+ assert assistant["content"] == visible
+ if reasoning_field is None:
+ assert "reasoning_content" not in assistant
+ assert "reasoning" not in assistant
+ else:
+ assert assistant[reasoning_field] == "Work"
+
+
+def test_reasoning_replay_artifacts_require_an_exact_route_scope() -> None:
+ matching = ReplayCompatibilityScope("route-a")
+ request = InferenceRequest(
+ model="client-model",
+ items=(
+ ReasoningItem(
+ turn_id="turn_0",
+ reasoning="Work",
+ artifacts=(
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,
+ kind=ReplayArtifactKind.REASONING_DETAILS,
+ attachment=ReplayAttachment.REASONING,
+ payload=[{"type": "reasoning.text", "text": "opaque"}],
+ scope=matching,
+ ),
+ ),
+ ),
+ MessageItem("turn_0", MessageRole.ASSISTANT, (TextContent("Done"),)),
+ ),
+ )
+ matched = _objects(_body(request, replay_scope=matching)["messages"])[0]
+ mismatched = _objects(
+ _body(
+ request,
+ replay_scope=ReplayCompatibilityScope("route-b"),
+ )["messages"]
+ )[0]
-def test_convert_tools():
- tools = [
- MockTool(
- "get_weather",
- "Get weather",
- {"type": "object", "properties": {"loc": {"type": "string"}}},
- ),
- MockTool("calculator", None, {"type": "object"}),
+ assert matched["reasoning_details"] == [
+ {"type": "reasoning.text", "text": "opaque"}
]
- result = AnthropicToOpenAIConverter.convert_tools(tools)
- assert len(result) == 2
-
- assert result[0]["type"] == "function"
- assert result[0]["function"]["name"] == "get_weather"
- assert result[0]["function"]["description"] == "Get weather"
- assert result[0]["function"]["parameters"] == {
- "type": "object",
- "properties": {"loc": {"type": "string"}},
- }
+ assert "reasoning_details" not in mismatched
- assert result[1]["function"]["name"] == "calculator"
- assert result[1]["function"]["description"] == "" # Check default empty string
+def test_function_tools_preserve_schema_strictness_and_choice() -> None:
+ request = _canonical(
+ tools=[
+ {
+ "name": "lookup",
+ "description": "Look up a value",
+ "input_schema": {
+ "type": "object",
+ "properties": {"value": {"type": "string"}},
+ },
+ "strict": True,
+ }
+ ],
+ tool_choice={"type": "tool", "name": "lookup"},
+ )
-def test_convert_tool_without_input_schema_uses_empty_object_schema():
- tools = [MockTool("web_search", None)]
-
- result = AnthropicToOpenAIConverter.convert_tools(tools)
+ body = _body(request)
- assert result == [
+ assert body["tools"] == [
{
"type": "function",
"function": {
- "name": "web_search",
- "description": "",
- "parameters": {"type": "object", "properties": {}},
+ "name": "lookup",
+ "description": "Look up a value",
+ "parameters": {
+ "type": "object",
+ "properties": {"value": {"type": "string"}},
+ },
+ "strict": True,
},
}
]
+ assert body["tool_choice"] == {
+ "type": "function",
+ "function": {"name": "lookup"},
+ }
@pytest.mark.parametrize(
- "tool_choice,expected",
+ ("mode", "expected"),
[
- (
- {"type": "tool", "name": "echo_smoke"},
- {"type": "function", "function": {"name": "echo_smoke"}},
- ),
- ({"type": "any"}, "required"),
- ({"type": "auto"}, "auto"),
- ({"type": "none"}, "none"),
- (
- {"type": "function", "function": {"name": "already_openai"}},
- {"type": "function", "function": {"name": "already_openai"}},
- ),
+ (ToolChoiceMode.AUTO, "auto"),
+ (ToolChoiceMode.NONE, "none"),
+ (ToolChoiceMode.REQUIRED, "required"),
],
)
-def test_convert_tool_choice(tool_choice, expected):
- result = AnthropicToOpenAIConverter.convert_tool_choice(tool_choice)
- assert result == expected
-
-
-def test_openai_build_materializes_auto_tool_choice_when_tools_are_declared():
- request = MessagesRequest.model_validate(
- {
- "model": "model",
- "messages": [{"role": "user", "content": "Use the echo tool."}],
- "tools": [
- {
- "name": "echo",
- "description": "Echo a value.",
- "input_schema": {
- "type": "object",
- "properties": {"value": {"type": "string"}},
- "required": ["value"],
- },
- }
- ],
- }
- )
-
- body = build_base_request_body(request)
-
- assert body["tool_choice"] == "auto"
-
-
-def test_openai_build_omits_tool_choice_when_tools_are_absent():
- request = MessagesRequest.model_validate(
- {
- "model": "model",
- "messages": [{"role": "user", "content": "Hello"}],
- }
+def test_nonspecific_tool_choice_modes(
+ mode: ToolChoiceMode,
+ expected: str,
+) -> None:
+ request = InferenceRequest(
+ model="client-model",
+ items=(MessageItem("turn_0", MessageRole.USER, (TextContent("Hi"),)),),
+ tools=(FunctionTool("lookup", None, {"type": "object"}),),
+ tool_choice=ToolChoice(mode),
+ )
+
+ assert _body(request)["tool_choice"] == expected
+
+
+def test_custom_and_namespaced_tools_share_a_reversible_name_map() -> None:
+ request = InferenceRequest(
+ model="client-model",
+ items=(MessageItem("turn_0", MessageRole.USER, (TextContent("Run"),)),),
+ tools=(
+ CustomTool(
+ name="shell",
+ description="Execute text",
+ format=CustomToolFormat(CustomToolFormatType.TEXT),
+ namespace="workspace",
+ ),
+ ),
+ tool_choice=ToolChoice(
+ ToolChoiceMode.SPECIFIC,
+ kind=ToolCallKind.CUSTOM,
+ name="shell",
+ namespace="workspace",
+ ),
+ )
+
+ codec = OpenAIToolNameCodec.from_request(request)
+ body = build_base_request_body(
+ request,
+ provider_model="upstream-model",
+ tool_names=codec,
+ replay_scope=None,
+ )
+ wire_tool = _objects(body["tools"])[0]
+ wire_function = _object(wire_tool["function"])
+ wire_name = wire_function["name"]
+ assert isinstance(wire_name, str)
+
+ choice = _object(body["tool_choice"])
+ assert _object(choice["function"])["name"] == wire_name
+ identity = codec.decode_identity(wire_name)
+ assert identity.kind is ToolCallKind.CUSTOM
+ assert identity.name == "shell"
+ assert identity.namespace == "workspace"
+
+
+def test_tool_history_keeps_calls_before_results_and_preserves_error_content() -> None:
+ request = InferenceRequest(
+ model="client-model",
+ items=(
+ MessageItem("turn_0", MessageRole.USER, (TextContent("Use it"),)),
+ ToolCallItem(
+ turn_id="turn_1",
+ call_id="call_1",
+ kind=ToolCallKind.FUNCTION,
+ name="lookup",
+ input={"value": "x"},
+ ),
+ ToolResultItem(
+ turn_id="turn_2",
+ call_id="call_1",
+ content={"error": "not found"},
+ is_error=True,
+ ),
+ MessageItem("turn_3", MessageRole.USER, (TextContent("Continue"),)),
+ ),
+ tools=(FunctionTool("lookup", None, {"type": "object"}),),
)
- body = build_base_request_body(request)
-
- assert "tools" not in body
- assert "tool_choice" not in body
-
-
-# --- Message Conversion Tests: User ---
-
-
-def test_convert_user_message_str():
- messages = [MockMessage("user", "Hello world")]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 1
- assert result[0] == {"role": "user", "content": "Hello world"}
+ messages = _objects(_body(request)["messages"])
-
-def test_convert_user_message_list_text():
- content = [
- MockBlock(type="text", text="Hello"),
- MockBlock(type="text", text="World"),
- ]
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 1
- assert result[0] == {"role": "user", "content": "Hello\nWorld"}
-
-
-def test_convert_user_message_tool_result_str():
- content = [
- MockBlock(type="tool_result", tool_use_id="tool_123", content="Result data")
+ assert [message["role"] for message in messages] == [
+ "user",
+ "assistant",
+ "tool",
+ "assistant",
+ "user",
]
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 1
- assert result[0] == {
+ assert _objects(messages[1]["tool_calls"])[0]["id"] == "call_1"
+ assert messages[2] == {
"role": "tool",
- "tool_call_id": "tool_123",
- "content": "Result data",
+ "tool_call_id": "call_1",
+ "content": '{"error": "not found"}',
}
-
-
-def test_convert_user_message_tool_result_list():
- # Tool result content as a list of text blocks
- tool_content = [
- {"type": "text", "text": "Line 1"},
- {"type": "text", "text": "Line 2"},
- ]
- content = [
- MockBlock(type="tool_result", tool_use_id="tool_456", content=tool_content)
- ]
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 1
- assert result[0]["role"] == "tool"
- assert result[0]["tool_call_id"] == "tool_456"
- assert result[0]["content"] == "Line 1\nLine 2"
-
-
-def test_convert_user_message_mixed_text_and_tool_result():
- # Note: Anthropic/OpenAI mapping usually separates these, but the converter handles lists
- # User text usually comes before tool results in a turn, or after.
- # The converter splits them into separate messages if they are different roles?
- # Let's check logic: _convert_user_message returns a list of dicts.
- content = [
- MockBlock(type="text", text="Here is the result:"),
- MockBlock(type="tool_result", tool_use_id="tool_789", content="42"),
- ]
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- # Order is preserved: user text first, then tool result.
- assert len(result) == 2
- assert result[0] == {"role": "user", "content": "Here is the result:"}
- assert result[1] == {"role": "tool", "tool_call_id": "tool_789", "content": "42"}
-
-
-# --- Message Conversion Tests: Assistant ---
-
-
-def test_convert_assistant_message_text_only():
- messages = [MockMessage("assistant", "I am ready.")]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 1
- assert result[0] == {"role": "assistant", "content": "I am ready."}
-
-
-def test_convert_assistant_message_blocks_text():
- content = [MockBlock(type="text", text="Part A")]
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert result[0] == {"role": "assistant", "content": "Part A"}
-
-
-def test_convert_assistant_message_thinking():
- content = [
- MockBlock(type="thinking", thinking="I need to calculate this."),
- MockBlock(type="text", text="The answer is 4."),
- ]
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert len(result) == 1
- # Expecting <think> tags
- expected_content = (
- "<think>\nI need to calculate this.\n</think>\n\nThe answer is 4."
- )
- assert result[0]["content"] == expected_content
- assert "reasoning_content" not in result[0]
-
-
-def test_convert_assistant_message_thinking_replays_reasoning_content():
- """Top-level reasoning replay avoids duplicating thinking into content."""
- content = [
- MockBlock(type="thinking", thinking="I need to calculate this."),
- MockBlock(type="text", text="The answer is 4."),
- ]
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
- )
-
- assert len(result) == 1
- assert result[0]["reasoning_content"] == "I need to calculate this."
- assert result[0]["content"] == "The answer is 4."
- assert "<think>" not in result[0]["content"]
-
-
-def test_convert_assistant_message_thinking_replays_reasoning():
- content = [
- MockBlock(type="thinking", thinking="I need to calculate this."),
- MockBlock(type="text", text="The answer is 4."),
- ]
- messages = [MockMessage("assistant", content)]
-
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING
- )
-
- assert result == [
- {
- "role": "assistant",
- "content": "The answer is 4.",
- "reasoning": "I need to calculate this.",
- }
- ]
-
-
-def test_convert_assistant_top_level_reasoning_content_is_preserved():
- messages = [
- MockMessage(
- "assistant",
- "The answer is 4.",
- reasoning_content="I need to calculate this.",
- )
- ]
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
- )
-
- assert result == [
- {
- "role": "assistant",
- "content": "The answer is 4.",
- "reasoning_content": "I need to calculate this.",
- }
- ]
-
-
-def test_convert_assistant_empty_top_level_reasoning_content_is_preserved():
- messages = [MockMessage("assistant", "The answer is 4.", reasoning_content="")]
-
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
- )
-
- assert result == [
- {
- "role": "assistant",
- "content": "The answer is 4.",
- "reasoning_content": "",
- }
- ]
-
-
-def test_convert_assistant_thinking_tool_use_replays_top_level_reasoning():
- content = [
- MockBlock(type="thinking", thinking="I should call the tool."),
- MockBlock(
- type="tool_use",
- id="call_reasoning",
- name="search",
- input={"query": "python"},
- ),
- ]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="call_reasoning",
- content="result",
- )
- ],
+ assert is_synthetic_openai_tool_turn_boundary(messages[3])
+
+
+def test_incomplete_tool_history_is_rejected() -> None:
+ request = InferenceRequest(
+ model="client-model",
+ items=(
+ ToolCallItem(
+ turn_id="turn_0",
+ call_id="missing",
+ kind=ToolCallKind.FUNCTION,
+ name="lookup",
+ input={},
+ ),
),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
- )
-
- assert len(result) == 2
- assert result[0]["content"] == ""
- assert result[0]["reasoning_content"] == "I should call the tool."
- assert "<think>" not in result[0]["content"]
- assert result[0]["tool_calls"][0]["id"] == "call_reasoning"
-
-
-def test_convert_assistant_tool_use_replays_ollama_reasoning_field():
- messages = [
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="Call the tool."),
- MockBlock(type="tool_use", id="call_1", name="Read", input={}),
- ],
+ tools=(FunctionTool("lookup", None, {"type": "object"}),),
+ )
+
+ with pytest.raises(OpenAIConversionError, match="missing tool results"):
+ _body(request)
+
+
+def test_tool_replay_artifacts_require_an_exact_route_scope() -> None:
+ matching = ReplayCompatibilityScope("route-a")
+ request = InferenceRequest(
+ model="client-model",
+ items=(
+ ToolCallItem(
+ turn_id="turn_0",
+ call_id="call_1",
+ kind=ToolCallKind.FUNCTION,
+ name="lookup",
+ input={},
+ artifacts=(
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.GOOGLE,
+ kind=ReplayArtifactKind.THOUGHT_SIGNATURE,
+ attachment=ReplayAttachment.TOOL_CALL,
+ payload="signature",
+ scope=matching,
+ ),
+ ),
+ ),
+ ToolResultItem("turn_1", "call_1", "done"),
+ ),
+ tools=(FunctionTool("lookup", None, {"type": "object"}),),
+ )
+
+ matched_message = _objects(_body(request, replay_scope=matching)["messages"])[0]
+ matched = _objects(matched_message["tool_calls"])[0]
+ mismatched_message = _objects(
+ _body(
+ request,
+ replay_scope=ReplayCompatibilityScope("route-b"),
+ )["messages"]
+ )[0]
+ mismatched = _objects(mismatched_message["tool_calls"])[0]
+
+ assert matched["extra_content"] == {"google": {"thought_signature": "signature"}}
+ assert "extra_content" not in mismatched
+
+
+def test_cache_control_is_preserved_only_at_supported_locations() -> None:
+ request = InferenceRequest(
+ model="client-model",
+ items=(
+ InstructionItem(
+ "System",
+ InstructionOrigin.SYSTEM,
+ InstructionPlacement.TOP_LEVEL,
+ cache_control=CacheControl(),
+ ),
+ MessageItem(
+ "turn_0",
+ MessageRole.USER,
+ (TextContent("Hello", cache_control=CacheControl()),),
+ ),
),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_1", content="done")],
+ tools=(
+ FunctionTool(
+ "lookup",
+ None,
+ {"type": "object"},
+ cache_control=CacheControl(),
+ ),
),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING
)
- assert result[0]["reasoning"] == "Call the tool."
- assert "reasoning_content" not in result[0]
- assert result[0]["tool_calls"][0]["id"] == "call_1"
+ body = _body(request)
+ messages = _objects(body["messages"])
+ first_content = _objects(messages[0]["content"])
+ second_content = _objects(messages[1]["content"])
+ tools = _objects(body["tools"])
+ assert first_content[0]["cache_control"] == {"type": "ephemeral"}
+ assert second_content[0]["cache_control"] == {"type": "ephemeral"}
+ assert tools[0]["cache_control"] == {"type": "ephemeral"}
-def test_convert_assistant_empty_thinking_replays_empty_reasoning_content():
- content = [
- MockBlock(type="thinking", thinking=""),
- MockBlock(type="text", text="The answer is 4."),
- ]
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
+def test_inline_instruction_after_tool_result_gets_a_synthetic_boundary() -> None:
+ request = _canonical(
+ messages=[
+ {"role": "user", "content": "Use it"},
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "tool_use",
+ "id": "call_1",
+ "name": "lookup",
+ "input": {},
+ }
+ ],
+ },
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "tool_result",
+ "tool_use_id": "call_1",
+ "content": "done",
+ }
+ ],
+ },
+ {"role": "system", "content": "New instructions"},
+ ],
+ tools=[{"name": "lookup", "input_schema": {"type": "object"}}],
)
- assert result == [
- {
- "role": "assistant",
- "content": "The answer is 4.",
- "reasoning_content": "",
- }
- ]
-
+ messages = _objects(_body(request)["messages"])
-def test_convert_assistant_tool_use_replays_empty_reasoning_content():
- content = [
- MockBlock(type="thinking", thinking=""),
- MockBlock(type="tool_use", id="call_empty", name="Read", input={}),
- ]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="call_empty",
- content="result",
- )
- ],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
- )
-
- assert result[0]["content"] == ""
- assert result[0]["reasoning_content"] == ""
- assert result[0]["tool_calls"][0]["id"] == "call_empty"
-
-
-def _convert_tool_turn(
- assistant_content: list[MockBlock],
- reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.REASONING_CONTENT,
-) -> list[dict]:
- tool_ids = [
- block.get("id")
- for block in assistant_content
- if block.get("type") == "tool_use"
- ]
- return AnthropicToOpenAIConverter.convert_messages(
- [
- MockMessage("assistant", assistant_content),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id=tool_id,
- content="result",
- )
- for tool_id in tool_ids
- ],
- ),
- ],
- reasoning_replay=reasoning_replay,
- )
-
-
-def test_convert_assistant_tool_use_without_thinking_replays_empty_reasoning_content():
- result = _convert_tool_turn(
- [MockBlock(type="tool_use", id="call_missing", name="Read", input={})]
- )
-
- assert result[0]["content"] == ""
- assert result[0]["reasoning_content"] == ""
- assert result[0]["tool_calls"][0]["id"] == "call_missing"
-
-
-def test_convert_parallel_tool_use_without_thinking_replays_one_empty_reasoning_field():
- result = _convert_tool_turn(
- [
- MockBlock(type="tool_use", id="call_1", name="Read", input={}),
- MockBlock(type="tool_use", id="call_2", name="Glob", input={}),
- ]
- )
-
- assert result[0]["reasoning_content"] == ""
- assert [tool_call["id"] for tool_call in result[0]["tool_calls"]] == [
- "call_1",
- "call_2",
- ]
-
-
-def test_convert_redacted_thinking_tool_use_replays_empty_reasoning_without_data():
- result = _convert_tool_turn(
- [
- MockBlock(type="redacted_thinking", data="opaque-secret"),
- MockBlock(type="tool_use", id="call_redacted", name="Read", input={}),
- ]
- )
-
- assert result[0]["reasoning_content"] == ""
- assert "opaque-secret" not in json.dumps(result)
-
-
-def test_convert_text_only_assistant_without_thinking_omits_reasoning_content():
- result = AnthropicToOpenAIConverter.convert_messages(
- [MockMessage("assistant", "Visible answer")],
- reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
- )
-
- assert result == [{"role": "assistant", "content": "Visible answer"}]
-
-
- "reasoning_replay",
- [
- ReasoningReplayMode.THINK_TAGS,
- ReasoningReplayMode.REASONING,
- ReasoningReplayMode.DISABLED,
- ],
-)
-def test_convert_tool_use_without_thinking_does_not_change_other_replay_modes(
- reasoning_replay: ReasoningReplayMode,
-) -> None:
- result = _convert_tool_turn(
- [MockBlock(type="tool_use", id="call_other", name="Read", input={})],
- reasoning_replay,
- )
-
- assert "reasoning_content" not in result[0]
-
-
-def test_convert_assistant_message_thinking_removed_when_disabled():
- content = [
- MockBlock(type="thinking", thinking="I need to calculate this."),
- MockBlock(type="text", text="The answer is 4."),
- ]
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(
- messages,
- reasoning_replay=ReasoningReplayMode.DISABLED,
- )
-
- assert len(result) == 1
- assert "reasoning_content" not in result[0]
- assert "<think>" not in result[0]["content"]
- assert result[0]["content"] == "The answer is 4."
-
-
-def test_convert_assistant_top_level_reasoning_stripped_when_disabled():
- messages = [
- MockMessage(
- "assistant",
- "The answer is 4.",
- reasoning_content="I need to calculate this.",
- )
- ]
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.DISABLED
- )
-
- assert result == [{"role": "assistant", "content": "The answer is 4."}]
-
-
-def test_convert_assistant_message_tool_use():
- content = [
- MockBlock(type="text", text="I will call the tool."),
- MockBlock(
- type="tool_use", id="call_1", name="search", input={"query": "python"}
- ),
- ]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_1", content="result")],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert len(result) == 2
- msg = result[0]
- assert msg["role"] == "assistant"
- assert "I will call the tool." in msg["content"]
- assert "tool_calls" in msg
- assert len(msg["tool_calls"]) == 1
- tc = msg["tool_calls"][0]
- assert tc["id"] == "call_1"
- assert tc["function"]["name"] == "search"
- assert json.loads(tc["function"]["arguments"]) == {"query": "python"}
-
-
-def test_convert_assistant_tool_use_preserves_extra_content():
- content = [
- MockBlock(
- type="tool_use",
- id="call_1",
- name="search",
- input={"query": "python"},
- extra_content={"google": {"thought_signature": "sig"}},
- ),
- ]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_1", content="result")],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert result[0]["tool_calls"][0]["extra_content"] == {
- "google": {"thought_signature": "sig"}
- }
-
-
-def test_convert_assistant_message_empty_content():
- # Verify that empty content becomes a single space (NIM requirement)
- # if no tool calls are present.
- content = []
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert result[0]["content"] == " "
-
-
-def test_convert_assistant_message_tool_use_no_text():
- # If tool usage exists, content can be empty string?
- # Logic: if not content_str and not tool_calls: content_str = " "
- # So if tool_calls exist, content_str can be empty string?
- # Actually code says: if not content_str and not tool_calls.
- # So if tool_calls is present, content_str remains "" (empty).
-
- content = [MockBlock(type="tool_use", id="call_2", name="test", input={})]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_2", content="result")],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert (
- result[0]["content"] == ""
- ) # Should be empty string, not space, because tools exist
- assert len(result[0]["tool_calls"]) == 1
-
-
-def test_convert_mixed_blocks_and_types_and_roles():
- # comprehensive flow
- messages = [
- MockMessage("user", "Start"),
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="Thinking..."),
- MockBlock(type="text", text="Here is a tool."),
- ],
- ),
- MockMessage(
- "assistant", [MockBlock(type="tool_use", id="t1", name="f", input={})]
- ),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="t1", content="result")],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert len(result) == 4
- assert result[0]["role"] == "user"
- assert "<think>" in result[1]["content"]
- assert result[2]["tool_calls"][0]["id"] == "t1"
-
-
-# --- Edge Cases ---
-
-
-def test_get_block_attr_defaults():
- # Test helper directly
- from free_claude_code.core.anthropic import get_block_attr
-
- assert get_block_attr({}, "missing", "default") == "default"
- assert get_block_attr(object(), "missing", "default") == "default"
-
-
-def test_input_not_dict():
- # Tool input might not be a dict (e.g. malformed or string)
- content = [MockBlock(type="tool_use", id="call_x", name="f", input="some_string")]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_x", content="result")],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- # The converter calls json.dumps(tool_input) if dict, else str(tool_input)
- # So it should be "some_string"
- assert result[0]["tool_calls"][0]["function"]["arguments"] == "some_string"
-
-
-# --- Parametrized Edge Case Tests ---
-
-
- "system_input,expected",
- [
- ("You are helpful.", {"role": "system", "content": "You are helpful."}),
- (
- [MockBlock(type="text", text="A"), MockBlock(type="text", text="B")],
- {"role": "system", "content": "A\n\nB"},
- ),
- (None, None),
- ("", {"role": "system", "content": ""}),
- ([], None),
- ],
- ids=["string", "list_text", "none", "empty_string", "empty_list"],
-)
-def test_convert_system_prompt_parametrized(system_input, expected):
- """Parametrized system prompt conversion covering edge cases."""
- result = AnthropicToOpenAIConverter.convert_system_prompt(system_input)
- assert result == expected
-
-
- "content,expected_content",
- [
- ("Hello world", "Hello world"),
- ("", ""),
- ([MockBlock(type="text", text="A"), MockBlock(type="text", text="B")], "A\nB"),
- ([MockBlock(type="text", text="")], ""),
- ],
- ids=["simple_string", "empty_string", "list_blocks", "empty_text_block"],
-)
-def test_convert_user_message_parametrized(content, expected_content):
- """Parametrized user message conversion."""
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) >= 1
- assert result[0]["content"] == expected_content
-
-
-def test_convert_assistant_message_unknown_block_type():
- """Unknown block types should be silently skipped."""
- content = [
- MockBlock(type="unknown_type", data="something"),
- MockBlock(type="text", text="visible"),
- ]
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 1
- assert "visible" in result[0]["content"]
-
-
-def test_convert_tool_use_none_input():
- """Tool use with None input should not crash."""
- content = [MockBlock(type="tool_use", id="call_n", name="test", input=None)]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_n", content="result")],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 2
- assert "tool_calls" in result[0]
-
-
-def test_convert_assistant_interleaved_order_preserved():
- """Interleaved thinking, text, tool_use should preserve thinking+text order in content.
-
- Bug: Current implementation collects all thinking, then all text, then tool_calls.
- Original order [thinking, text, thinking, tool_use] becomes [all thinking, all text, tool_calls],
- losing the interleaving. Content string should reflect original block order for thinking+text.
- Tool calls stay at end (API constraint).
- """
- content = [
- MockBlock(type="thinking", thinking="First thought."),
- MockBlock(type="text", text="Here is the answer."),
- MockBlock(type="thinking", thinking="Second thought."),
- MockBlock(type="tool_use", id="call_1", name="search", input={"q": "x"}),
- ]
- messages = [
- MockMessage("assistant", content),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_1", content="result")],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert len(result) == 2
- msg = result[0]
- # Expected: thinking1, text, thinking2 in that order within content; tool_calls at end
- expected_content = "<think>\nFirst thought.\n</think>\n\nHere is the answer.\n\n<think>\nSecond thought.\n</think>"
- assert msg["content"] == expected_content, (
- f"Interleaved order lost. Got: {msg['content']!r}"
- )
- assert len(msg["tool_calls"]) == 1
-
-
-def test_convert_user_message_text_before_tool_result_order():
- """User message with text then tool_result should preserve order: user text first, then tool.
-
- Bug: Current implementation emits tool_result immediately, then user text at end.
- Anthropic order is typically: user says something, then provides tool results.
- """
- content = [
- MockBlock(type="text", text="Please use this result:"),
- MockBlock(type="tool_result", tool_use_id="t1", content="42"),
- ]
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert len(result) == 2
- # Expected: user text first, then tool result
- assert result[0]["role"] == "user"
- assert result[0]["content"] == "Please use this result:"
- assert result[1]["role"] == "tool"
- assert result[1]["tool_call_id"] == "t1"
-
-
-def test_convert_multiple_tool_results():
- """Multiple tool results in a single user message."""
- content = [
- MockBlock(type="tool_result", tool_use_id="t1", content="Result 1"),
- MockBlock(type="tool_result", tool_use_id="t2", content="Result 2"),
- ]
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert len(result) == 2
- assert result[0]["tool_call_id"] == "t1"
- assert result[1]["tool_call_id"] == "t2"
-
-
-def test_convert_user_message_tool_result_dict_as_json():
- content = [
- MockBlock(
- type="tool_result",
- tool_use_id="t_dict",
- content={"ok": True, "count": 2},
- ),
- ]
- messages = [MockMessage("user", content)]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert result[0]["role"] == "tool"
- assert result[0]["content"] == '{"ok": true, "count": 2}'
-
-
-def test_assistant_redacted_thinking_omitted_from_openai_chat():
- """Opaque redacted_thinking is not materialized as content or reasoning_content."""
- content = [
- MockBlock(type="redacted_thinking", data="secret-opaque"),
- MockBlock(type="text", text="Visible."),
- ]
- messages = [MockMessage("assistant", content)]
- result = AnthropicToOpenAIConverter.convert_messages(
- messages, reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
- )
- assert result[0]["content"] == "Visible."
- assert "secret-opaque" not in result[0]["content"]
- assert "reasoning_content" not in result[0]
-
-
- "source,expected_url",
- [
- (
- {"type": "base64", "media_type": "image/png", "data": "AAAA"},
- "data:image/png;base64,AAAA",
- ),
- (
- {"type": "url", "url": "https://example.com/image.png"},
- "https://example.com/image.png",
- ),
- ],
-)
-def test_convert_user_message_image_sources(source, expected_url):
- messages = [MockMessage("user", [MockBlock(type="image", source=source)])]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert result == [
- {
- "role": "user",
- "content": [{"type": "image_url", "image_url": {"url": expected_url}}],
- }
- ]
-
-
-def test_convert_user_message_preserves_interleaved_image_text_order():
- messages = [
- MockMessage(
- "user",
- [
- MockBlock(
- type="image",
- source={
- "type": "base64",
- "media_type": "image/jpeg",
- "data": "FIRST",
- },
- ),
- MockBlock(type="text", text="Compare the first image with this one."),
- MockBlock(
- type="image",
- source={"type": "url", "url": "https://example.com/second.jpg"},
- ),
- MockBlock(type="text", text="Describe the differences."),
- ],
- )
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert result == [
- {
- "role": "user",
- "content": [
- {
- "type": "image_url",
- "image_url": {"url": "data:image/jpeg;base64,FIRST"},
- },
- {
- "type": "text",
- "text": "Compare the first image with this one.",
- },
- {
- "type": "image_url",
- "image_url": {"url": "https://example.com/second.jpg"},
- },
- {"type": "text", "text": "Describe the differences."},
- ],
- }
- ]
-
-
-def test_convert_user_image_before_tool_result_preserves_message_order():
- messages = [
- MockMessage(
- "user",
- [
- MockBlock(type="text", text="Inspect this."),
- MockBlock(
- type="image",
- source={"type": "url", "url": "https://example.com/image.png"},
- ),
- MockBlock(type="tool_result", tool_use_id="tool_1", content="done"),
- ],
- )
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert result == [
- {
- "role": "user",
- "content": [
- {"type": "text", "text": "Inspect this."},
- {
- "type": "image_url",
- "image_url": {"url": "https://example.com/image.png"},
- },
- ],
- },
- {"role": "tool", "tool_call_id": "tool_1", "content": "done"},
+ assert [message["role"] for message in messages] == [
+ "user",
+ "assistant",
+ "tool",
+ "assistant",
+ "user",
]
+ assert is_synthetic_openai_tool_turn_boundary(messages[3])
@pytest.mark.parametrize(
- "source,error",
+ ("content", "expected"),
[
+ (None, ""),
+ ("plain", "plain"),
+ ({"value": 1}, '{"value": 1}'),
(
- {"type": "base64", "media_type": "", "data": "AAAA"},
- "non-empty media_type",
- ),
- (
- {"type": "base64", "media_type": "image/png", "data": ""},
- "non-empty data",
- ),
- ({"type": "url", "url": ""}, "non-empty url"),
- ({"type": "file", "file_id": "file_1"}, "Unsupported image source type"),
- ({}, "Unsupported image source type"),
- ],
-)
-def test_convert_user_message_rejects_unconvertible_image_sources(source, error):
- messages = [MockMessage("user", [MockBlock(type="image", source=source)])]
-
- with pytest.raises(OpenAIConversionError, match=error):
- AnthropicToOpenAIConverter.convert_messages(messages)
-
-
-def test_convert_assistant_text_after_tool_use_requires_matching_tool_result():
- """Dangling post-tool assistant text cannot be replayed as valid OpenAI chat."""
- content = [
- MockBlock(type="tool_use", id="call_z", name="Read", input={}),
- MockBlock(type="text", text="After tool"),
- ]
- messages = [MockMessage("assistant", content)]
- with pytest.raises(OpenAIConversionError, match="missing tool_result"):
- AnthropicToOpenAIConverter.convert_messages(messages)
-
-
-def test_convert_assistant_text_after_tool_use_inserts_after_tool_results():
- messages = [
- MockMessage(
- "assistant",
- [
- MockBlock(type="tool_use", id="call_z", name="Read", input={}),
- MockBlock(type="text", text="Post-tool commentary"),
- ],
- ),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="call_z",
- content="file contents",
- )
- ],
- ),
- ]
- result = AnthropicToOpenAIConverter.convert_messages(messages)
- assert result[0]["role"] == "assistant" and "tool_calls" in result[0]
- assert result[1]["role"] == "tool" and result[1]["tool_call_id"] == "call_z"
- assert result[2] == {"role": "assistant", "content": "Post-tool commentary"}
-
-
-def _completed_single_tool_turn(*, user_text=None):
- result_blocks = [
- MockBlock(
- type="tool_result",
- tool_use_id="call_z",
- content="file contents",
- )
- ]
- if user_text is not None:
- result_blocks.append(MockBlock(type="text", text=user_text))
- return [
- MockMessage(
- "assistant",
- [MockBlock(type="tool_use", id="call_z", name="Read", input={})],
- ),
- MockMessage("user", result_blocks),
- ]
-
-
-def test_unrelated_user_text_before_tool_result_is_buffered_after_closed_tool_turn():
- messages = [
- MockMessage(
- "assistant",
- [MockBlock(type="tool_use", id="call_z", name="Read", input={})],
+ [{"type": "text", "text": "a"}, {"type": "text", "text": "b"}],
+ "a\nb",
),
- MockMessage("user", "Please also summarize it."),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="call_z",
- content="file contents",
- )
- ],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- "user",
- ]
- assert result[0]["tool_calls"][0]["id"] == "call_z"
- assert result[1]["tool_call_id"] == "call_z"
- assert result[2] == {"role": "assistant", "content": " "}
- assert result[3]["content"] == "Please also summarize it."
-
-
-def test_user_after_completed_tool_result_gets_neutral_assistant_boundary():
- messages = [
- MockMessage("user", "Read the file."),
- *_completed_single_tool_turn(),
- MockMessage("user", "Please summarize it."),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "user",
- "assistant",
- "tool",
- "assistant",
- "user",
- ]
- assert result[3] == {"role": "assistant", "content": " "}
- assert is_synthetic_openai_tool_turn_boundary(result[3])
- assert json.loads(json.dumps(result[3])) == {
- "role": "assistant",
- "content": " ",
- }
- assert result[4]["content"] == "Please summarize it."
-
-
-def test_user_text_beside_tool_result_follows_neutral_assistant_boundary():
- messages = _completed_single_tool_turn(user_text="Please summarize it.")
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- "user",
- ]
- assert result[2] == {"role": "assistant", "content": " "}
- assert result[3]["content"] == "Please summarize it."
-
-
-def test_multiple_tool_results_get_one_assistant_boundary_before_user():
- messages = [
- MockMessage(
- "assistant",
- [
- MockBlock(type="tool_use", id="call_a", name="ReadA", input={}),
- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),
- ],
- ),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="call_b",
- content="result b",
- ),
- MockBlock(
- type="tool_result",
- tool_use_id="call_a",
- content="result a",
- ),
- ],
- ),
- MockMessage("user", "Compare both results."),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "tool",
- "assistant",
- "user",
- ]
- assert [message["tool_call_id"] for message in result[1:3]] == [
- "call_a",
- "call_b",
- ]
- assert result[3] == {"role": "assistant", "content": " "}
- assert result[4]["content"] == "Compare both results."
-
-
-def test_terminal_tool_result_does_not_get_assistant_boundary():
- messages = _completed_single_tool_turn()
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == ["assistant", "tool"]
-
-
-def test_existing_assistant_completion_prevents_extra_tool_turn_boundary():
- messages = [
- *_completed_single_tool_turn(),
- MockMessage("assistant", "The file contains useful information."),
- MockMessage("user", "Please summarize it."),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- "user",
- ]
- assert result[2]["content"] == "The file contains useful information."
-
-
-def test_unrelated_assistant_text_before_tool_result_is_buffered_until_after_tool_result():
- messages = [
- MockMessage(
- "assistant",
- [MockBlock(type="tool_use", id="call_z", name="Read", input={})],
- ),
- MockMessage("assistant", "Waiting for the result."),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="call_z",
- content="file contents",
- )
- ],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- ]
- assert result[0]["tool_calls"][0]["id"] == "call_z"
- assert result[1]["tool_call_id"] == "call_z"
- assert result[2]["content"] == "Waiting for the result."
-
-
-def test_user_text_in_tool_result_message_is_replayed_after_tool_sequence():
- messages = [
- MockMessage(
- "assistant",
- [
- MockBlock(type="tool_use", id="call_z", name="Read", input={}),
- MockBlock(type="text", text="Post-tool commentary"),
- ],
- ),
- MockMessage(
- "user",
- [
- MockBlock(type="text", text="Use this result too."),
- MockBlock(
- type="tool_result",
- tool_use_id="call_z",
- content="file contents",
- ),
- ],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- "user",
- ]
- assert result[1]["tool_call_id"] == "call_z"
- assert result[2]["content"] == "Post-tool commentary"
- assert result[3]["content"] == "Use this result too."
-
-
-def test_nested_pending_tool_use_waits_for_its_own_tool_result_before_deferred_text():
- messages = [
- MockMessage(
- "assistant",
- [MockBlock(type="tool_use", id="call_a", name="ReadA", input={})],
- ),
- MockMessage(
- "assistant",
- [
- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),
- MockBlock(type="text", text="Post-call-b commentary"),
- ],
- ),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_a", content="result a")],
- ),
- MockMessage(
- "user",
- [MockBlock(type="tool_result", tool_use_id="call_b", content="result b")],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- "tool",
- "assistant",
- ]
- assert result[0]["tool_calls"][0]["id"] == "call_a"
- assert result[1]["tool_call_id"] == "call_a"
- assert result[2]["tool_calls"][0]["id"] == "call_b"
- assert result[3]["tool_call_id"] == "call_b"
- assert result[4]["content"] == "Post-call-b commentary"
-
-
-def test_nested_pending_uses_early_nested_tool_result_after_outer_result():
- messages = [
- MockMessage(
- "assistant",
- [MockBlock(type="tool_use", id="call_a", name="ReadA", input={})],
- ),
- MockMessage(
- "assistant",
- [
- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),
- MockBlock(type="text", text="Post-call-b commentary"),
- ],
- ),
- MockMessage(
- "user",
- [
- MockBlock(type="tool_result", tool_use_id="call_b", content="result b"),
- MockBlock(type="tool_result", tool_use_id="call_a", content="result a"),
- ],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- "tool",
- "assistant",
- ]
- assert result[0]["tool_calls"][0]["id"] == "call_a"
- assert result[1]["tool_call_id"] == "call_a"
- assert result[2]["tool_calls"][0]["id"] == "call_b"
- assert result[3]["tool_call_id"] == "call_b"
- assert result[4]["content"] == "Post-call-b commentary"
-
-
-def test_multi_tool_turn_waits_for_all_results_before_deferred_text():
- messages = [
- MockMessage(
- "assistant",
- [
- MockBlock(type="tool_use", id="call_a", name="ReadA", input={}),
- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),
- MockBlock(type="text", text="Both tools are done."),
- ],
- ),
- MockMessage(
- "user",
- [
- MockBlock(type="tool_result", tool_use_id="call_b", content="result b"),
- MockBlock(type="tool_result", tool_use_id="call_a", content="result a"),
- ],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "tool",
- "assistant",
- ]
- assert [message["tool_call_id"] for message in result[1:3]] == [
- "call_a",
- "call_b",
- ]
- assert result[3]["content"] == "Both tools are done."
-
-
-def test_nested_pending_buffers_user_text_until_all_prior_tool_sequences_complete():
- messages = [
- MockMessage(
- "assistant",
- [MockBlock(type="tool_use", id="call_a", name="ReadA", input={})],
- ),
- MockMessage(
- "assistant",
- [
- MockBlock(type="tool_use", id="call_b", name="ReadB", input={}),
- MockBlock(type="text", text="Post-call-b commentary"),
- ],
- ),
- MockMessage(
- "user",
- [
- MockBlock(type="text", text="Use both results."),
- MockBlock(
- type="tool_result",
- tool_use_id="call_a",
- content="result a",
- ),
- MockBlock(
- type="tool_result",
- tool_use_id="call_b",
- content="result b",
- ),
- ],
- ),
- ]
-
- result = AnthropicToOpenAIConverter.convert_messages(messages)
-
- assert [message["role"] for message in result] == [
- "assistant",
- "tool",
- "assistant",
- "tool",
- "assistant",
- "user",
- ]
- assert result[1]["tool_call_id"] == "call_a"
- assert result[3]["tool_call_id"] == "call_b"
- assert result[4]["content"] == "Post-call-b commentary"
- assert result[5]["content"] == "Use both results."
-
-
-def test_openai_build_accepts_declared_native_top_level_hints() -> None:
- """OpenAI conversion ignores known non-OpenAI hints (e.g. context_management) without 400."""
- req = MessagesRequest.model_validate(
- {
- "model": "m",
- "messages": [{"role": "user", "content": "h"}],
- "context_management": {"edits": []},
- "output_config": {"foo": 1},
- "mcp_servers": [{"type": "url", "url": "https://x.com"}],
- }
- )
- body = build_base_request_body(req, default_max_tokens=100)
- assert "context_management" not in body
- assert "output_config" not in body
- assert "mcp_servers" not in body
- assert body["model"] == "m"
-
-
-def test_openai_build_converts_validated_anthropic_image_block() -> None:
- request = MessagesRequest.model_validate(
- {
- "model": "vision-model",
- "messages": [
- {
- "role": "user",
- "content": [
- {
- "type": "image",
- "source": {
- "type": "base64",
- "media_type": "image/webp",
- "data": "AAAA",
- },
- },
- {"type": "text", "text": "What is shown?"},
- ],
- }
- ],
- }
- )
-
- body = build_base_request_body(request)
-
- assert body["messages"] == [
- {
- "role": "user",
- "content": [
- {
- "type": "image_url",
- "image_url": {"url": "data:image/webp;base64,AAAA"},
- },
- {"type": "text", "text": "What is shown?"},
- ],
- }
- ]
-
-
-def test_openai_build_rejects_unknown_top_level_extras() -> None:
- """Truly unknown keys must still be rejected (not dropped silently)."""
- req = MessagesRequest.model_validate(
- {
- "model": "m",
- "messages": [{"role": "user", "content": "h"}],
- "experimental_client_only_passthrough": True,
- }
- )
- with pytest.raises(OpenAIConversionError, match="top-level request fields"):
- build_base_request_body(req)
-
-
- "content",
- [
- [MockBlock(type="server_tool_use", id="1", name="web_search", input={})],
- [MockBlock(type="web_search_tool_result", tool_use_id="1", content=[])],
- [
- MockBlock(
- type="web_fetch_tool_result",
- tool_use_id="1",
- content={"type": "web_fetch_result", "url": "https://a.com/x"},
- )
- ],
],
)
-def test_convert_assistant_server_tool_blocks_raise(content) -> None:
- messages = [MockMessage("assistant", content)]
- with pytest.raises(OpenAIConversionError, match="server tool"):
- AnthropicToOpenAIConverter.convert_messages(messages)
+def test_tool_result_serialization(content: JsonValue, expected: str) -> None:
+ assert serialize_tool_result_content(content) == expected
diff --git a/tests/providers/test_deepinfra.py b/tests/providers/test_deepinfra.py
index b844e987..70ec0d3e 100644
--- a/tests/providers/test_deepinfra.py
+++ b/tests/providers/test_deepinfra.py
@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -119,8 +120,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images(
)
body = deepinfra_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "deepseek-ai/DeepSeek-V4-Flash"
@@ -154,7 +156,9 @@ def test_build_request_body_encodes_documented_reasoning_effort(
) -> None:
request = _request()
- body = deepinfra_provider._build_request_body(request, reasoning=reasoning)
+ body = deepinfra_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
assert body["extra_body"] == {"reasoning_effort": expected}
@@ -164,7 +168,11 @@ def test_build_request_body_preserves_extra_body_without_reasoning_override(
) -> None:
request = _request(extra_body={"service_tier": "priority"})
- body = deepinfra_provider._build_request_body(request, reasoning=REASONING_ON)
+ body = deepinfra_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
assert body["extra_body"] == {
"service_tier": "priority",
@@ -180,7 +188,11 @@ def test_build_request_body_rejects_caller_reasoning_override(
request = _request(extra_body={field: "caller-owned"})
with pytest.raises(InvalidRequestError, match="must not override reasoning"):
- deepinfra_provider._build_request_body(request, reasoning=REASONING_ON)
+ deepinfra_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
def test_build_request_body_replays_documented_reasoning_content(
@@ -204,8 +216,9 @@ def test_build_request_body_replays_documented_reasoning_content(
)
body = deepinfra_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
diff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.py
index 05f7e154..0e9b04e6 100644
--- a/tests/providers/test_deepseek.py
+++ b/tests/providers/test_deepseek.py
@@ -1,6 +1,6 @@
"""Tests for DeepSeek OpenAI-compatible Chat Completions provider."""
-import logging
+import json
from types import SimpleNamespace
from unittest.mock import AsyncMock, patch
@@ -9,6 +9,7 @@ import pytest
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
from free_claude_code.config.provider_catalog import DEEPSEEK_DEFAULT_BASE
+from free_claude_code.core.anthropic.ingress import AnthropicIngressError
from free_claude_code.core.anthropic.models import (
ContentBlockDocument,
ContentBlockImage,
@@ -19,6 +20,7 @@ from free_claude_code.core.anthropic.models import (
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.providers.deepseek import DeepSeekProvider
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -153,7 +155,9 @@ def test_build_request_body_openai_chat_shape(deepseek_provider):
system="S",
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "deepseek-v4-pro"
assert "stream" not in body
@@ -170,7 +174,9 @@ def test_build_request_body_default_max_tokens(deepseek_provider):
messages=[Message(role="user", content="x")],
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -184,7 +190,9 @@ def test_build_request_body_thinking_enabled(deepseek_provider):
}
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "enabled"}
@@ -206,7 +214,9 @@ def test_build_request_body_tool_list_keeps_thinking(deepseek_provider):
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "enabled"}
@@ -224,7 +234,9 @@ def test_build_request_body_tool_choice_keeps_thinking(deepseek_provider):
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "enabled"}
@@ -251,7 +263,9 @@ def test_build_request_body_forced_tool_choice_downgrades_to_auto(
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "enabled"}
@@ -275,7 +289,11 @@ def test_build_request_body_encodes_reasoning_off():
"thinking": {"type": "enabled", "budget_tokens": 1},
}
)
- body = provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["extra_body"]["thinking"] == {"type": "disabled"}
assert "stream_options" not in body
@@ -300,7 +318,9 @@ def test_non_tool_thinking_is_omitted_from_first_replay(deepseek_provider):
}
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][0] == {"role": "assistant", "content": "out"}
@@ -321,7 +341,9 @@ def test_strip_redacted_thinking_when_thinking_on(deepseek_provider):
}
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][0] == {"role": "assistant", "content": "out"}
@@ -368,7 +390,9 @@ def test_tool_history_with_replayable_thinking_preserves_thinking(deepseek_provi
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["reasoning_effort"] == "high"
@@ -378,7 +402,7 @@ def test_tool_history_with_replayable_thinking_preserves_thinking(deepseek_provi
assert assistant["content"] == ""
assert assistant["reasoning_content"] == "hidden"
assert assistant["tool_calls"][0]["function"]["name"] == "Read"
- assert assistant["tool_calls"][0]["function"]["arguments"] == '{"file_path": "x"}'
+ assert assistant["tool_calls"][0]["function"]["arguments"] == '{"file_path":"x"}'
assert body["messages"][1] == {
"role": "tool",
"tool_call_id": "t1",
@@ -419,7 +443,9 @@ def test_tool_history_with_unsigned_thinking_preserves_thinking(deepseek_provide
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "enabled"}
@@ -465,16 +491,16 @@ def test_tool_history_without_thinking_disables_thinking_and_hints(deepseek_prov
"context_management": {
"edits": [
{"type": "clear_thinking_20251015", "keep": "all"},
- {"type": "other_edit", "keep": "all"},
],
- "other": True,
},
- "output_config": {"effort": "high", "format": "text"},
+ "output_config": {"effort": "high"},
}
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "disabled"}
@@ -519,7 +545,9 @@ def test_tool_history_with_empty_thinking_preserves_reasoning_state(deepseek_pro
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "enabled"}
@@ -562,7 +590,9 @@ def test_tool_history_with_empty_top_level_reasoning_preserves_reasoning_state(
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["thinking"] == {"type": "enabled"}
@@ -594,7 +624,11 @@ def test_thinking_off_strips_thinking_history():
],
}
)
- body = provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert "reasoning_content" not in body["messages"][0]
assert "sec" not in str(body["messages"])
@@ -639,7 +673,11 @@ def test_thinking_off_still_replays_required_tool_reasoning():
}
)
- body = provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["extra_body"]["thinking"] == {"type": "disabled"}
assert body["messages"][0]["reasoning_content"] == "required"
@@ -675,14 +713,16 @@ def test_passthrough_tool_use_and_result(deepseek_provider):
}
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][0]["tool_calls"][0]["function"]["name"] == "n"
assert body["messages"][1]["role"] == "tool"
-def test_preflight_strips_user_image():
- """Image blocks are silently stripped (DeepSeek lacks vision); request must not fail."""
+def test_preflight_rejects_user_image_for_non_vision_model():
+ """Unsupported image input is rejected instead of being silently discarded."""
request = MessagesRequest(
model="m",
messages=[
@@ -710,12 +750,12 @@ def test_preflight_strips_user_image():
),
admission=immediate_admission(),
)
- # Should not raise; image is stripped.
- provider.preflight_stream(request, reasoning=REASONING_ON)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
- content = body["messages"][0]["content"]
- assert "attachment omitted" in content.lower()
- assert "image or document inputs" in content.lower()
+ with pytest.raises(InvalidRequestError, match="does not support image content"):
+ provider.preflight_stream(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=request.model,
+ )
def test_vision_model_forwards_user_image():
@@ -749,8 +789,16 @@ def test_vision_model_forwards_user_image():
admission=immediate_admission(),
)
# Must not raise on preflight (no InvalidRequestError for image blocks).
- provider.preflight_stream(request, reasoning=REASONING_ON)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
+ provider.preflight_stream(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
content = body["messages"][0]["content"]
assert isinstance(content, list)
image_parts = [
@@ -768,8 +816,8 @@ def test_vision_model_forwards_user_image():
assert text_parts[0]["text"] == "Describe this image"
-def test_vision_model_strips_user_document():
- """Vision models still omit documents; conversion has no document parts."""
+def test_vision_model_rejects_user_document():
+ """Unsupported document input is rejected instead of being silently discarded."""
request = MessagesRequest(
model="deepseek-v4-flash-vision-exp",
messages=[
@@ -797,66 +845,35 @@ def test_vision_model_strips_user_document():
),
admission=immediate_admission(),
)
- provider.preflight_stream(request, reasoning=REASONING_ON)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
- content = body["messages"][0]["content"]
- assert content
- if isinstance(content, str):
- lowered = content.lower()
- else:
- texts = [
- part.get("text", "")
- for part in content
- if isinstance(part, dict) and part.get("type") == "text"
- ]
- lowered = "\n".join(texts).lower()
- assert not any(
- isinstance(part, dict) and part.get("type") == "image_url"
- for part in content
+ with pytest.raises(InvalidRequestError, match="does not support document content"):
+ provider.preflight_stream(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=request.model,
)
- assert "attachment omitted" in lowered
- assert "image or document inputs" in lowered
-def test_preflight_rejects_mcp_servers():
+def test_ingress_rejects_mcp_servers_before_provider_preflight():
request = MessagesRequest(
model="m",
messages=[Message(role="user", content="x")],
mcp_servers=[{"type": "url", "url": "https://x"}],
)
- provider = DeepSeekProvider(
- make_provider_config(
- api_key="k",
- base_url=DEEPSEEK_DEFAULT_BASE,
- rate_limit=1,
- rate_window=1,
- ),
- admission=immediate_admission(),
- )
- with pytest.raises(InvalidRequestError, match="mcp_servers"):
- provider.preflight_stream(request)
+ with pytest.raises(AnthropicIngressError, match="mcp_servers"):
+ canonical_request(request)
-def test_preflight_rejects_listed_server_tools_in_tools_list():
+def test_ingress_rejects_server_tools_before_provider_preflight():
request = MessagesRequest(
model="m",
messages=[Message(role="user", content="x")],
tools=[Tool(name="web_search", type="web_search_20250305", input_schema={})],
)
- provider = DeepSeekProvider(
- make_provider_config(
- api_key="k",
- base_url=DEEPSEEK_DEFAULT_BASE,
- rate_limit=1,
- rate_window=1,
- ),
- admission=immediate_admission(),
- )
- with pytest.raises(InvalidRequestError, match="web_search"):
- provider.preflight_stream(request)
+ with pytest.raises(AnthropicIngressError, match="web_search"):
+ canonical_request(request)
-def test_preflight_rejects_server_tool_result_blocks():
+def test_ingress_rejects_server_tool_history_before_provider_preflight():
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -880,17 +897,8 @@ def test_preflight_rejects_server_tool_result_blocks():
],
}
)
- provider = DeepSeekProvider(
- make_provider_config(
- api_key="k",
- base_url=DEEPSEEK_DEFAULT_BASE,
- rate_limit=1,
- rate_window=1,
- ),
- admission=immediate_admission(),
- )
- with pytest.raises(InvalidRequestError, match=r"web_search_tool_result|server"):
- provider.preflight_stream(request)
+ with pytest.raises(AnthropicIngressError, match=r"web_search_tool_result|server"):
+ canonical_request(request)
def test_non_tool_top_level_reasoning_is_not_replayed(deepseek_provider):
@@ -905,7 +913,9 @@ def test_non_tool_top_level_reasoning_is_not_replayed(deepseek_provider):
],
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][0] == {"role": "assistant", "content": "hi"}
@@ -942,7 +952,9 @@ def test_tool_call_top_level_reasoning_is_replayed(deepseek_provider):
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][0]["reasoning_content"] == "required"
@@ -1020,7 +1032,9 @@ async def test_wire_messages_keep_prefix_across_tool_thinking_fallback(
}
)
return deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
first_wire = await capture_openai_chat_wire_body(build(prefix_messages))
@@ -1081,7 +1095,12 @@ async def test_stream_uses_chat_completions_and_maps_cache_usage(deepseek_provid
create = AsyncMock(return_value=fake_stream())
with patch.object(deepseek_provider._client.chat.completions, "create", create):
chunks = await collect_anthropic(
- deepseek_provider.stream_response(request, input_tokens=7, request_id="r1")
+ deepseek_provider.stream_response(
+ canonical_request(request),
+ input_tokens=7,
+ request_id="r1",
+ provider_model=(request).model,
+ )
)
create.assert_awaited_once()
@@ -1110,7 +1129,9 @@ def test_preserves_extra_body_for_openai_chat_request(deepseek_provider):
"extra_body": {"note": 1},
}
r = MessagesRequest.model_validate(raw)
- body = deepseek_provider._build_request_body(r, reasoning=reasoning_for(r))
+ body = deepseek_provider._build_request_body(
+ canonical_request(r), reasoning=reasoning_for(r), provider_model=(r).model
+ )
assert body["extra_body"] == {"note": 1}
@@ -1149,7 +1170,9 @@ def test_normalizes_tool_result_content_array_to_string(deepseek_provider):
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
tool_result = body["messages"][1]
@@ -1159,8 +1182,8 @@ def test_normalizes_tool_result_content_array_to_string(deepseek_provider):
assert "file2.txt" in tool_result["content"]
-def test_strips_document_blocks_for_deepseek(deepseek_provider):
- """Document blocks (e.g. PDFs from Claude Code) are stripped since DeepSeek can't process them."""
+def test_rejects_document_blocks_for_deepseek(deepseek_provider):
+ """DeepSeek rejects documents instead of forwarding a partial request."""
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -1184,19 +1207,16 @@ def test_strips_document_blocks_for_deepseek(deepseek_provider):
}
)
- body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
- )
-
- assert body["messages"][0] == {
- "role": "tool",
- "tool_call_id": "t1",
- "content": "PDF text extracted",
- }
+ with pytest.raises(InvalidRequestError, match="does not support document content"):
+ deepseek_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=request.model,
+ )
-def test_strips_image_blocks_for_deepseek(deepseek_provider):
- """Image blocks are stripped for DeepSeek since it doesn't support vision."""
+def test_rejects_image_blocks_for_deepseek(deepseek_provider):
+ """DeepSeek rejects unsupported images instead of forwarding a partial request."""
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -1219,11 +1239,12 @@ def test_strips_image_blocks_for_deepseek(deepseek_provider):
}
)
- body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
- )
-
- assert body["messages"][0] == {"role": "user", "content": "describe this"}
+ with pytest.raises(InvalidRequestError, match="does not support image content"):
+ deepseek_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=request.model,
+ )
def test_normalizes_tool_result_content_dict_to_string(deepseek_provider):
@@ -1258,7 +1279,9 @@ def test_normalizes_tool_result_content_dict_to_string(deepseek_provider):
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
tool_result = body["messages"][1]
@@ -1268,8 +1291,8 @@ def test_normalizes_tool_result_content_dict_to_string(deepseek_provider):
assert "success" in tool_result["content"]
-def test_strips_image_block_inside_tool_result(deepseek_provider):
- """Image blocks nested inside tool_result.content are stripped, not rejected."""
+def test_preserves_image_descriptor_inside_tool_result(deepseek_provider):
+ """Opaque tool output stays lossless even when it describes an image."""
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -1310,20 +1333,21 @@ def test_strips_image_block_inside_tool_result(deepseek_provider):
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
tool_result = body["messages"][1]
assert tool_result["role"] == "tool"
- # After stripping + string-normalization, no base64/image marker survives.
assert isinstance(tool_result["content"], str)
assert "screenshot saved" in tool_result["content"]
- assert "base64" not in tool_result["content"]
- assert "abc" not in tool_result["content"]
+ assert "base64" in tool_result["content"]
+ assert "abc" in tool_result["content"]
-def test_image_only_tool_result_replaced_with_placeholder(deepseek_provider):
- """A tool_result whose only inner block is an image becomes a placeholder string."""
+def test_image_only_tool_result_is_serialized_losslessly(deepseek_provider):
+ """An image descriptor returned by a tool remains opaque JSON output."""
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -1363,21 +1387,28 @@ def test_image_only_tool_result_replaced_with_placeholder(deepseek_provider):
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
tool_result = body["messages"][1]
assert tool_result["role"] == "tool"
assert isinstance(tool_result["content"], str)
- assert tool_result["content"] != ""
- assert "attachment omitted" in tool_result["content"].lower()
- assert "image or document inputs" in tool_result["content"].lower()
+ assert json.loads(tool_result["content"]) == {
+ "type": "image",
+ "source": {
+ "type": "base64",
+ "media_type": "image/png",
+ "data": "abc",
+ },
+ }
-def test_document_only_tool_result_replaced_with_generic_placeholder(
+def test_document_only_tool_result_is_serialized_losslessly(
deepseek_provider,
):
- """A document-only tool_result uses the generic attachment placeholder."""
+ """A document descriptor returned by a tool remains opaque JSON output."""
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -1416,19 +1447,22 @@ def test_document_only_tool_result_replaced_with_generic_placeholder(
)
body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
tool_result = body["messages"][1]
assert tool_result["role"] == "tool"
assert isinstance(tool_result["content"], str)
- assert "attachment omitted" in tool_result["content"].lower()
- assert "document inputs" in tool_result["content"].lower()
- assert "image omitted" not in tool_result["content"].lower()
+ assert json.loads(tool_result["content"]) == {
+ "type": "document",
+ "source": {"type": "file", "file_id": "file_pdf"},
+ }
-def test_image_only_message_replaced_with_placeholder(deepseek_provider):
- """A top-level image-only message remains non-empty after stripping."""
+def test_image_only_message_is_rejected(deepseek_provider):
+ """A top-level unsupported image cannot be silently discarded."""
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -1450,17 +1484,16 @@ def test_image_only_message_replaced_with_placeholder(deepseek_provider):
}
)
- body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
- )
-
- content = body["messages"][0]["content"]
- assert "attachment omitted" in content.lower()
- assert "image or document inputs" in content.lower()
+ with pytest.raises(InvalidRequestError, match="does not support image content"):
+ deepseek_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=request.model,
+ )
-def test_document_only_message_replaced_with_placeholder(deepseek_provider):
- """A top-level document-only message remains non-empty after stripping."""
+def test_document_only_message_is_rejected(deepseek_provider):
+ """A top-level unsupported document cannot be silently discarded."""
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -1478,90 +1511,9 @@ def test_document_only_message_replaced_with_placeholder(deepseek_provider):
}
)
- body = deepseek_provider._build_request_body(
- request, reasoning=reasoning_for(request)
- )
-
- content = body["messages"][0]["content"]
- assert "attachment omitted" in content.lower()
- assert "document inputs" in content.lower()
-
-
-def test_warns_when_stripping_attachment_blocks(deepseek_provider, caplog):
- """A warning is emitted when image/document blocks are dropped so users notice."""
- request = MessagesRequest.model_validate(
- {
- "model": "m",
- "messages": [
- {
- "role": "user",
- "content": [
- {"type": "text", "text": "look"},
- {
- "type": "image",
- "source": {
- "type": "base64",
- "media_type": "image/png",
- "data": "abc",
- },
- },
- ],
- },
- {
- "role": "assistant",
- "content": [
- {
- "type": "tool_use",
- "id": "t1",
- "name": "Screenshot",
- "input": {},
- }
- ],
- },
- {
- "role": "user",
- "content": [
- {
- "type": "tool_result",
- "tool_use_id": "t1",
- "content": [
- {
- "type": "image",
- "source": {
- "type": "base64",
- "media_type": "image/png",
- "data": "abc",
- },
- },
- ],
- }
- ],
- },
- ],
- }
- )
-
- with caplog.at_level(logging.WARNING):
- deepseek_provider._build_request_body(request, reasoning=reasoning_for(request))
-
- warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
- assert any("stripped unsupported attachment blocks" in r.message for r in warnings)
-
-
-def test_no_warning_when_no_attachments(deepseek_provider, caplog):
- """No warning is emitted on plain text-only requests."""
- request = MessagesRequest.model_validate(
- {
- "model": "m",
- "messages": [{"role": "user", "content": "hello"}],
- }
- )
-
- with caplog.at_level(logging.WARNING):
- deepseek_provider._build_request_body(request, reasoning=reasoning_for(request))
-
- assert not any(
- "stripped unsupported attachment blocks" in r.message
- for r in caplog.records
- if r.levelno == logging.WARNING
- )
+ with pytest.raises(InvalidRequestError, match="does not support document content"):
+ deepseek_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=request.model,
+ )
diff --git a/tests/providers/test_execution_failure_boundary.py b/tests/providers/test_execution_failure_boundary.py
index 6b14170d..b3f3ae76 100644
--- a/tests/providers/test_execution_failure_boundary.py
+++ b/tests/providers/test_execution_failure_boundary.py
@@ -19,7 +19,7 @@ from free_claude_code.providers.http import (
)
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -102,8 +102,9 @@ async def test_committed_provider_failure_closes_block_then_raises_canonical_val
pytest.raises(ExecutionFailure) as exc_info,
):
async for event in provider.stream_response(
- request,
+ canonical_request(request),
request_id="req_committed_failure",
+ provider_model=(request).model,
):
emitted.extend(presenter.present(event))
@@ -143,8 +144,9 @@ async def test_openai_stream_close_failure_cannot_mask_execution_failure() -> No
):
await collect_anthropic(
provider.stream_response(
- request,
+ canonical_request(request),
request_id="req_close_failure",
+ provider_model=(request).model,
)
)
@@ -280,8 +282,9 @@ async def test_completed_stream_close_failure_preserves_success_lifecycle(
):
emitted = await collect_anthropic(
provider.stream_response(
- request,
+ canonical_request(request),
request_id="req_successful_close_failure",
+ provider_model=(request).model,
)
)
@@ -355,7 +358,11 @@ async def test_closing_public_openai_stream_closes_raw_stream_once() -> None:
new_callable=AsyncMock,
return_value=raw_stream,
):
- stream = provider.stream_response(request, request_id="req_early_close")
+ stream = provider.stream_response(
+ canonical_request(request),
+ request_id="req_early_close",
+ provider_model=(request).model,
+ )
await anext(stream)
assert isinstance(stream, AsyncCloseable)
await stream.aclose()
diff --git a/tests/providers/test_featherless.py b/tests/providers/test_featherless.py
index 3cf21f6d..b9b1bfc1 100644
--- a/tests/providers/test_featherless.py
+++ b/tests/providers/test_featherless.py
@@ -15,6 +15,7 @@ from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -116,8 +117,9 @@ def test_build_request_body_preserves_shared_chat_contract(
)
body = featherless_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == _MODEL
@@ -143,8 +145,9 @@ def test_build_request_body_encodes_documented_thinking_control(
enabled: bool,
) -> None:
body = featherless_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=reasoning,
+ provider_model=(_request()).model,
)
assert body["extra_body"] == {"chat_template_kwargs": {"enable_thinking": enabled}}
@@ -154,8 +157,9 @@ def test_build_request_body_omits_thinking_control_for_provider_default(
featherless_provider: OpenAIChatProvider,
) -> None:
body = featherless_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(_request()).model,
)
assert "extra_body" not in body
@@ -172,7 +176,11 @@ def test_build_request_body_rejects_caller_reasoning_override(
request = _request(extra_body={field: "caller-owned"})
with pytest.raises(InvalidRequestError, match="must not override reasoning"):
- featherless_provider._build_request_body(request, reasoning=REASONING_ON)
+ featherless_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
def test_build_request_body_replays_reasoning_and_tool_history(
@@ -208,8 +216,9 @@ def test_build_request_body_replays_reasoning_and_tool_history(
)
body = featherless_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
@@ -222,7 +231,7 @@ def test_build_request_body_replays_reasoning_and_tool_history(
"type": "function",
"function": {
"name": "read_file",
- "arguments": '{"path": "example.py"}',
+ "arguments": '{"path":"example.py"}',
},
}
],
diff --git a/tests/providers/test_fireworks.py b/tests/providers/test_fireworks.py
index 1229e8db..25730fc2 100644
--- a/tests/providers/test_fireworks.py
+++ b/tests/providers/test_fireworks.py
@@ -9,6 +9,7 @@ from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKEN
from free_claude_code.config.provider_catalog import FIREWORKS_DEFAULT_BASE
from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -51,7 +52,9 @@ def test_build_request_body_openai_chat_shape(fireworks_provider):
)
body = fireworks_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "accounts/fireworks/models/glm-5p1"
@@ -69,7 +72,9 @@ def test_build_request_body_default_max_tokens(fireworks_provider):
)
body = fireworks_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -98,7 +103,11 @@ def test_replay_is_independent_of_current_turn_reasoning_control():
}
)
- body = provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["messages"][0]["reasoning_content"] == "hidden"
assert body["reasoning_effort"] == "none"
@@ -114,7 +123,9 @@ def test_build_request_body_preserves_validated_extra_body(fireworks_provider):
)
body = fireworks_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"] == {"custom_param": "value"}
@@ -131,7 +142,9 @@ def test_build_request_body_rejects_reserved_extra_body_keys(fireworks_provider)
with pytest.raises(InvalidRequestError, match="extra_body must not override"):
fireworks_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
diff --git a/tests/providers/test_gemini.py b/tests/providers/test_gemini.py
index 0612cddf..42a1bc17 100644
--- a/tests/providers/test_gemini.py
+++ b/tests/providers/test_gemini.py
@@ -6,13 +6,16 @@ import pytest
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.provider_catalog import GEMINI_DEFAULT_BASE
+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
+from free_claude_code.core.inference import ReplayArtifactKind, ReplayAttachment
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
+from free_claude_code.core.replay_envelope import decode_replay_envelope
from free_claude_code.providers.gemini import GeminiProvider
from free_claude_code.providers.google_openai import (
GOOGLE_SKIP_THOUGHT_SIGNATURE_VALIDATOR,
)
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -81,7 +84,9 @@ def test_default_base_url_constant():
def test_build_request_body_basic(gemini_provider):
"""Basic body conversion attaches Gemini thinking fields when thinking is on."""
req = make_request()
- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = gemini_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert body["model"] == "models/gemini-3.1-flash-lite"
assert body["messages"][0]["role"] == "system"
@@ -102,7 +107,9 @@ def test_build_request_body_sdk_wire_json_has_literal_extra_body(gemini_provider
"""Regression for issue #542: SDK merge must not send top-level google."""
req = make_request()
- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = gemini_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
wire_json = _simulate_openai_sdk_wire_json(body)
assert "reasoning_effort" not in wire_json
@@ -128,7 +135,9 @@ def test_build_request_body_reasoning_off_sets_reasoning_none():
admission=immediate_admission(),
)
req = make_request(thinking={"type": "disabled"})
- body = provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert body["reasoning_effort"] == "none"
roles = [m.get("role") for m in body.get("messages", [])]
@@ -168,8 +177,9 @@ def test_gemini_reasoning_uses_exactly_one_wire_channel(
expected_thinking_config: dict | None,
) -> None:
body = gemini_provider._build_request_body(
- make_request(thinking=None),
+ canonical_request(make_request(thinking=None)),
reasoning=reasoning,
+ provider_model=(make_request(thinking=None)).model,
)
wire = _simulate_openai_sdk_wire_json(body)
@@ -190,8 +200,9 @@ def test_gemini_adaptive_thinking_with_effort_does_not_emit_custom_config(
)
body = gemini_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
wire = _simulate_openai_sdk_wire_json(body)
@@ -202,7 +213,9 @@ def test_gemini_adaptive_thinking_with_effort_does_not_emit_custom_config(
def test_build_request_body_preserves_caller_extra_body(gemini_provider):
req = make_request(extra_body={"metadata": {"user": "u1"}})
- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = gemini_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert "reasoning_effort" not in body
eb = body.get("extra_body")
@@ -231,7 +244,9 @@ def test_build_request_body_merges_caller_nested_google(gemini_provider):
},
)
- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = gemini_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert "reasoning_effort" not in body
eb = body.get("extra_body")
@@ -262,8 +277,9 @@ def test_gemini_rejects_caller_thinking_config_with_fcc_reasoning_control(
with pytest.raises(InvalidRequestError, match="thinking_config"):
gemini_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(request).model,
)
@@ -277,12 +293,15 @@ def test_gemini_rejects_malformed_google_extension_container(
with pytest.raises(InvalidRequestError, match="thinking_config must be an object"):
gemini_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(request).model,
)
-def test_build_request_body_preserves_tool_call_extra_content(gemini_provider):
+def test_build_request_body_does_not_replay_unscoped_tool_extra_content(
+ gemini_provider,
+):
req = make_request(
system=None,
messages=[
@@ -314,11 +333,15 @@ def test_build_request_body_preserves_tool_call_extra_content(gemini_provider):
],
)
- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = gemini_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
tool_call = body["messages"][1]["tool_calls"][0]
assert tool_call["extra_content"] == {
- "google": {"thought_signature": "sig-from-client"}
+ "google": {
+ "thought_signature": GOOGLE_SKIP_THOUGHT_SIGNATURE_VALIDATOR,
+ }
}
@@ -354,7 +377,9 @@ def test_build_request_body_uses_cached_tool_call_signature(gemini_provider):
],
)
- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = gemini_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
tool_call = body["messages"][1]["tool_calls"][0]
assert tool_call["extra_content"] == {
@@ -404,7 +429,9 @@ def test_build_request_body_adds_current_turn_fallback_signature(
],
)
- body = gemini_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = gemini_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
tool_calls = body["messages"][1]["tool_calls"]
assert tool_calls[0]["extra_content"] == {
@@ -439,7 +466,11 @@ async def test_stream_response_text(gemini_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- gemini_provider.stream_response(req, reasoning=reasoning_for(req))
+ gemini_provider.stream_response(
+ canonical_request(req),
+ reasoning=reasoning_for(req),
+ provider_model=(req).model,
+ )
)
assert any(
@@ -491,16 +522,32 @@ async def test_stream_response_preserves_tool_call_extra_content(gemini_provider
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(gemini_provider.stream_response(req))
+ events = await collect_anthropic(
+ gemini_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
tool_starts = [
event
- for event in events
- if '"content_block_start"' in event and '"tool_use"' in event
+ for event in parse_sse_text("".join(events))
+ if event.event == "content_block_start"
+ and event.data.get("content_block", {}).get("type") == "tool_use"
]
- assert any(
- '"extra_content"' in event and "sig-stream" in event for event in tool_starts
+ assert len(tool_starts) == 1
+ extra_content = tool_starts[0].data["content_block"]["extra_content"]
+ assert isinstance(extra_content, dict)
+ carrier = extra_content.get("fcc_replay")
+ assert isinstance(carrier, str)
+ artifacts = decode_replay_envelope(
+ carrier,
+ attachment=ReplayAttachment.TOOL_CALL,
)
+ assert artifacts is not None
+ assert len(artifacts) == 1
+ assert artifacts[0].kind is ReplayArtifactKind.THOUGHT_SIGNATURE
+ assert artifacts[0].payload == "sig-stream"
+ assert artifacts[0].scope is not None
assert gemini_provider._tool_call_extra_content_by_id["function-call-1"] == {
"google": {"thought_signature": "sig-stream"}
}
@@ -531,7 +578,11 @@ async def test_stream_response_reasoning_content(gemini_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(gemini_provider.stream_response(req))
+ events = await collect_anthropic(
+ gemini_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"thinking_delta"' in event and "Thinking..." in event for event in events
diff --git a/tests/providers/test_github_models.py b/tests/providers/test_github_models.py
index a1a6ec29..f7b5a55c 100644
--- a/tests/providers/test_github_models.py
+++ b/tests/providers/test_github_models.py
@@ -17,6 +17,7 @@ from free_claude_code.providers.github_models import GitHubModelsProvider
from free_claude_code.providers.github_models.client import GITHUB_MODELS_CATALOG_URL
from free_claude_code.providers.model_listing import ModelListResponseError
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_ON,
immediate_admission,
@@ -121,7 +122,11 @@ def test_build_request_body_uses_shared_openai_chat_policy(
) -> None:
request = _request()
- body = github_models_provider._build_request_body(request, reasoning=REASONING_ON)
+ body = github_models_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
assert body["model"] == "openai/gpt-4.1"
assert body["max_tokens"] == 100
@@ -218,7 +223,9 @@ async def test_stream_response_text(
return_value=_stream(_chunk(delta)),
) as mock_create:
events = await collect_anthropic(
- github_models_provider.stream_response(_request())
+ github_models_provider.stream_response(
+ canonical_request(_request()), provider_model=(_request()).model
+ )
)
parsed = parse_sse_text("".join(events))
@@ -268,7 +275,9 @@ async def test_stream_response_tool_call(
return_value=_stream(_chunk(delta, finish_reason="tool_calls")),
):
events = await collect_anthropic(
- github_models_provider.stream_response(request)
+ github_models_provider.stream_response(
+ canonical_request(request), provider_model=(request).model
+ )
)
parsed = parse_sse_text("".join(events))
@@ -302,7 +311,9 @@ async def test_stream_response_reasoning_content(
return_value=_stream(_chunk(delta)),
):
events = await collect_anthropic(
- github_models_provider.stream_response(_request())
+ github_models_provider.stream_response(
+ canonical_request(_request()), provider_model=(_request()).model
+ )
)
parsed = parse_sse_text("".join(events))
diff --git a/tests/providers/test_groq.py b/tests/providers/test_groq.py
index 984a9e6d..cf99cee9 100644
--- a/tests/providers/test_groq.py
+++ b/tests/providers/test_groq.py
@@ -7,7 +7,7 @@ import pytest
from free_claude_code.config.provider_catalog import GROQ_DEFAULT_BASE
from free_claude_code.providers.groq import GroqProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -51,7 +51,9 @@ def test_default_base_url_constant():
def test_build_request_body_basic(groq_provider):
"""Basic request body conversion attaches system message from Claude request."""
req = make_request()
- body = groq_provider._build_request_body(req)
+ body = groq_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
assert body["model"] == "llama-3.3-70b-versatile"
assert body["messages"][0]["role"] == "system"
@@ -88,7 +90,9 @@ def test_build_request_body_replays_reasoning_as_tagged_content(groq_provider):
]
)
- body = groq_provider._build_request_body(request)
+ body = groq_provider._build_request_body(
+ canonical_request(request), provider_model=(request).model
+ )
assistant = next(
message for message in body["messages"] if message["role"] == "assistant"
@@ -119,7 +123,9 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():
admission=immediate_admission(),
)
req = make_request()
- body = provider._build_request_body(req)
+ body = provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
roles = [m.get("role") for m in body.get("messages", [])]
assert "assistant_reasoning_content" not in roles
@@ -147,7 +153,9 @@ def test_build_request_body_sanitizes_and_remaps_via_mock_converter(groq_provide
"n": 4,
}
req = make_request()
- body = groq_provider._build_request_body(req)
+ body = groq_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
msgs = body["messages"]
assert msgs[0].get("name") is None and msgs[1].get("name") is None
@@ -168,7 +176,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(groq_provider
"max_completion_tokens": 77,
"max_tokens": 999,
}
- body = groq_provider._build_request_body(make_request())
+ body = groq_provider._build_request_body(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
assert body["max_completion_tokens"] == 77
assert "max_tokens" not in body
@@ -177,7 +187,9 @@ def test_build_request_body_prefers_existing_max_completion_tokens(groq_provider
def test_build_request_body_preserves_caller_extra_body(groq_provider):
req = make_request(extra_body={"metadata": {"user": "u1"}})
- body = groq_provider._build_request_body(req)
+ body = groq_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
eb = body.get("extra_body")
assert isinstance(eb, dict)
@@ -210,7 +222,11 @@ async def test_stream_response_text(groq_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(groq_provider.stream_response(req))
+ events = await collect_anthropic(
+ groq_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"text_delta"' in event and "Hello back!" in event for event in events
@@ -243,7 +259,11 @@ async def test_stream_response_reasoning_content(groq_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(groq_provider.stream_response(req))
+ events = await collect_anthropic(
+ groq_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"thinking_delta"' in event and "Thinking..." in event for event in events
diff --git a/tests/providers/test_groq_reasoning.py b/tests/providers/test_groq_reasoning.py
index f369dbf3..87eff033 100644
--- a/tests/providers/test_groq_reasoning.py
+++ b/tests/providers/test_groq_reasoning.py
@@ -18,7 +18,7 @@ from free_claude_code.providers.groq.client import (
_rewrite_reasoning_effort,
)
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
capture_openai_chat_wire_body,
immediate_admission,
@@ -332,7 +332,11 @@ async def test_initial_reasoning_policy_reaches_sdk_wire(
policy: ReasoningPolicy,
expected: str | None,
) -> None:
- body = _provider()._build_request_body(_request(), reasoning=policy)
+ body = _provider()._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ )
wire = await capture_openai_chat_wire_body(body)
@@ -343,7 +347,11 @@ async def test_initial_reasoning_policy_reaches_sdk_wire(
async def test_exact_issue_retries_with_default_and_learns_model() -> None:
provider = _provider()
policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)
- body = provider._build_request_body(_request(), reasoning=policy)
+ body = provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ )
create = AsyncMock(side_effect=[_vocabulary_error(), object()])
with patch.object(provider._client.chat.completions, "create", create):
@@ -362,7 +370,11 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:
_MODEL: frozenset({"none", "default"})
}
- next_body = provider._build_request_body(_request(), reasoning=policy)
+ next_body = provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ )
assert next_body["reasoning_effort"] == "default"
next_create = AsyncMock(return_value=object())
with patch.object(provider._client.chat.completions, "create", next_create):
@@ -380,7 +392,11 @@ def test_cached_none_default_preserves_off() -> None:
provider = _provider()
provider._model_reasoning_vocabularies[_MODEL] = frozenset({"none", "default"})
- body = provider._build_request_body(_request(), reasoning=ReasoningPolicy.off())
+ body = provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=ReasoningPolicy.off(),
+ provider_model=(_request()).model,
+ )
assert body["reasoning_effort"] == "none"
@@ -403,8 +419,9 @@ def test_cached_named_vocabulary_preserves_enabled_efforts(
)
body = provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(effort=effort),
+ provider_model=(_request()).model,
)
assert body["reasoning_effort"] == expected
@@ -416,7 +433,11 @@ def test_cached_named_vocabulary_omits_unrepresentable_off() -> None:
{"low", "medium", "high"}
)
- body = provider._build_request_body(_request(), reasoning=ReasoningPolicy.off())
+ body = provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=ReasoningPolicy.off(),
+ provider_model=(_request()).model,
+ )
assert "reasoning_effort" not in body
@@ -425,8 +446,9 @@ def test_cached_named_vocabulary_omits_unrepresentable_off() -> None:
async def test_unknown_vocabulary_retries_without_effort_and_negative_caches() -> None:
provider = _provider()
body = provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(_request()).model,
)
create = AsyncMock(
side_effect=[
@@ -447,8 +469,9 @@ async def test_unknown_vocabulary_retries_without_effort_and_negative_caches() -
assert "reasoning_effort" not in used_body
assert provider._model_reasoning_vocabularies[_MODEL] == frozenset()
assert "reasoning_effort" not in provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(_request()).model,
)
@@ -457,9 +480,15 @@ def test_reasoning_cache_isolated_by_opaque_model_id() -> None:
policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)
provider._model_reasoning_vocabularies[_MODEL] = frozenset({"none", "default"})
- learned = provider._build_request_body(_request(_MODEL), reasoning=policy)
+ learned = provider._build_request_body(
+ canonical_request(_request(_MODEL)),
+ reasoning=policy,
+ provider_model=(_request(_MODEL)).model,
+ )
unlearned = provider._build_request_body(
- _request("opaque-model-b"), reasoning=policy
+ canonical_request(_request("opaque-model-b")),
+ reasoning=policy,
+ provider_model=(_request("opaque-model-b")).model,
)
assert learned["reasoning_effort"] == "default"
@@ -471,8 +500,16 @@ async def test_concurrent_first_requests_can_learn_without_state_corruption() ->
provider = _provider()
policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)
bodies = [
- provider._build_request_body(_request(), reasoning=policy),
- provider._build_request_body(_request(), reasoning=policy),
+ provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ ),
+ provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ ),
]
initial_calls = 0
release_initial_errors = asyncio.Event()
@@ -517,7 +554,11 @@ async def test_stale_cache_self_heals_without_guessing_original_effort() -> None
provider = _provider()
policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)
provider._model_reasoning_vocabularies[_MODEL] = frozenset({"none", "default"})
- cached_body = provider._build_request_body(_request(), reasoning=policy)
+ cached_body = provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ )
assert cached_body["reasoning_effort"] == "default"
create = AsyncMock(
side_effect=[
@@ -538,7 +579,11 @@ async def test_stale_cache_self_heals_without_guessing_original_effort() -> None
assert provider._model_reasoning_vocabularies[_MODEL] == frozenset(
{"low", "medium", "high"}
)
- rebuilt = provider._build_request_body(_request(), reasoning=policy)
+ rebuilt = provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ )
assert rebuilt["reasoning_effort"] == "high"
@@ -546,8 +591,9 @@ async def test_stale_cache_self_heals_without_guessing_original_effort() -> None
async def test_unrelated_400_propagates_without_cache_poisoning() -> None:
provider = _provider()
body = provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(_request()).model,
)
create = AsyncMock(side_effect=_BadRequest("messages: invalid role 'wizard'"))
@@ -569,8 +615,9 @@ async def test_unrelated_400_propagates_without_cache_poisoning() -> None:
async def test_nested_unrelated_allow_list_cannot_retry_or_poison_cache() -> None:
provider = _provider()
body = provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.off(),
+ provider_model=(_request()).model,
)
error = _BadRequest(
"invalid request",
@@ -600,8 +647,9 @@ async def test_nested_unrelated_allow_list_cannot_retry_or_poison_cache() -> Non
async def test_advertised_current_value_does_not_retry_or_cache() -> None:
provider = _provider()
body = provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(_request()).model,
)
create = AsyncMock(side_effect=_vocabulary_error("`low`, `medium`, or `high`"))
@@ -623,7 +671,11 @@ async def test_advertised_current_value_does_not_retry_or_cache() -> None:
async def test_last_attempt_learns_but_does_not_exceed_budget() -> None:
provider = _provider(max_attempts=1)
policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)
- body = provider._build_request_body(_request(), reasoning=policy)
+ body = provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ )
create = AsyncMock(side_effect=_vocabulary_error())
with (
@@ -641,7 +693,11 @@ async def test_last_attempt_learns_but_does_not_exceed_budget() -> None:
{"none", "default"}
)
assert (
- provider._build_request_body(_request(), reasoning=policy)["reasoning_effort"]
+ provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=policy,
+ provider_model=(_request()).model,
+ )["reasoning_effort"]
== "default"
)
@@ -650,8 +706,9 @@ async def test_last_attempt_learns_but_does_not_exceed_budget() -> None:
async def test_output_cap_and_reasoning_corrections_share_one_session() -> None:
provider = _provider()
body = provider._build_request_body(
- make_messages_request(_MODEL, max_tokens=64_000),
+ canonical_request(make_messages_request(_MODEL, max_tokens=64_000)),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(make_messages_request(_MODEL, max_tokens=64_000)).model,
)
cap_error = _BadRequest("max_completion_tokens must be less than or equal to 40960")
create = AsyncMock(side_effect=[cap_error, _vocabulary_error(), object()])
@@ -679,8 +736,9 @@ async def test_output_cap_and_reasoning_corrections_share_one_session() -> None:
async def test_corrected_request_cannot_enter_vocabulary_retry_loop() -> None:
provider = _provider()
body = provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(_request()).model,
)
create = AsyncMock(side_effect=[_vocabulary_error(), _vocabulary_error()])
@@ -708,8 +766,9 @@ async def test_reasoning_correction_emits_one_downstream_lifecycle() -> None:
raw = "".join(
await collect_anthropic(
provider.stream_response(
- request,
+ canonical_request(request),
reasoning=policy,
+ provider_model=(request).model,
)
)
)
diff --git a/tests/providers/test_huggingface.py b/tests/providers/test_huggingface.py
index ba484fae..4561ec54 100644
--- a/tests/providers/test_huggingface.py
+++ b/tests/providers/test_huggingface.py
@@ -6,10 +6,10 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from free_claude_code.config.provider_catalog import HUGGINGFACE_DEFAULT_BASE
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
+from free_claude_code.providers.openai_chat import ReasoningReplayMode
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -76,7 +76,9 @@ def test_build_request_body_keeps_max_tokens(huggingface_provider):
"max_tokens": 42,
}
- body = huggingface_provider._build_request_body(make_request())
+ body = huggingface_provider._build_request_body(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
mock_convert.assert_called_once()
assert (
@@ -92,7 +94,9 @@ def test_build_request_body_preserves_caller_extra_body(huggingface_provider):
extra_body = {"provider": "auto", "routing": {"bill_to": "my-org"}}
req = make_request(extra_body=extra_body)
- body = huggingface_provider._build_request_body(req)
+ body = huggingface_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
assert body["extra_body"] == extra_body
assert body["extra_body"] is not extra_body
@@ -111,8 +115,9 @@ def test_build_request_body_leaves_reasoning_control_to_selected_upstream(
huggingface_provider, reasoning
):
body = huggingface_provider._build_request_body(
- make_request(),
+ canonical_request(make_request()),
reasoning=reasoning,
+ provider_model=(make_request()).model,
)
assert "reasoning_effort" not in body
@@ -137,7 +142,9 @@ def test_build_request_body_does_not_replay_prior_thinking_blocks(
],
)
- body = huggingface_provider._build_request_body(req)
+ body = huggingface_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
assert body["messages"] == [{"role": "assistant", "content": "visible answer"}]
assert "reasoning_content" not in body["messages"][0]
@@ -158,7 +165,9 @@ def test_build_request_body_does_not_replay_top_level_reasoning_content(
],
)
- body = huggingface_provider._build_request_body(req)
+ body = huggingface_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
assert body["messages"] == [{"role": "assistant", "content": "visible answer"}]
assert "hidden prior reasoning" not in str(body)
@@ -188,7 +197,9 @@ async def test_stream_response_text(huggingface_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- huggingface_provider.stream_response(make_request())
+ huggingface_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
@@ -221,7 +232,9 @@ async def test_stream_response_reasoning_content(huggingface_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- huggingface_provider.stream_response(make_request())
+ huggingface_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
diff --git a/tests/providers/test_kilo.py b/tests/providers/test_kilo.py
index 807500f2..f163977a 100644
--- a/tests/providers/test_kilo.py
+++ b/tests/providers/test_kilo.py
@@ -15,11 +15,23 @@ from free_claude_code.core.anthropic.stream_contracts import (
text_content,
thinking_content,
)
+from free_claude_code.core.inference import (
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+)
from free_claude_code.core.reasoning import ReasoningPolicy
+from free_claude_code.core.replay_envelope import (
+ decode_replay_envelope,
+ encode_replay_envelope,
+)
from free_claude_code.providers.kilo import KiloProvider
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from free_claude_code.providers.openai_compat import openai_replay_scope
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -100,7 +112,11 @@ def test_build_request_body_openai_shape(kilo_provider):
}
)
- body = kilo_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = kilo_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["model"] == "anthropic/claude-sonnet-4.5"
assert body["messages"][0] == {"role": "user", "content": "Hello"}
@@ -116,7 +132,11 @@ def test_build_request_body_forwards_caller_extra_body(kilo_provider):
}
)
- body = kilo_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = kilo_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body.get("extra_body", {}).get("custom_field") == "value"
@@ -142,7 +162,11 @@ def test_extra_body_cannot_override_canonical_request_fields(kilo_provider, fiel
)
with pytest.raises(InvalidRequestError, match=field):
- kilo_provider._build_request_body(request, reasoning=reasoning_for(request))
+ kilo_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
def test_build_request_body_sends_reasoning_object(kilo_provider):
@@ -154,7 +178,11 @@ def test_build_request_body_sends_reasoning_object(kilo_provider):
}
)
- body = kilo_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = kilo_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body.get("extra_body", {}).get("reasoning") is not None
@@ -168,8 +196,9 @@ def test_build_request_body_sends_reasoning_disabled(kilo_provider):
)
body = kilo_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.off(),
+ provider_model=(request).model,
)
assert body["extra_body"]["reasoning"] == {"enabled": False}
@@ -182,6 +211,21 @@ def test_build_request_body_replays_opaque_reasoning_details_on_tool_turn(
"type": "reasoning.opaque",
"data": {"signature": "opaque-value"},
}
+ carrier = encode_replay_envelope(
+ (
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,
+ kind=ReplayArtifactKind.REASONING_DETAILS,
+ attachment=ReplayAttachment.REASONING,
+ scope=openai_replay_scope(
+ "KILO",
+ "m",
+ replay_format="chat-completions",
+ ),
+ payload=detail,
+ ),
+ )
+ )
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -191,7 +235,7 @@ def test_build_request_body_replays_opaque_reasoning_details_on_tool_turn(
"content": [
{
"type": "redacted_thinking",
- "data": json.dumps(detail),
+ "data": carrier,
},
{
"type": "tool_use",
@@ -216,8 +260,9 @@ def test_build_request_body_replays_opaque_reasoning_details_on_tool_turn(
)
body = kilo_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistant = next(msg for msg in body["messages"] if msg["role"] == "assistant")
@@ -266,7 +311,11 @@ async def test_stream_uses_reasoning_field_without_duplicating_plain_details(
return_value=stream,
):
event_text = "".join(
- await collect_anthropic(kilo_provider.stream_response(request))
+ await collect_anthropic(
+ kilo_provider.stream_response(
+ canonical_request(request), provider_model=(request).model
+ )
+ )
)
events = parse_sse_text(event_text)
@@ -279,7 +328,16 @@ async def test_stream_uses_reasoning_field_without_duplicating_plain_details(
and event.data.get("content_block", {}).get("type") == "redacted_thinking"
]
assert len(redacted_blocks) == 1
- assert json.loads(redacted_blocks[0]["data"]) == encrypted
+ artifacts = decode_replay_envelope(
+ redacted_blocks[0]["data"],
+ attachment=ReplayAttachment.REASONING,
+ )
+ assert artifacts is not None
+ assert len(artifacts) == 1
+ assert artifacts[0].kind is ReplayArtifactKind.REASONING_DETAILS
+ assert isinstance(artifacts[0].payload, str)
+ assert json.loads(artifacts[0].payload) == encrypted
+ assert artifacts[0].scope is not None
assert stream.closed
@@ -307,7 +365,11 @@ async def test_stream_restarts_reasoning_reconciliation_after_early_retry(
side_effect=[abandoned, recovered],
) as create:
event_text = "".join(
- await collect_anthropic(kilo_provider.stream_response(request))
+ await collect_anthropic(
+ kilo_provider.stream_response(
+ canonical_request(request), provider_model=(request).model
+ )
+ )
)
events = parse_sse_text(event_text)
@@ -349,8 +411,9 @@ async def test_stream_omits_all_reasoning_representations_when_disabled(
event_text = "".join(
await collect_anthropic(
kilo_provider.stream_response(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.off(),
+ provider_model=(request).model,
)
)
)
diff --git a/tests/providers/test_kimi.py b/tests/providers/test_kimi.py
index 878c3443..c79ad8d4 100644
--- a/tests/providers/test_kimi.py
+++ b/tests/providers/test_kimi.py
@@ -11,6 +11,7 @@ from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKEN
from free_claude_code.config.provider_catalog import KIMI_DEFAULT_BASE
from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -46,7 +47,11 @@ def test_build_request_body_openai_chat(kimi_provider):
messages=[Message(role="user", content="hi")],
)
- body = kimi_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = kimi_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["model"] == "kimi-k2.5"
assert body["max_tokens"] == 50
@@ -60,7 +65,11 @@ def test_build_request_body_default_max_tokens(kimi_provider):
messages=[Message(role="user", content="x")],
)
- body = kimi_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = kimi_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -75,7 +84,11 @@ def test_build_request_body_rejects_caller_extra_body(kimi_provider):
)
with pytest.raises(InvalidRequestError, match="Kimi Chat Completions"):
- kimi_provider._build_request_body(request, reasoning=reasoning_for(request))
+ kimi_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
def test_build_request_body_disables_kimi_thinking(kimi_provider):
@@ -87,7 +100,11 @@ def test_build_request_body_disables_kimi_thinking(kimi_provider):
}
)
- body = kimi_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = kimi_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["extra_body"]["thinking"] == {"type": "disabled"}
diff --git a/tests/providers/test_kimi_code.py b/tests/providers/test_kimi_code.py
index fd881961..94d05518 100644
--- a/tests/providers/test_kimi_code.py
+++ b/tests/providers/test_kimi_code.py
@@ -10,6 +10,7 @@ from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.provider_catalog import KIMI_CODE_DEFAULT_BASE
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -54,7 +55,9 @@ def test_explicit_output_limit_uses_max_completion_tokens(kimi_code_provider):
request = _request(max_tokens=32_768)
body = kimi_code_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["max_completion_tokens"] == 32_768
@@ -65,7 +68,9 @@ def test_omitted_output_limit_preserves_kimi_default(kimi_code_provider):
request = _request()
body = kimi_code_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert "max_tokens" not in body
@@ -92,7 +97,9 @@ def test_named_reasoning_effort_uses_kimi_vocabulary(
request = _request(output_config={"effort": client_effort})
body = kimi_code_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["reasoning_effort"] == upstream_effort
@@ -102,7 +109,9 @@ def test_enabled_reasoning_without_named_effort_uses_max(kimi_code_provider):
request = _request(thinking={"type": "enabled", "budget_tokens": 4_096})
body = kimi_code_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["reasoning_effort"] == "max"
@@ -112,7 +121,9 @@ def test_disabled_reasoning_uses_none(kimi_code_provider):
request = _request(thinking={"type": "disabled"})
body = kimi_code_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["reasoning_effort"] == "none"
@@ -133,7 +144,9 @@ def test_reasoning_history_uses_reasoning_content(kimi_code_provider):
)
body = kimi_code_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistant = body["messages"][0]
@@ -146,7 +159,9 @@ def test_caller_extra_body_is_rejected(kimi_code_provider):
with pytest.raises(InvalidRequestError, match="Kimi Code Chat Completions"):
kimi_code_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.py
index 58f3ee71..bc1caa8b 100644
--- a/tests/providers/test_llamacpp.py
+++ b/tests/providers/test_llamacpp.py
@@ -8,7 +8,7 @@ from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKEN
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -79,7 +79,11 @@ def test_build_request_body_uses_openai_chat_shape(
) -> None:
request = make_messages_request(LLAMACPP_MODEL, max_tokens=None)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["model"] == LLAMACPP_MODEL
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -105,7 +109,11 @@ def test_replay_is_independent_of_current_turn_reasoning_control(
],
)
- body = provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["messages"][1]["content"] == ("<think>\nprivate\n</think>\n\nvisible")
assert body["extra_body"]["thinking_budget_tokens"] == 0
@@ -139,7 +147,10 @@ async def test_stream_response_uses_shared_openai_chat_provider(
) as create:
output = "".join(
await collect_anthropic(
- provider.stream_response(make_messages_request(LLAMACPP_MODEL))
+ provider.stream_response(
+ canonical_request(make_messages_request(LLAMACPP_MODEL)),
+ provider_model=(make_messages_request(LLAMACPP_MODEL)).model,
+ )
)
)
diff --git a/tests/providers/test_llm7.py b/tests/providers/test_llm7.py
index 6ba3a3a7..c3771a94 100644
--- a/tests/providers/test_llm7.py
+++ b/tests/providers/test_llm7.py
@@ -14,6 +14,7 @@ from free_claude_code.core.json_types import JsonObject, JsonValue
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_DEFAULT,
REASONING_OFF,
@@ -98,7 +99,11 @@ def test_preserves_provider_reasoning_default_and_standard_request_fields(
llm7_provider: OpenAIChatProvider,
reasoning: ReasoningPolicy,
) -> None:
- body = llm7_provider._build_request_body(_request(), reasoning=reasoning)
+ body = llm7_provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=reasoning,
+ provider_model=(_request()).model,
+ )
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
assert body["model"] == _MODEL
@@ -142,8 +147,9 @@ def test_replays_reasoning_content_with_tool_history(
)
body = llm7_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
@@ -156,7 +162,7 @@ def test_replays_reasoning_content_with_tool_history(
"type": "function",
"function": {
"name": "read_file",
- "arguments": '{"path": "example.py"}',
+ "arguments": '{"path":"example.py"}',
},
}
],
diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.py
index 16d78b13..0e53c37b 100644
--- a/tests/providers/test_lmstudio.py
+++ b/tests/providers/test_lmstudio.py
@@ -11,7 +11,7 @@ from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.lmstudio import LMStudioProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -57,7 +57,9 @@ def test_default_base_url_constant():
def test_build_request_body_basic(lmstudio_provider):
req = make_request()
- body = lmstudio_provider._build_request_body(req)
+ body = lmstudio_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
assert body["model"] == "lmstudio-community/qwen2.5-7b-instruct"
assert body["messages"][0]["role"] == "system"
@@ -66,7 +68,9 @@ def test_build_request_body_basic(lmstudio_provider):
def test_adaptive_client_reasoning_uses_documented_named_effort(lmstudio_provider):
req = make_request()
- body = lmstudio_provider._build_request_body(req, reasoning=REASONING_ON)
+ body = lmstudio_provider._build_request_body(
+ canonical_request(req), reasoning=REASONING_ON, provider_model=(req).model
+ )
assert body["extra_body"]["reasoning_effort"] == "high"
assert "reasoning_effort" not in body
@@ -76,11 +80,12 @@ def test_exact_client_budget_is_not_derived_from_output_tokens(lmstudio_provider
req = make_request(max_tokens=8192)
body = lmstudio_provider._build_request_body(
- req,
+ canonical_request(req),
reasoning=ReasoningPolicy.on(
effort=ReasoningEffort.HIGH,
budget_tokens=1024,
),
+ provider_model=(req).model,
)
assert body["extra_body"]["reasoning_tokens"] == 1024
@@ -106,7 +111,9 @@ def test_build_request_body_never_replays_prior_thinking(lmstudio_provider):
},
]
)
- body = lmstudio_provider._build_request_body(req)
+ body = lmstudio_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
roles = [m.get("role") for m in body.get("messages", [])]
assert "assistant_reasoning_content" not in roles
@@ -117,15 +124,17 @@ def test_preflight_builds_before_context_budget_and_preserves_policy(
lmstudio_provider,
):
request = make_request()
+ canonical = canonical_request(request)
calls: list[tuple[str, object]] = []
- def build(request_arg, *, reasoning):
- assert request_arg is request
+ def build(request_arg, *, provider_model, reasoning):
+ assert request_arg is canonical
+ assert provider_model == request.model
calls.append(("build", reasoning))
return {}
def check_context(request_arg):
- assert request_arg is request
+ assert request_arg is canonical
calls.append(("context", request_arg))
with (
@@ -136,9 +145,13 @@ def test_preflight_builds_before_context_budget_and_preserves_policy(
side_effect=check_context,
),
):
- lmstudio_provider.preflight_stream(request, reasoning=REASONING_OFF)
+ lmstudio_provider.preflight_stream(
+ canonical,
+ reasoning=REASONING_OFF,
+ provider_model=request.model,
+ )
- assert calls == [("build", REASONING_OFF), ("context", request)]
+ assert calls == [("build", REASONING_OFF), ("context", canonical)]
def test_preflight_conversion_failure_skips_context_budget(lmstudio_provider):
@@ -154,7 +167,11 @@ def test_preflight_conversion_failure_skips_context_budget(lmstudio_provider):
patch.object(lmstudio_provider, "_preflight_context_budget") as context,
pytest.raises(InvalidRequestError, match="invalid request conversion"),
):
- lmstudio_provider.preflight_stream(request, reasoning=REASONING_ON)
+ lmstudio_provider.preflight_stream(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
context.assert_not_called()
@@ -183,7 +200,11 @@ async def test_stream_response_text(lmstudio_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(lmstudio_provider.stream_response(req))
+ events = await collect_anthropic(
+ lmstudio_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"text_delta"' in event and "Hello back!" in event for event in events
@@ -219,8 +240,7 @@ async def test_stream_response_passes_exact_reasoning_budget_via_extra_body(
events = await collect_anthropic(
lmstudio_provider.stream_response(
- req,
- reasoning=policy,
+ canonical_request(req), reasoning=policy, provider_model=(req).model
)
)
@@ -262,7 +282,7 @@ def test_preflight_context_budget_rejects_request_over_90_percent(lmstudio_provi
with (
patch.object(lmstudio_provider, "_loaded_context_length", return_value=1000),
patch(
- "free_claude_code.providers.lmstudio.client.get_token_count",
+ "free_claude_code.providers.lmstudio.client.get_inference_token_count",
return_value=901,
),
pytest.raises(ExecutionFailure) as exc_info,
diff --git a/tests/providers/test_minimax.py b/tests/providers/test_minimax.py
index 176fef4c..d4e9257d 100644
--- a/tests/providers/test_minimax.py
+++ b/tests/providers/test_minimax.py
@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.stream_contracts import (
)
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -102,7 +103,9 @@ def test_build_request_body_requests_split_output_and_max_completion_tokens(
)
body = minimax_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "MiniMax-M3"
@@ -120,7 +123,11 @@ def test_build_request_body_does_not_invent_unsupported_compute_control(
messages=[Message(role="user", content="Hello")],
)
- body = minimax_provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = minimax_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["extra_body"] == {"reasoning_split": True}
@@ -157,7 +164,11 @@ async def test_stream_preserves_reasoning_content(minimax_provider):
new_callable=AsyncMock,
return_value=stream,
) as create:
- events = await collect_anthropic(minimax_provider.stream_response(request))
+ events = await collect_anthropic(
+ minimax_provider.stream_response(
+ canonical_request(request), provider_model=(request).model
+ )
+ )
parsed = parse_sse_text("".join(events))
assert thinking_content(parsed) == "plan"
diff --git a/tests/providers/test_mistral.py b/tests/providers/test_mistral.py
index 4ba6be3f..cdfcee09 100644
--- a/tests/providers/test_mistral.py
+++ b/tests/providers/test_mistral.py
@@ -11,7 +11,7 @@ from free_claude_code.config.provider_catalog import MISTRAL_DEFAULT_BASE
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.providers.mistral import MistralProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -57,7 +57,9 @@ def test_default_base_url():
def test_build_request_body_basic(mistral_provider):
"""Basic request body conversion works for Mistral."""
req = make_request()
- body = mistral_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = mistral_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert body["model"] == "devstral-small-latest"
assert body["messages"][0]["role"] == "system"
@@ -96,7 +98,9 @@ def test_build_request_body_replays_prior_thinking_as_mistral_chunks(
],
)
- body = mistral_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = mistral_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assistant = body["messages"][0]
assert "reasoning_content" not in assistant
@@ -127,7 +131,9 @@ def test_build_request_body_preserves_tools_tool_choice_and_params(mistral_provi
stop_sequences=["STOP"],
)
- body = mistral_provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = mistral_provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert body["max_tokens"] == 100
assert body["temperature"] == 0.5
@@ -148,7 +154,9 @@ def test_build_request_body_reasoning_off_uses_native_none():
admission=immediate_admission(),
)
req = make_request()
- body = provider._build_request_body(req, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model
+ )
assert body["reasoning_effort"] == "none"
assert all("reasoning_content" not in m for m in body.get("messages", []))
@@ -177,7 +185,9 @@ def test_reasoning_off_keeps_replay_separate_from_new_turn_compute():
],
)
- body = provider._build_request_body(req, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model
+ )
assert body["reasoning_effort"] == "none"
assert body["messages"][0]["content"] == [
@@ -215,7 +225,11 @@ async def test_stream_response_text(mistral_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"text_delta"' in event and "Hello back!" in event for event in events
@@ -248,7 +262,11 @@ async def test_stream_response_reasoning_content(mistral_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"thinking_delta"' in event and "Thinking..." in event for event in events
@@ -285,7 +303,11 @@ async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any(
'"thinking_delta"' in event and "Native thought." in event for event in events
@@ -317,7 +339,11 @@ async def test_stream_response_native_mistral_text_chunk(mistral_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert any('"text_delta"' in event and "Native text." in event for event in events)
@@ -351,7 +377,11 @@ async def test_stream_response_preserves_native_thinking_and_string_text(
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
event_text = "\n".join(events)
assert '"thinking_delta"' in event_text
@@ -389,7 +419,11 @@ async def test_stream_response_preserves_native_reasoning_and_string_text(
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
event_text = "\n".join(events)
assert "Native reasoning." in event_text
@@ -429,7 +463,11 @@ async def test_stream_response_preserves_mixed_native_content_array(
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
event_text = "\n".join(events)
assert "Native thought." in event_text
@@ -468,7 +506,11 @@ async def test_stream_response_ignores_unknown_native_content_chunks(
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
event_text = "\n".join(events)
assert "reference_ids" not in event_text
@@ -509,7 +551,11 @@ async def test_stream_response_suppresses_native_mistral_thinking_when_disabled(
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- mistral_provider.stream_response(req, reasoning=REASONING_OFF)
+ mistral_provider.stream_response(
+ canonical_request(req),
+ reasoning=REASONING_OFF,
+ provider_model=(req).model,
+ )
)
event_text = "\n".join(events)
@@ -571,7 +617,11 @@ async def test_stream_response_retries_without_mistral_reasoning_on_rejection(
mock_create.side_effect = [error, mock_stream()]
events = await collect_anthropic(
- mistral_provider.stream_response(req, reasoning=reasoning_for(req))
+ mistral_provider.stream_response(
+ canonical_request(req),
+ reasoning=reasoning_for(req),
+ provider_model=(req).model,
+ )
)
assert mock_create.await_count == 2
@@ -639,7 +689,11 @@ async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools(
mock_create.side_effect = [error, mock_stream()]
events = await collect_anthropic(
- mistral_provider.stream_response(req, reasoning=reasoning_for(req))
+ mistral_provider.stream_response(
+ canonical_request(req),
+ reasoning=reasoning_for(req),
+ provider_model=(req).model,
+ )
)
second_call = mock_create.await_args_list[1].kwargs
@@ -678,7 +732,11 @@ async def test_stream_response_retries_on_mistral_422_reasoning_rejection(
mock_create.side_effect = [error, mock_stream()]
events = await collect_anthropic(
- mistral_provider.stream_response(req, reasoning=reasoning_for(req))
+ mistral_provider.stream_response(
+ canonical_request(req),
+ reasoning=reasoning_for(req),
+ provider_model=(req).model,
+ )
)
assert mock_create.await_count == 2
@@ -731,7 +789,11 @@ async def test_stream_response_retries_when_model_disables_reasoning_input(
) as mock_create:
mock_create.side_effect = [error, mock_stream()]
- events = await collect_anthropic(mistral_provider.stream_response(req))
+ events = await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 2
second_call = mock_create.await_args_list[1].kwargs
@@ -751,7 +813,11 @@ async def test_stream_response_unrelated_bad_request_does_not_retry(mistral_prov
mock_create.side_effect = error
with pytest.raises(ExecutionFailure) as exc_info:
- await collect_anthropic(mistral_provider.stream_response(req))
+ await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 1
assert "Invalid request sent to provider" in exc_info.value.message
@@ -770,7 +836,11 @@ async def test_stream_response_generic_thinking_error_does_not_retry(
mock_create.side_effect = error
with pytest.raises(ExecutionFailure) as exc_info:
- await collect_anthropic(mistral_provider.stream_response(req))
+ await collect_anthropic(
+ mistral_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 1
assert "Invalid request sent to provider" in exc_info.value.message
diff --git a/tests/providers/test_model_discovery.py b/tests/providers/test_model_discovery.py
index 888add5e..16f4e548 100644
--- a/tests/providers/test_model_discovery.py
+++ b/tests/providers/test_model_discovery.py
@@ -14,8 +14,11 @@ from free_claude_code.config.provider_catalog import (
WAFER_DEFAULT_BASE,
)
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ InferenceStreamLedger,
+)
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.base import BaseProvider
from free_claude_code.providers.deepseek import DeepSeekProvider
@@ -357,8 +360,9 @@ class FakeProvider(BaseProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
return None
@@ -381,9 +385,10 @@ class FakeProvider(BaseProvider):
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
diff --git a/tests/providers/test_nebius.py b/tests/providers/test_nebius.py
index 8e446e2e..c94d6dcd 100644
--- a/tests/providers/test_nebius.py
+++ b/tests/providers/test_nebius.py
@@ -13,6 +13,7 @@ from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -64,7 +65,9 @@ def test_encodes_documented_reasoning_effort(
}
)
- body = nebius_provider._build_request_body(request, reasoning=reasoning)
+ body = nebius_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
assert body["reasoning_effort"] == expected
assert "extra_body" not in body
@@ -89,8 +92,9 @@ def test_replays_reasoning_content(nebius_provider: OpenAIChatProvider) -> None:
)
body = nebius_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
diff --git a/tests/providers/test_novita.py b/tests/providers/test_novita.py
index 3909fc32..67f731bc 100644
--- a/tests/providers/test_novita.py
+++ b/tests/providers/test_novita.py
@@ -10,6 +10,7 @@ from free_claude_code.config.provider_catalog import NOVITA_DEFAULT_BASE
from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -53,7 +54,9 @@ def test_build_request_body_openai_chat_shape(novita_provider):
)
body = novita_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "deepseek/deepseek-v4-flash-0731"
@@ -71,7 +74,9 @@ def test_build_request_body_default_max_tokens(novita_provider):
)
body = novita_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -87,7 +92,9 @@ def test_build_request_body_preserves_validated_extra_body(novita_provider):
)
body = novita_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["custom_param"] == "value"
@@ -105,7 +112,11 @@ def test_build_request_body_rejects_reserved_reasoning_extra_body_keys(
)
with pytest.raises(InvalidRequestError, match="extra_body must not override"):
- novita_provider._build_request_body(request, reasoning=reasoning_for(request))
+ novita_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
def test_build_request_body_disables_thinking_when_reasoning_off(novita_provider):
@@ -114,7 +125,11 @@ def test_build_request_body_disables_thinking_when_reasoning_off(novita_provider
messages=[Message(role="user", content="x")],
)
- body = novita_provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = novita_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["extra_body"]["enable_thinking"] is False
@@ -125,7 +140,11 @@ def test_build_request_body_enables_thinking_when_reasoning_on(novita_provider):
messages=[Message(role="user", content="x")],
)
- body = novita_provider._build_request_body(request, reasoning=REASONING_ON)
+ body = novita_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
assert body["extra_body"]["enable_thinking"] is True
@@ -137,7 +156,9 @@ def test_build_request_body_omits_thinking_field_by_default(novita_provider):
)
body = novita_provider._build_request_body(
- request, reasoning=ReasoningPolicy.provider_default()
+ canonical_request(request),
+ reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(request).model,
)
assert "enable_thinking" not in body.get("extra_body", {})
diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.py
index 73aab9f7..cd3fc44e 100644
--- a/tests/providers/test_nvidia_nim.py
+++ b/tests/providers/test_nvidia_nim.py
@@ -16,7 +16,7 @@ from free_claude_code.providers.nvidia_nim.tool_schema import (
)
from free_claude_code.providers.stream_recovery import RecoveryHoldbackBuffer
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -178,7 +178,9 @@ async def test_build_request_body(provider_config):
admission=immediate_admission(),
)
req = make_request()
- body = provider._build_request_body(req, reasoning=reasoning_for(req))
+ body = provider._build_request_body(
+ canonical_request(req), reasoning=reasoning_for(req), provider_model=(req).model
+ )
assert body["model"] == "test-model"
assert body["temperature"] == 0.5
@@ -204,7 +206,9 @@ async def test_build_request_body_encodes_explicit_reasoning_off(
admission=immediate_admission(),
)
req = make_request()
- body = provider._build_request_body(req, reasoning=REASONING_OFF)
+ body = provider._build_request_body(
+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model
+ )
extra = body.get("extra_body", {})
assert extra["chat_template_kwargs"] == {
@@ -215,7 +219,7 @@ async def test_build_request_body_encodes_explicit_reasoning_off(
@pytest.mark.asyncio
-async def test_build_request_body_omits_reasoning_when_request_disables_thinking(
+async def test_build_request_body_does_not_reresolve_client_reasoning(
provider_config,
):
provider = NvidiaNimProvider(
@@ -223,9 +227,10 @@ async def test_build_request_body_omits_reasoning_when_request_disables_thinking
nim_settings=NimSettings(),
admission=immediate_admission(),
)
- req = make_request()
- req.thinking.enabled = False
- body = provider._build_request_body(req)
+ req = make_request(thinking={"enabled": False})
+ body = provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
extra = body.get("extra_body", {})
assert "chat_template_kwargs" not in extra
@@ -262,8 +267,12 @@ def test_preflight_and_build_request_issue_206_post_tool_text(nim_provider):
),
],
)
- nim_provider.preflight_stream(req, reasoning=REASONING_OFF)
- body = nim_provider._build_request_body(req, reasoning=REASONING_OFF)
+ nim_provider.preflight_stream(
+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model
+ )
+ body = nim_provider._build_request_body(
+ canonical_request(req), reasoning=REASONING_OFF, provider_model=(req).model
+ )
assert "messages" in body
assert any(m.get("role") == "tool" for m in body["messages"])
@@ -300,7 +309,11 @@ async def test_stream_response_text(nim_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert len(events) > 0
assert "event: message_start" in events[0]
@@ -348,7 +361,11 @@ async def test_stream_response_thinking_reasoning_content(nim_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
# Check for thinking_delta
found_thinking = False
@@ -391,7 +408,11 @@ async def test_stream_response_suppresses_thinking_when_disabled(provider_config
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- provider.stream_response(req, reasoning=REASONING_OFF)
+ provider.stream_response(
+ canonical_request(req),
+ reasoning=REASONING_OFF,
+ provider_model=(req).model,
+ )
)
event_text = "".join(events)
@@ -438,7 +459,11 @@ async def test_stream_response_retries_without_chat_template(provider_config):
mock_create.side_effect = [first_error, mock_stream()]
events = await collect_anthropic(
- provider.stream_response(req, reasoning=REASONING_ON)
+ provider.stream_response(
+ canonical_request(req),
+ reasoning=REASONING_ON,
+ provider_model=(req).model,
+ )
)
assert mock_create.await_count == 2
@@ -495,7 +520,11 @@ async def test_stream_response_retries_without_chat_template_kwargs_issue_993(
mock_create.side_effect = [first_error, mock_stream()]
events = await collect_anthropic(
- provider.stream_response(req, reasoning=REASONING_ON)
+ provider.stream_response(
+ canonical_request(req),
+ reasoning=REASONING_ON,
+ provider_model=(req).model,
+ )
)
assert mock_create.await_count == 2
@@ -532,7 +561,11 @@ async def test_stream_response_does_not_retry_unrelated_bad_request(provider_con
mock_create.side_effect = _make_bad_request_error("unrelated bad request")
with pytest.raises(ExecutionFailure) as exc_info:
- await collect_anthropic(provider.stream_response(req))
+ await collect_anthropic(
+ provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 1
assert "Invalid request sent to provider" in exc_info.value.message
@@ -567,7 +600,11 @@ async def test_tool_call_stream(nim_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
starts = [
e for e in events if "event: content_block_start" in e and '"tool_use"' in e
@@ -609,7 +646,11 @@ async def test_native_minimax_tool_markup_becomes_anthropic_tool_use(nim_provide
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
event_text = "".join(events)
assert namespace not in event_text
@@ -657,7 +698,11 @@ async def test_native_minimax_reasoning_markup_becomes_anthropic_tool_use(
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
event_text = "".join(events)
assert namespace not in event_text
@@ -693,7 +738,11 @@ async def test_native_minimax_markup_without_tools_retries_without_leaking(
) as mock_create:
mock_create.side_effect = attempts
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
event_text = "".join(events)
assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
@@ -738,7 +787,11 @@ async def test_native_minimax_tool_markup_restores_nim_argument_aliases(nim_prov
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert json.loads(_input_json_deltas(events)[0]) == {
"pattern": "needle",
@@ -789,7 +842,11 @@ async def test_malformed_native_minimax_tool_call_retries_without_leaking(
) as mock_create:
mock_create.side_effect = [malformed_stream(), recovered_stream()]
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 2
event_text = "".join(events)
@@ -855,7 +912,11 @@ async def test_midstream_native_tool_suffix_failure_recovers_without_duplication
):
mock_create.side_effect = [malformed_stream(), recovered_stream()]
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 2
event_text = "".join(events)
@@ -899,7 +960,11 @@ async def test_stream_response_restores_aliased_tool_arguments(nim_provider):
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
await_args = mock_create.await_args
assert await_args is not None
@@ -956,7 +1021,11 @@ async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provid
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
deltas = _input_json_deltas(events)
assert len(deltas) == 1
@@ -1002,7 +1071,11 @@ async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provid
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
deltas = _input_json_deltas(events)
assert len(deltas) == 1
@@ -1048,7 +1121,11 @@ async def test_stream_response_task_tool_still_forces_background_false(nim_provi
) as mock_create:
mock_create.return_value = mock_stream()
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
deltas = _input_json_deltas(events)
assert len(deltas) == 1
@@ -1080,8 +1157,9 @@ async def test_stream_response_retries_without_reasoning_budget(nim_provider):
events = await collect_anthropic(
nim_provider.stream_response(
- req,
+ canonical_request(req),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),
+ provider_model=(req).model,
)
)
@@ -1126,7 +1204,9 @@ async def test_stream_response_retries_without_budget_for_thinking_token_error(
events = await collect_anthropic(
nim_provider.stream_response(
- req, reasoning=ReasoningPolicy.on(budget_tokens=77)
+ canonical_request(req),
+ reasoning=ReasoningPolicy.on(budget_tokens=77),
+ provider_model=(req).model,
)
)
@@ -1191,7 +1271,11 @@ async def test_stream_response_retries_without_reasoning_content(nim_provider):
) as mock_create:
mock_create.side_effect = [error, mock_stream()]
- events = await collect_anthropic(nim_provider.stream_response(req))
+ events = await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 2
first_call = mock_create.await_args_list[0].kwargs
@@ -1216,7 +1300,11 @@ async def test_stream_response_bad_request_without_reasoning_budget_does_not_ret
mock_create.side_effect = error
with pytest.raises(ExecutionFailure) as exc_info:
- await collect_anthropic(nim_provider.stream_response(req))
+ await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 1
assert "Invalid request sent to provider" in exc_info.value.message
@@ -1235,7 +1323,11 @@ async def test_stream_response_unrelated_internal_error_does_not_downgrade(
mock_create.side_effect = error
with pytest.raises(ExecutionFailure) as exc_info:
- await collect_anthropic(nim_provider.stream_response(req))
+ await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
assert all(
@@ -1260,7 +1352,11 @@ async def test_stream_response_internal_reasoning_content_error_does_not_downgra
mock_create.side_effect = error
with pytest.raises(ExecutionFailure) as exc_info:
- await collect_anthropic(nim_provider.stream_response(req))
+ await collect_anthropic(
+ nim_provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
assert all(
diff --git a/tests/providers/test_nvidia_nim_degraded_retry.py b/tests/providers/test_nvidia_nim_degraded_retry.py
index 83558cb2..a2dfaebb 100644
--- a/tests/providers/test_nvidia_nim_degraded_retry.py
+++ b/tests/providers/test_nvidia_nim_degraded_retry.py
@@ -21,7 +21,7 @@ from free_claude_code.providers.failure_policy import (
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.open_router import OpenRouterProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import make_provider_config
_FUNCTION_ID = "87ea0ddc-cff1-4bca-bf8b-3bd98a35ddd0"
@@ -139,7 +139,9 @@ async def test_degraded_function_retries_unchanged_request_then_succeeds() -> No
):
events = await collect_anthropic(
provider.stream_response(
- make_messages_request(), request_id="req_recovered"
+ canonical_request(make_messages_request()),
+ request_id="req_recovered",
+ provider_model=(make_messages_request()).model,
)
)
@@ -173,7 +175,11 @@ async def test_degraded_function_exhaustion_is_detailed_redacted_overload() -> N
pytest.raises(ExecutionFailure) as exc_info,
):
await collect_anthropic(
- provider.stream_response(make_messages_request(), request_id="req_degraded")
+ provider.stream_response(
+ canonical_request(make_messages_request()),
+ request_id="req_degraded",
+ provider_model=(make_messages_request()).model,
+ )
)
assert create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS
@@ -217,7 +223,11 @@ async def test_negative_derived_max_tokens_is_context_window_failure(
pytest.raises(ExecutionFailure) as exc_info,
):
await collect_anthropic(
- provider.stream_response(make_messages_request(), request_id="req_context")
+ provider.stream_response(
+ canonical_request(make_messages_request()),
+ request_id="req_context",
+ provider_model=(make_messages_request()).model,
+ )
)
assert create.await_count == 1
@@ -251,7 +261,9 @@ async def test_negative_derived_max_tokens_is_context_window_failure_on_500(
):
await collect_anthropic(
provider.stream_response(
- make_messages_request(), request_id="req_context_500"
+ canonical_request(make_messages_request()),
+ request_id="req_context_500",
+ provider_model=(make_messages_request()).model,
)
)
@@ -292,7 +304,12 @@ async def test_other_nim_max_token_errors_remain_invalid_requests(
) as create,
pytest.raises(ExecutionFailure) as exc_info,
):
- await collect_anthropic(provider.stream_response(make_messages_request()))
+ await collect_anthropic(
+ provider.stream_response(
+ canonical_request(make_messages_request()),
+ provider_model=(make_messages_request()).model,
+ )
+ )
assert create.await_count == 1
assert exc_info.value.kind is FailureKind.INVALID_REQUEST
@@ -323,7 +340,12 @@ async def test_unrelated_nim_bad_request_is_not_retried(detail: str) -> None:
) as create,
pytest.raises(ExecutionFailure) as exc_info,
):
- await collect_anthropic(provider.stream_response(make_messages_request()))
+ await collect_anthropic(
+ provider.stream_response(
+ canonical_request(make_messages_request()),
+ provider_model=(make_messages_request()).model,
+ )
+ )
assert create.await_count == 1
assert exc_info.value.kind is FailureKind.INVALID_REQUEST
@@ -350,7 +372,12 @@ async def test_degraded_wording_remains_non_retryable_for_other_providers() -> N
) as create,
pytest.raises(ExecutionFailure) as exc_info,
):
- await collect_anthropic(provider.stream_response(make_messages_request()))
+ await collect_anthropic(
+ provider.stream_response(
+ canonical_request(make_messages_request()),
+ provider_model=(make_messages_request()).model,
+ )
+ )
assert create.await_count == 1
assert exc_info.value.kind is FailureKind.INVALID_REQUEST
diff --git a/tests/providers/test_nvidia_nim_request.py b/tests/providers/test_nvidia_nim_request.py
index 84b22b87..dfc58e06 100644
--- a/tests/providers/test_nvidia_nim_request.py
+++ b/tests/providers/test_nvidia_nim_request.py
@@ -8,13 +8,12 @@ import pytest
from free_claude_code.config.nim import NimSettings
from free_claude_code.core.anthropic import set_if_not_none
-from free_claude_code.core.anthropic.models import MessagesRequest, Tool
+from free_claude_code.core.anthropic.models import Tool
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.nvidia_nim.request_options import (
_set_extra,
-)
-from free_claude_code.providers.nvidia_nim.request_options import (
- build_nim_request_body as build_request_body,
+ build_nim_request_body,
)
from free_claude_code.providers.nvidia_nim.retry import (
clone_body_without_chat_template,
@@ -51,19 +50,41 @@ GREP_SCHEMA_FROM_SERVER_LOG: dict[str, Any] = {
@pytest.fixture
-def req() -> MessagesRequest:
+def req() -> InferenceRequest:
+ return make_request()
+
+
+def make_request(**overrides: object) -> InferenceRequest:
+ data: dict[str, object] = {
+ "messages": [{"role": "user", "content": "hi"}],
+ "max_tokens": 100,
+ "system": None,
+ "temperature": None,
+ "top_p": None,
+ "stop_sequences": None,
+ "tools": None,
+ "extra_body": None,
+ "top_k": None,
+ "thinking": None,
+ }
+ data.update(overrides)
return make_messages_request(
model="test",
- messages=[{"role": "user", "content": "hi"}],
- max_tokens=100,
- system=None,
- temperature=None,
- top_p=None,
- stop_sequences=None,
- tools=None,
- extra_body=None,
- top_k=None,
- thinking=None,
+ **data,
+ )
+
+
+def build_request_body(
+ request: InferenceRequest,
+ nim: NimSettings,
+ *,
+ reasoning: ReasoningPolicy,
+) -> dict[str, Any]:
+ return build_nim_request_body(
+ request,
+ nim,
+ provider_model=request.model,
+ reasoning=reasoning,
)
@@ -157,15 +178,15 @@ class TestBuildRequestBody:
"reasoning_budget": 2048,
}
- def test_max_tokens_capped_by_nim(self, req):
- req.max_tokens = 100000
+ def test_max_tokens_capped_by_nim(self):
+ req = make_request(max_tokens=100000)
nim = NimSettings(max_tokens=4096)
body = build_request_body(req, nim, reasoning=REASONING_ON)
assert body["max_tokens"] == 4096
@pytest.mark.parametrize("client_top_p", (None, 0.0, 0.5, 0.95, 1.0))
- def test_top_p_always_uses_nim_policy(self, req, client_top_p):
- req.top_p = client_top_p
+ def test_top_p_always_uses_nim_policy(self, client_top_p):
+ req = make_request(top_p=client_top_p)
body = build_request_body(req, NimSettings(), reasoning=REASONING_ON)
@@ -186,7 +207,7 @@ class TestBuildRequestBody:
assert body["parallel_tool_calls"] is False
def test_tool_schema_boolean_subschemas_are_removed_without_mutating_request(
- self, req
+ self,
):
tool_schema = {
"type": "object",
@@ -199,13 +220,15 @@ class TestBuildRequestBody:
"additionalProperties": False,
"required": ["query"],
}
- req.tools = [
- Tool(
- name="search",
- description="search",
- input_schema=tool_schema,
- )
- ]
+ req = make_request(
+ tools=[
+ Tool(
+ name="search",
+ description="search",
+ input_schema=tool_schema,
+ )
+ ]
+ )
body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)
@@ -219,7 +242,7 @@ class TestBuildRequestBody:
assert tool_schema["additionalProperties"] is False
assert tool_schema["properties"]["nested"]["additionalProperties"] is False
- def test_grep_schema_type_parameter_is_aliased_without_mutating_request(self, req):
+ def test_grep_schema_type_parameter_is_aliased_without_mutating_request(self):
tool_schema = deepcopy(GREP_SCHEMA_FROM_SERVER_LOG)
tool_schema["properties"]["_fcc_arg_type"] = {
"type": "string",
@@ -227,13 +250,15 @@ class TestBuildRequestBody:
}
tool_schema["required"] = ["pattern", "-A", "_fcc_arg_type"]
original_schema = deepcopy(tool_schema)
- req.tools = [
- Tool(
- name="Grep",
- description="Search file contents",
- input_schema=tool_schema,
- )
- ]
+ req = make_request(
+ tools=[
+ Tool(
+ name="Grep",
+ description="Search file contents",
+ input_schema=tool_schema,
+ )
+ ]
+ )
body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)
@@ -263,7 +288,7 @@ class TestBuildRequestBody:
assert "_fcc_arg_type" in parameters["required"]
assert tool_schema == original_schema
- def test_reported_long_tool_name_uses_generic_alias_after_nim_repairs(self, req):
+ def test_reported_long_tool_name_uses_generic_alias_after_nim_repairs(self):
"""Issue #1307's 52nd tool is portable without losing NIM arg aliases."""
long_name = "mcp__issue_1307__" + "x" * 85
assert len(long_name) == 102
@@ -281,8 +306,8 @@ class TestBuildRequestBody:
},
)
)
- req.tools = tools
- snapshot = req.model_dump()
+ req = make_request(tools=tools)
+ snapshot = req
body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)
@@ -290,15 +315,15 @@ class TestBuildRequestBody:
assert wire_name != long_name
assert re.fullmatch(r"[A-Za-z0-9_-]{1,64}", wire_name)
assert body[NIM_TOOL_ARGUMENT_ALIASES_KEY] == {
- long_name: {"_fcc_arg_type": "type"}
+ wire_name: {"_fcc_arg_type": "type"}
}
assert (
NIM_TOOL_ARGUMENT_ALIASES_KEY
not in body_without_nim_tool_argument_aliases(body)
)
- assert req.model_dump() == snapshot
+ assert req is snapshot
- def test_safe_tool_schema_does_not_add_alias_metadata(self, req):
+ def test_safe_tool_schema_does_not_add_alias_metadata(self):
tool_schema = {
"type": "object",
"properties": {
@@ -308,13 +333,15 @@ class TestBuildRequestBody:
},
"required": ["pattern"],
}
- req.tools = [
- Tool(
- name="Glob",
- description="Find files",
- input_schema=tool_schema,
- )
- ]
+ req = make_request(
+ tools=[
+ Tool(
+ name="Glob",
+ description="Find files",
+ input_schema=tool_schema,
+ )
+ ]
+ )
body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)
@@ -324,7 +351,7 @@ class TestBuildRequestBody:
assert parameters["required"] == ["pattern"]
def test_nested_schema_keyword_properties_are_aliased_without_mutating_request(
- self, req
+ self,
):
tool_schema = {
"type": "object",
@@ -341,13 +368,15 @@ class TestBuildRequestBody:
"required": ["parent"],
}
original_schema = deepcopy(tool_schema)
- req.tools = [
- Tool(
- name="NotionLike",
- description="Nested type schema",
- input_schema=tool_schema,
- )
- ]
+ req = make_request(
+ tools=[
+ Tool(
+ name="NotionLike",
+ description="Nested type schema",
+ input_schema=tool_schema,
+ )
+ ]
+ )
body = build_request_body(req, NimSettings(), reasoning=REASONING_OFF)
diff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.py
index 4cde616f..6eeb6681 100644
--- a/tests/providers/test_ollama.py
+++ b/tests/providers/test_ollama.py
@@ -14,7 +14,7 @@ from free_claude_code.core.anthropic.stream_contracts import (
)
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -80,7 +80,10 @@ def test_cloud_init_uses_fixed_openai_endpoint_and_api_key() -> None:
def test_build_request_body_uses_openai_chat_shape() -> None:
- body = _provider()._build_request_body(make_messages_request(OLLAMA_MODEL))
+ body = _provider()._build_request_body(
+ canonical_request(make_messages_request(OLLAMA_MODEL)),
+ provider_model=(make_messages_request(OLLAMA_MODEL)).model,
+ )
assert body["model"] == OLLAMA_MODEL
assert body["messages"][0]["role"] == "system"
@@ -94,7 +97,9 @@ def test_cloud_build_request_body_forwards_client_reasoning_effort() -> None:
OLLAMA_CLOUD_MODEL, output_config={"effort": "high"}
)
body = _cloud_provider()._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == OLLAMA_CLOUD_MODEL
@@ -131,7 +136,9 @@ def test_cloud_build_request_body_replays_thinking_in_ollama_reasoning_field() -
)
body = _cloud_provider()._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistant = next(
@@ -157,7 +164,11 @@ def test_replay_is_independent_of_disabled_current_turn_reasoning(provider) -> N
],
)
- body = provider()._build_request_body(request, reasoning=REASONING_OFF)
+ body = provider()._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assistant = next(
message for message in body["messages"] if message["role"] == "assistant"
)
@@ -195,7 +206,10 @@ async def test_stream_response_uses_shared_openai_chat_provider() -> None:
) as create:
output = "".join(
await collect_anthropic(
- provider.stream_response(make_messages_request(OLLAMA_MODEL))
+ provider.stream_response(
+ canonical_request(make_messages_request(OLLAMA_MODEL)),
+ provider_model=(make_messages_request(OLLAMA_MODEL)).model,
+ )
)
)
@@ -232,7 +246,10 @@ async def test_cloud_stream_maps_ollama_reasoning_delta_to_anthropic_thinking()
):
output = "".join(
await collect_anthropic(
- client.stream_response(make_messages_request(OLLAMA_CLOUD_MODEL))
+ client.stream_response(
+ canonical_request(make_messages_request(OLLAMA_CLOUD_MODEL)),
+ provider_model=(make_messages_request(OLLAMA_CLOUD_MODEL)).model,
+ )
)
)
diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.py
index d692a9bf..8d09edc7 100644
--- a/tests/providers/test_open_router.py
+++ b/tests/providers/test_open_router.py
@@ -1,6 +1,7 @@
"""Tests for the OpenRouter OpenAI-chat provider."""
import json
+from collections.abc import Mapping
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
@@ -14,10 +15,22 @@ from free_claude_code.core.anthropic.stream_contracts import (
text_content,
thinking_content,
)
+from free_claude_code.core.inference import (
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+)
+from free_claude_code.core.json_types import JsonValue
+from free_claude_code.core.replay_envelope import (
+ decode_replay_envelope,
+ encode_replay_envelope,
+)
from free_claude_code.providers.open_router import OpenRouterProvider
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from free_claude_code.providers.openai_compat import openai_replay_scope
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -46,6 +59,24 @@ def make_request(**overrides):
return make_messages_request("moonshotai/kimi-k2.6:free", **overrides)
+def _reasoning_carrier(detail: Mapping[str, JsonValue], *, model: str = "m") -> str:
+ return encode_replay_envelope(
+ (
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENROUTER,
+ kind=ReplayArtifactKind.REASONING_DETAILS,
+ attachment=ReplayAttachment.REASONING,
+ scope=openai_replay_scope(
+ "OPENROUTER",
+ model,
+ replay_format="chat-completions",
+ ),
+ payload=detail,
+ ),
+ )
+ )
+
+
@pytest.fixture
def open_router_provider():
return OpenRouterProvider(
@@ -84,7 +115,9 @@ def test_init_uses_openai_chat_provider(open_router_provider):
def test_build_request_body_uses_openai_chat_shape(open_router_provider):
- body = open_router_provider._build_request_body(make_request())
+ body = open_router_provider._build_request_body(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
assert body["model"] == "moonshotai/kimi-k2.6:free"
assert body["temperature"] == 0.5
@@ -97,7 +130,10 @@ def test_build_request_body_uses_openai_chat_shape(open_router_provider):
def test_build_request_body_default_max_tokens(open_router_provider):
- body = open_router_provider._build_request_body(make_request(max_tokens=None))
+ body = open_router_provider._build_request_body(
+ canonical_request(make_request(max_tokens=None)),
+ provider_model=(make_request(max_tokens=None)).model,
+ )
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -107,14 +143,20 @@ def test_openrouter_extra_body_rejects_overriding_reserved_fields(
):
with pytest.raises(InvalidRequestError, match="model"):
open_router_provider._build_request_body(
- make_request(extra_body={"model": "hijack"})
+ canonical_request(make_request(extra_body={"model": "hijack"})),
+ provider_model=(make_request(extra_body={"model": "hijack"})).model,
)
def test_openrouter_extra_body_allows_provider_keys(open_router_provider):
body = open_router_provider._build_request_body(
- make_request(extra_body={"transforms": ["no-web"], "plugins": []}),
+ canonical_request(
+ make_request(extra_body={"transforms": ["no-web"], "plugins": []})
+ ),
reasoning=REASONING_OFF,
+ provider_model=(
+ make_request(extra_body={"transforms": ["no-web"], "plugins": []})
+ ).model,
)
assert body["extra_body"] == {
@@ -129,7 +171,9 @@ def test_build_request_body_disables_reasoning_when_client_disables_it(
):
request = make_request(thinking={"type": "disabled"})
body = open_router_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["reasoning"] == {"enabled": False}
@@ -140,7 +184,9 @@ def test_build_request_body_maps_thinking_budget_to_reasoning_max_tokens(
):
request = make_request(thinking={"type": "enabled", "budget_tokens": 4096})
body = open_router_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["extra_body"]["reasoning"] == {"max_tokens": 4096}
@@ -159,7 +205,7 @@ def test_build_request_body_replays_openrouter_reasoning_details(
"content": [
{
"type": "redacted_thinking",
- "data": '{"type":"reasoning.encrypted","data":"opaque"}',
+ "data": _reasoning_carrier(detail),
},
{"type": "text", "text": "Need a tool."},
],
@@ -170,7 +216,9 @@ def test_build_request_body_replays_openrouter_reasoning_details(
)
body = open_router_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistant = next(msg for msg in body["messages"] if msg["role"] == "assistant")
@@ -189,7 +237,7 @@ def test_reasoning_details_skip_neutral_tool_turn_boundary(open_router_provider)
"content": [
{
"type": "redacted_thinking",
- "data": json.dumps(first_detail),
+ "data": _reasoning_carrier(first_detail),
},
{
"type": "tool_use",
@@ -215,7 +263,7 @@ def test_reasoning_details_skip_neutral_tool_turn_boundary(open_router_provider)
"content": [
{
"type": "redacted_thinking",
- "data": json.dumps(second_detail),
+ "data": _reasoning_carrier(second_detail),
},
{"type": "text", "text": "done"},
],
@@ -225,7 +273,9 @@ def test_reasoning_details_skip_neutral_tool_turn_boundary(open_router_provider)
)
body = open_router_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistants = [
@@ -250,7 +300,7 @@ def test_reasoning_details_preserve_redacted_only_assistant_after_tool(
"content": [
{
"type": "redacted_thinking",
- "data": json.dumps(first_detail),
+ "data": _reasoning_carrier(first_detail),
},
{
"type": "tool_use",
@@ -275,7 +325,7 @@ def test_reasoning_details_preserve_redacted_only_assistant_after_tool(
"content": [
{
"type": "redacted_thinking",
- "data": json.dumps(second_detail),
+ "data": _reasoning_carrier(second_detail),
}
],
},
@@ -286,7 +336,9 @@ def test_reasoning_details_preserve_redacted_only_assistant_after_tool(
)
body = open_router_provider._build_request_body(
- request, reasoning=reasoning_for(request)
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistants = [
@@ -319,14 +371,31 @@ async def test_stream_maps_reasoning_content_and_details(open_router_provider):
return_value=stream,
):
events = await collect_anthropic(
- open_router_provider.stream_response(make_request())
+ open_router_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
event_text = "".join(events)
parsed = parse_sse_text(event_text)
assert thinking_content(parsed) == "plan "
- assert "redacted_thinking" in event_text
- assert "opaque" in event_text
+ redacted_blocks = [
+ event.data["content_block"]
+ for event in parsed
+ if event.event == "content_block_start"
+ and event.data.get("content_block", {}).get("type") == "redacted_thinking"
+ ]
+ assert len(redacted_blocks) == 1
+ artifacts = decode_replay_envelope(
+ redacted_blocks[0]["data"],
+ attachment=ReplayAttachment.REASONING,
+ )
+ assert artifacts is not None
+ assert len(artifacts) == 1
+ assert artifacts[0].kind is ReplayArtifactKind.REASONING_DETAILS
+ assert isinstance(artifacts[0].payload, str)
+ assert json.loads(artifacts[0].payload) == redacted
+ assert artifacts[0].scope is not None
assert text_content(parsed) == "done"
assert stream.closed
diff --git a/tests/providers/test_openai_chat_output_cap.py b/tests/providers/test_openai_chat_output_cap.py
index 16032f3e..eb9aa2e6 100644
--- a/tests/providers/test_openai_chat_output_cap.py
+++ b/tests/providers/test_openai_chat_output_cap.py
@@ -16,7 +16,7 @@ from free_claude_code.providers.openai_chat.output_cap import (
clamp_output_tokens,
parse_output_token_cap,
)
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -241,11 +241,20 @@ def groq_provider():
@pytest.mark.asyncio
async def test_create_stream_clamps_and_learns_on_cap_rejection(groq_provider):
body = groq_provider._build_request_body(
- make_messages_request(
- "llama-3.3-70b-versatile",
- max_tokens=64000,
- thinking={"enabled": False},
- )
+ canonical_request(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ ),
+ provider_model=(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ ).model,
)
assert body["max_completion_tokens"] == 64000
model = body["model"]
@@ -281,11 +290,20 @@ async def test_create_stream_clamps_and_learns_on_cap_rejection(groq_provider):
@pytest.mark.asyncio
async def test_learned_cap_clamps_next_request_without_a_400(groq_provider):
body = groq_provider._build_request_body(
- make_messages_request(
- "llama-3.3-70b-versatile",
- max_tokens=64000,
- thinking={"enabled": False},
- )
+ canonical_request(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ ),
+ provider_model=(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ ).model,
)
model = body["model"]
groq_provider._model_output_caps[model] = 40960
@@ -307,11 +325,20 @@ async def test_learned_cap_clamps_next_request_without_a_400(groq_provider):
@pytest.mark.asyncio
async def test_unrelated_400_is_not_clamped_and_propagates(groq_provider):
body = groq_provider._build_request_body(
- make_messages_request(
- "llama-3.3-70b-versatile",
- max_tokens=100,
- thinking={"enabled": False},
- )
+ canonical_request(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=100,
+ thinking={"enabled": False},
+ )
+ ),
+ provider_model=(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=100,
+ thinking={"enabled": False},
+ )
+ ).model,
)
create = AsyncMock(side_effect=_BadRequest("messages: invalid role 'wizard'"))
@@ -332,11 +359,20 @@ async def test_unrelated_400_is_not_clamped_and_propagates(groq_provider):
@pytest.mark.asyncio
async def test_mixed_field_400_does_not_retry_or_poison_learned_cap(groq_provider):
body = groq_provider._build_request_body(
- make_messages_request(
- "llama-3.3-70b-versatile",
- max_tokens=64000,
- thinking={"enabled": False},
- )
+ canonical_request(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ ),
+ provider_model=(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ ).model,
)
error_body = {
"param": "temperature",
diff --git a/tests/providers/test_openai_chat_tool_names.py b/tests/providers/test_openai_chat_tool_names.py
index 5c4956fc..3f55e0d0 100644
--- a/tests/providers/test_openai_chat_tool_names.py
+++ b/tests/providers/test_openai_chat_tool_names.py
@@ -1,13 +1,15 @@
from copy import deepcopy
from typing import Any
-from free_claude_code.core.anthropic import ReasoningReplayMode
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
+from free_claude_code.providers.openai_chat.request_codec import ReasoningReplayMode
from free_claude_code.providers.openai_chat.request_policy import (
OpenAIChatRequestPolicy,
build_openai_chat_request_body,
)
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
+from tests.providers.request_factory import canonical_request
_POLICY = OpenAIChatRequestPolicy(
provider_name="TEST",
@@ -67,10 +69,14 @@ def _request(name: str, *, continued: bool = False) -> MessagesRequest:
def _body(request: MessagesRequest, *, postprocessors=()) -> dict[str, Any]:
+ canonical = canonical_request(request)
return build_openai_chat_request_body(
- request,
+ canonical,
+ provider_model=canonical.model,
reasoning=ReasoningPolicy.provider_default(),
policy=_POLICY,
+ tool_names=OpenAIToolNameCodec.from_request(canonical),
+ replay_scope=None,
postprocessors=postprocessors,
)
@@ -97,13 +103,13 @@ def test_chat_request_uses_one_alias_in_definition_choice_and_history() -> None:
assistant = next(message for message in messages if message["role"] == "assistant")
assert assistant["tool_calls"][0]["function"] == {
"name": alias,
- "arguments": '{"value": "x"}',
+ "arguments": '{"value":"x"}',
}
assert assistant["tool_calls"][0]["id"] == "call_1"
assert request.model_dump() == snapshot
-def test_chat_name_encoding_runs_after_provider_postprocessors() -> None:
+def test_provider_postprocessors_observe_final_upstream_tool_names() -> None:
original = "mcp__postprocessor_order__" + "x" * 80
request = _request(original)
observed: list[str] = []
@@ -113,8 +119,9 @@ def test_chat_name_encoding_runs_after_provider_postprocessors() -> None:
body = _body(request, postprocessors=(observe_names,))
- assert observed == [original]
- assert body["tools"][0]["function"]["name"] != original
+ alias = body["tools"][0]["function"]["name"]
+ assert alias != original
+ assert observed == [alias]
def test_chat_aliases_remain_stable_for_append_only_requests() -> None:
@@ -140,11 +147,21 @@ def test_chat_encoding_does_not_rewrite_unrelated_name_fields() -> None:
)
snapshot = deepcopy(request.extra_body)
+ canonical = canonical_request(request)
body = build_openai_chat_request_body(
- request,
+ canonical,
+ provider_model=canonical.model,
reasoning=ReasoningPolicy.provider_default(),
policy=policy,
+ tool_names=OpenAIToolNameCodec.from_request(canonical),
+ replay_scope=None,
)
assert body["extra_body"] == snapshot
- assert body["tools"][0]["function"]["name"] != original
+ tools = body["tools"]
+ assert isinstance(tools, list)
+ tool = tools[0]
+ assert isinstance(tool, dict)
+ function = tool["function"]
+ assert isinstance(function, dict)
+ assert function["name"] != original
diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.py
index 1218ec86..96b9a983 100644
--- a/tests/providers/test_openai_chat_usage.py
+++ b/tests/providers/test_openai_chat_usage.py
@@ -8,15 +8,15 @@ import openai
import pytest
from httpx2 import Request, Response
-from free_claude_code.core.anthropic import ReasoningReplayMode
-from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
+from free_claude_code.core.inference import InferenceRequest
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.admission import ProviderOperationKind
from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
+ ReasoningReplayMode,
)
from free_claude_code.providers.openai_chat.reasoning import NO_REASONING
from free_claude_code.providers.openai_chat.usage import (
@@ -26,7 +26,7 @@ from free_claude_code.providers.openai_chat.usage import (
usage_int,
)
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -54,11 +54,12 @@ class _UsageTestProvider(OpenAIChatProvider):
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict:
- return {"model": request.model, "messages": [{"role": "user", "content": "x"}]}
+ return {"model": provider_model, "messages": [{"role": "user", "content": "x"}]}
def _bad_request(message: str, body: object | None = None) -> openai.BadRequestError:
@@ -184,7 +185,11 @@ async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokens
with patch.object(provider._client.chat.completions, "create", create):
events = await collect_anthropic(
- provider.stream_response(request, input_tokens=7)
+ provider.stream_response(
+ canonical_request(request),
+ input_tokens=7,
+ provider_model=(request).model,
+ )
)
create.assert_awaited_once()
@@ -220,8 +225,9 @@ async def test_openai_chat_stream_keeps_response_model_separate_from_upstream_mo
with patch.object(provider._client.chat.completions, "create", create):
events = await collect_anthropic(
provider.stream_response(
- request,
+ canonical_request(request),
response_model="anthropic/test/upstream/model",
+ provider_model=(request).model,
)
)
diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.py
index b5a6db7b..58e7d50a 100644
--- a/tests/providers/test_openai_codex_provider.py
+++ b/tests/providers/test_openai_codex_provider.py
@@ -7,8 +7,8 @@ from unittest.mock import patch
import httpx
import pytest
-from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.core.anthropic import AnthropicEventPresenter
+from free_claude_code.core.anthropic.ingress import AnthropicIngressError
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import (
assert_anthropic_stream_contract,
@@ -27,6 +27,7 @@ from free_claude_code.providers.openai_codex.auth import (
)
from free_claude_code.providers.openai_codex.provider import OpenAICodexProvider
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import make_provider_config
@@ -206,11 +207,12 @@ async def test_provider_uses_subscription_headers_and_visible_model_catalog() ->
infos = await provider.list_model_infos()
body = await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
input_tokens=3,
request_id="req_test",
response_model="claude-opus-4",
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(_request()).model,
)
)
@@ -301,11 +303,23 @@ async def test_generation_close_failure_preserves_success_and_permit() -> None:
)
first = await asyncio.wait_for(
- _collect(provider.stream_response(_request(), response_model="claude-opus-4")),
+ _collect(
+ provider.stream_response(
+ canonical_request(_request()),
+ response_model="claude-opus-4",
+ provider_model=(_request()).model,
+ )
+ ),
timeout=1,
)
second = await asyncio.wait_for(
- _collect(provider.stream_response(_request(), response_model="claude-opus-4")),
+ _collect(
+ provider.stream_response(
+ canonical_request(_request()),
+ response_model="claude-opus-4",
+ provider_model=(_request()).model,
+ )
+ ),
timeout=1,
)
@@ -340,9 +354,10 @@ async def test_generation_close_failure_preserves_provider_failure() -> None:
with pytest.raises(ExecutionFailure) as exc_info:
await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_close_failure",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -377,15 +392,18 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> N
original_request = request.model_dump()
reasoning = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)
- provider.preflight_stream(request, reasoning=reasoning)
+ provider.preflight_stream(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
assert requests == []
body = await _collect(
provider.stream_response(
- request,
+ canonical_request(request),
request_id="req_client_controls",
response_model="claude-opus-4",
reasoning=reasoning,
+ provider_model=(request).model,
)
)
@@ -404,7 +422,6 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> N
await client.aclose()
@pytest.mark.parametrize(
("field", "value", "error_path"),
[
@@ -427,35 +444,19 @@ async def test_provider_accepts_claude_client_controls_before_upstream_io() -> N
),
],
)
-async def test_provider_preflight_rejects_unrepresentable_client_controls(
+def test_ingress_rejects_unrepresentable_client_controls(
field: str,
value: object,
error_path: str,
) -> None:
- requests: list[httpx.Request] = []
-
- def handler(request: httpx.Request) -> httpx.Response:
- requests.append(request)
- return httpx.Response(500, request=request)
-
- client = httpx.AsyncClient(
- base_url="https://chatgpt.com/backend-api/codex/",
- transport=httpx.MockTransport(handler),
- )
- provider = OpenAICodexProvider(
- _config(), auth=_FakeAuth(), admission=_admission(), client=client
- )
payload = {
"model": "gpt-test",
"messages": [{"role": "user", "content": "hello"}],
field: value,
}
- with pytest.raises(InvalidRequestError, match=error_path):
- provider.preflight_stream(MessagesRequest.model_validate(payload))
-
- assert requests == []
- await client.aclose()
+ with pytest.raises(AnthropicIngressError, match=error_path):
+ canonical_request(MessagesRequest.model_validate(payload))
@pytest.mark.asyncio
@@ -533,7 +534,11 @@ async def test_provider_round_trips_portable_tool_name_alias() -> None:
_config(), auth=_FakeAuth(), admission=_admission(), client=client
)
- body = await _collect(provider.stream_response(request))
+ body = await _collect(
+ provider.stream_response(
+ canonical_request(request), provider_model=(request).model
+ )
+ )
payload = payloads[0]
alias = payload["tools"][0]["name"]
@@ -589,9 +594,10 @@ async def test_early_truncated_attempt_is_retried_without_duplicate_output() ->
body = await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_retry",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -633,9 +639,10 @@ async def test_pre_stream_retry_discards_held_message_start() -> None:
body = await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_pre_stream",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -678,9 +685,10 @@ async def test_non_streaming_success_is_retried_then_reports_bounded_body() -> N
with pytest.raises(ExecutionFailure) as exc_info:
await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_non_stream",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -733,9 +741,10 @@ async def test_truncated_attempt_after_commit_is_not_retried_or_duplicated() ->
with pytest.raises(ExecutionFailure):
async for event in provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_committed",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
):
chunks.extend(presenter.present(event))
@@ -779,9 +788,10 @@ async def test_unauthorized_response_forces_one_auth_refresh() -> None:
body = await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_auth",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -893,9 +903,10 @@ async def test_auth_refresh_failure_does_not_repeat_rejected_provider_call() ->
with pytest.raises(ExecutionFailure, match="refresh interrupted") as exc_info:
await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_auth_transient",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -929,9 +940,10 @@ async def test_second_unauthorized_response_is_terminal_without_refresh_loop() -
with pytest.raises(ExecutionFailure) as exc_info:
await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_auth_terminal",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -967,9 +979,10 @@ async def test_final_attempt_unauthorized_preserves_the_provider_401() -> None:
with pytest.raises(ExecutionFailure) as exc_info:
await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_final_401",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
@@ -1019,9 +1032,10 @@ async def test_stream_failure_redacts_credentials_from_customer_diagnostic() ->
with pytest.raises(ExecutionFailure) as exc_info:
await _collect(
provider.stream_response(
- _request(),
+ canonical_request(_request()),
request_id="req_redaction",
response_model="claude-opus-4",
+ provider_model=(_request()).model,
)
)
diff --git a/tests/providers/test_openai_compat_5xx_retry.py b/tests/providers/test_openai_compat_5xx_retry.py
index 7db937d7..0ce6267f 100644
--- a/tests/providers/test_openai_compat_5xx_retry.py
+++ b/tests/providers/test_openai_compat_5xx_retry.py
@@ -11,7 +11,7 @@ from free_claude_code.config.nim import NimSettings
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -73,7 +73,9 @@ async def test_nim_stream_retries_on_openai_5xx_then_streams(status_code):
) as mock_create,
):
mock_create.side_effect = [_internal_5xx(status_code), mock_stream()]
- events = await collect_anthropic(provider.stream_response(req))
+ events = await collect_anthropic(
+ provider.stream_response(canonical_request(req), provider_model=(req).model)
+ )
assert mock_create.await_count == 2
assert any("Hi" in e for e in events)
@@ -117,7 +119,9 @@ async def test_nim_stream_retries_on_pre_stream_connection_error_then_streams():
) as mock_create,
):
mock_create.side_effect = [_connection_error(), mock_stream()]
- events = await collect_anthropic(provider.stream_response(req))
+ events = await collect_anthropic(
+ provider.stream_response(canonical_request(req), provider_model=(req).model)
+ )
assert mock_create.await_count == 2
assert any("Recovered" in e for e in events)
@@ -152,7 +156,13 @@ async def test_nim_stream_connection_error_exhausted_emits_cause_chain():
patch("free_claude_code.providers.openai_chat.provider.trace_event") as trace,
pytest.raises(ExecutionFailure) as exc_info,
):
- await collect_anthropic(provider.stream_response(req, request_id="req_conn"))
+ await collect_anthropic(
+ provider.stream_response(
+ canonical_request(req),
+ request_id="req_conn",
+ provider_model=(req).model,
+ )
+ )
assert mock_create.await_count == 5
error_traces = [
@@ -205,7 +215,11 @@ async def test_nim_stream_openai_5xx_exhausted_emits_user_message(
):
mock_create.side_effect = _internal_5xx(status_code)
with pytest.raises(ExecutionFailure) as exc_info:
- await collect_anthropic(provider.stream_response(req))
+ await collect_anthropic(
+ provider.stream_response(
+ canonical_request(req), provider_model=(req).model
+ )
+ )
assert mock_create.await_count == 5
assert expect_substr in exc_info.value.message.lower()
diff --git a/tests/providers/test_openai_responses_transport.py b/tests/providers/test_openai_responses_transport.py
index 364b1bba..19346514 100644
--- a/tests/providers/test_openai_responses_transport.py
+++ b/tests/providers/test_openai_responses_transport.py
@@ -20,6 +20,7 @@ from free_claude_code.core.anthropic.stream_contracts import (
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.providers.openai_responses import OpenAIResponsesTransport
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import REASONING_ON, immediate_admission
@@ -135,11 +136,12 @@ async def _collect(
) -> list[str]:
return await collect_anthropic(
transport.stream_response(
- request or _request(),
+ canonical_request(request or _request()),
input_tokens=11,
request_id="req_responses",
response_model="public-model",
reasoning=REASONING_ON,
+ provider_model=(request or _request()).model,
)
)
@@ -371,11 +373,12 @@ async def test_post_commit_truncation_is_not_replayed() -> None:
try:
with pytest.raises(ExecutionFailure):
async for event in _transport(client).stream_response(
- _request(),
+ canonical_request(_request()),
input_tokens=1,
request_id="req_committed",
response_model="public-model",
reasoning=REASONING_ON,
+ provider_model=(_request()).model,
):
chunks.extend(presenter.present(event))
finally:
@@ -429,6 +432,10 @@ async def test_preflight_rejects_fields_responses_cannot_represent() -> None:
try:
with pytest.raises(InvalidRequestError, match="stop_sequences"):
- transport.preflight_stream(request, reasoning=REASONING_ON)
+ transport.preflight_stream(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
finally:
await client.close()
diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.py
index 7d3a9355..bcc2b662 100644
--- a/tests/providers/test_opencode.py
+++ b/tests/providers/test_opencode.py
@@ -31,6 +31,7 @@ from free_claude_code.providers.opencode.catalog import (
parse_open_code_catalog,
)
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
capture_openai_chat_wire_body,
immediate_admission,
@@ -234,9 +235,10 @@ async def _collect(provider: OpenCodeProvider, model: str, **overrides: object)
return "".join(
await collect_anthropic(
provider.stream_response(
- _request(model, **overrides),
+ canonical_request(_request(model, **overrides)),
input_tokens=2,
request_id="req_opencode",
+ provider_model=(_request(model, **overrides)).model,
)
)
)
@@ -582,10 +584,18 @@ async def test_warm_preflight_rejects_unknown_and_route_specific_fields() -> Non
try:
await provider.list_model_infos()
with pytest.raises(InvalidRequestError, match="does not advertise"):
- provider.preflight_stream(_request("missing"))
+ provider.preflight_stream(
+ canonical_request(_request("missing")),
+ provider_model=(_request("missing")).model,
+ )
with pytest.raises(InvalidRequestError, match="stop_sequences"):
provider.preflight_stream(
- _request("responses-selector", stop_sequences=["done"])
+ canonical_request(
+ _request("responses-selector", stop_sequences=["done"])
+ ),
+ provider_model=(
+ _request("responses-selector", stop_sequences=["done"])
+ ).model,
)
finally:
await provider.cleanup()
@@ -660,7 +670,11 @@ def test_build_request_body_replays_tool_reasoning_natively(
}
)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assistant = body["messages"][0]
assert assistant["content"] == ""
@@ -717,7 +731,11 @@ async def test_tool_only_history_sends_empty_reasoning_content_on_wire(
}
)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
wire = await capture_openai_chat_wire_body(body)
assistant = wire["messages"][0]
diff --git a/tests/providers/test_poolside.py b/tests/providers/test_poolside.py
index 4c81fa4c..b03d074b 100644
--- a/tests/providers/test_poolside.py
+++ b/tests/providers/test_poolside.py
@@ -14,6 +14,7 @@ from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.json_types import JsonObject, JsonValue
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -60,8 +61,9 @@ def test_encodes_documented_chat_template_thinking_control(
enabled: bool,
) -> None:
body = poolside_provider._build_request_body(
- _request(extra_body={"top_k": 20}),
+ canonical_request(_request(extra_body={"top_k": 20})),
reasoning=reasoning,
+ provider_model=(_request(extra_body={"top_k": 20})).model,
)
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -75,8 +77,9 @@ def test_omits_thinking_control_for_poolside_default(
poolside_provider: OpenAIChatProvider,
) -> None:
body = poolside_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(_request()).model,
)
assert "extra_body" not in body
@@ -93,7 +96,11 @@ def test_rejects_caller_reasoning_override(
request = _request(extra_body={field: "caller-owned"})
with pytest.raises(InvalidRequestError, match="must not override reasoning"):
- poolside_provider._build_request_body(request, reasoning=REASONING_ON)
+ poolside_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
def test_replays_reasoning_content_with_tool_history(
@@ -129,8 +136,9 @@ def test_replays_reasoning_content_with_tool_history(
)
body = poolside_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
@@ -143,7 +151,7 @@ def test_replays_reasoning_content_with_tool_history(
"type": "function",
"function": {
"name": "read_file",
- "arguments": '{"path": "example.py"}',
+ "arguments": '{"path":"example.py"}',
},
}
],
@@ -166,8 +174,9 @@ async def test_thinking_control_reaches_wire_as_top_level_extension(
poolside_provider: OpenAIChatProvider,
) -> None:
body = poolside_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=REASONING_OFF,
+ provider_model=(_request()).model,
)
wire = await capture_openai_chat_wire_body(body)
diff --git a/tests/providers/test_preflight_contract.py b/tests/providers/test_preflight_contract.py
index 2dfe97dc..fb314678 100644
--- a/tests/providers/test_preflight_contract.py
+++ b/tests/providers/test_preflight_contract.py
@@ -6,24 +6,30 @@ import pytest
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.core.anthropic.models import Message, MessagesRequest
-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ InferenceStreamLedger,
+)
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.providers.base import BaseProvider
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import make_provider_config
class RecordingOpenAIProvider(OpenAIChatProvider):
def __init__(self) -> None:
- self.build_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []
+ self.build_calls: list[tuple[InferenceRequest, str, ReasoningPolicy]] = []
def _build_request_body(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> dict:
- self.build_calls.append((request, reasoning))
+ self.build_calls.append((request, provider_model, reasoning))
return {}
@@ -36,9 +42,10 @@ class ProviderWithoutPreflight(BaseProvider):
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
@@ -65,6 +72,12 @@ def test_provider_preflight_calls_builder_and_preserves_policy() -> None:
messages=[Message(role="user", content="hello")],
)
- provider.preflight_stream(request, reasoning=ReasoningPolicy.off())
+ provider.preflight_stream(
+ canonical_request(request),
+ reasoning=ReasoningPolicy.off(),
+ provider_model=(request).model,
+ )
- assert provider.build_calls == [(request, ReasoningPolicy.off())]
+ assert provider.build_calls == [
+ (canonical_request(request), request.model, ReasoningPolicy.off())
+ ]
diff --git a/tests/providers/test_provider_transport_logging.py b/tests/providers/test_provider_transport_logging.py
index 047f3ab2..775e86ed 100644
--- a/tests/providers/test_provider_transport_logging.py
+++ b/tests/providers/test_provider_transport_logging.py
@@ -10,7 +10,7 @@ import pytest
from free_claude_code.config.nim import NimSettings
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -42,7 +42,13 @@ async def test_stream_failure_default_logs_exclude_exception_text(caplog) -> Non
caplog.at_level(logging.ERROR),
pytest.raises(ExecutionFailure),
):
- [event async for event in provider.stream_response(make_messages_request())]
+ [
+ event
+ async for event in provider.stream_response(
+ canonical_request(make_messages_request()),
+ provider_model=(make_messages_request()).model,
+ )
+ ]
messages = " | ".join(record.getMessage() for record in caplog.records)
assert "SECRET_OPENAI_COMPAT" not in messages
@@ -66,7 +72,13 @@ async def test_stream_failure_default_logs_cause_types_only(caplog) -> None:
caplog.at_level(logging.ERROR),
pytest.raises(ExecutionFailure),
):
- [event async for event in provider.stream_response(make_messages_request())]
+ [
+ event
+ async for event in provider.stream_response(
+ canonical_request(make_messages_request()),
+ provider_model=(make_messages_request()).model,
+ )
+ ]
messages = " | ".join(record.getMessage() for record in caplog.records)
assert "SECRET_CAUSE_DETAIL" not in messages
@@ -89,7 +101,13 @@ async def test_stream_failure_verbose_traceback_redacts_credentials(caplog) -> N
caplog.at_level(logging.ERROR),
pytest.raises(ExecutionFailure),
):
- [event async for event in provider.stream_response(make_messages_request())]
+ [
+ event
+ async for event in provider.stream_response(
+ canonical_request(make_messages_request()),
+ provider_model=(make_messages_request()).model,
+ )
+ ]
messages = " | ".join(record.getMessage() for record in caplog.records)
assert "api_key=<redacted>" in messages
diff --git a/tests/providers/test_qwencloud.py b/tests/providers/test_qwencloud.py
index e6852b37..c8f7ab7c 100644
--- a/tests/providers/test_qwencloud.py
+++ b/tests/providers/test_qwencloud.py
@@ -13,6 +13,7 @@ from free_claude_code.config.provider_catalog import QWENCLOUD_DEFAULT_BASE
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -82,8 +83,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images(
)
body = qwencloud_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "qwen3.7-plus"
@@ -111,7 +113,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(
}
)
- body = qwencloud_provider._build_request_body(request, reasoning=reasoning)
+ body = qwencloud_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
extra_body = body.get("extra_body", {})
for field in (
@@ -145,8 +149,9 @@ def test_build_request_body_replays_prior_reasoning_content(
)
body = qwencloud_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
diff --git a/tests/providers/test_qwencloud_coding.py b/tests/providers/test_qwencloud_coding.py
index 167e358f..db9810b8 100644
--- a/tests/providers/test_qwencloud_coding.py
+++ b/tests/providers/test_qwencloud_coding.py
@@ -11,6 +11,7 @@ from free_claude_code.config.provider_catalog import QWENCLOUD_CODING_DEFAULT_BA
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -80,8 +81,9 @@ def test_build_request_body_preserves_tools_and_images_without_inventing_a_cap(
)
body = qwencloud_coding_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "qwen3.7-plus"
@@ -110,8 +112,9 @@ def test_build_request_body_preserves_explicit_client_cap(
)
body = qwencloud_coding_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["max_tokens"] == 321
@@ -136,7 +139,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(
}
)
- body = qwencloud_coding_provider._build_request_body(request, reasoning=reasoning)
+ body = qwencloud_coding_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
extra_body = body.get("extra_body", {})
for field in (
@@ -173,8 +178,9 @@ def test_build_request_body_replays_prior_reasoning_content(
)
body = qwencloud_coding_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
diff --git a/tests/providers/test_sambanova.py b/tests/providers/test_sambanova.py
index 494170e8..6d1d2ad5 100644
--- a/tests/providers/test_sambanova.py
+++ b/tests/providers/test_sambanova.py
@@ -8,7 +8,7 @@ import pytest
from free_claude_code.config.provider_catalog import SAMBANOVA_DEFAULT_BASE
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -67,7 +67,9 @@ def test_init_strips_trailing_slash(sambanova_config):
def test_build_request_body_basic(sambanova_provider):
"""Basic request body conversion attaches system message and keeps max_tokens."""
- body = sambanova_provider._build_request_body(make_request())
+ body = sambanova_provider._build_request_body(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
assert body["model"] == "Meta-Llama-3.3-70B-Instruct"
assert body["messages"][0]["role"] == "system"
@@ -78,7 +80,9 @@ def test_build_request_body_basic(sambanova_provider):
def test_build_request_body_preserves_caller_extra_body(sambanova_provider):
req = make_request(extra_body={"metadata": {"user": "u1"}})
- body = sambanova_provider._build_request_body(req)
+ body = sambanova_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
eb = body.get("extra_body")
assert isinstance(eb, dict)
@@ -99,8 +103,9 @@ def test_build_request_body_uses_only_documented_reasoning_efforts(
sambanova_provider, reasoning, expected
):
body = sambanova_provider._build_request_body(
- make_request(),
+ canonical_request(make_request()),
reasoning=reasoning,
+ provider_model=(make_request()).model,
)
assert body.get("reasoning_effort") == expected
@@ -131,7 +136,9 @@ async def test_stream_response_text(sambanova_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- sambanova_provider.stream_response(make_request())
+ sambanova_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
@@ -166,7 +173,9 @@ async def test_stream_response_tool_call(sambanova_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- sambanova_provider.stream_response(make_request())
+ sambanova_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
@@ -202,7 +211,9 @@ async def test_stream_response_reasoning_content(sambanova_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- sambanova_provider.stream_response(make_request())
+ sambanova_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
diff --git a/tests/providers/test_siliconflow.py b/tests/providers/test_siliconflow.py
index 7ae76f90..17141566 100644
--- a/tests/providers/test_siliconflow.py
+++ b/tests/providers/test_siliconflow.py
@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -94,8 +95,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images(
)
body = siliconflow_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(request).model,
)
assert body["model"] == _MODEL
@@ -126,7 +128,11 @@ def test_build_request_body_omits_model_specific_thinking_controls(
siliconflow_provider: OpenAIChatProvider,
reasoning: ReasoningPolicy,
) -> None:
- body = siliconflow_provider._build_request_body(_request(), reasoning=reasoning)
+ body = siliconflow_provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=reasoning,
+ provider_model=(_request()).model,
+ )
assert "extra_body" not in body
@@ -137,8 +143,9 @@ def test_build_request_body_preserves_unrelated_extra_body(
request = _request(extra_body={"min_p": 0.05})
body = siliconflow_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(request).model,
)
assert body["extra_body"] == {
@@ -154,7 +161,11 @@ def test_build_request_body_rejects_caller_thinking_override(
request = _request(extra_body={field: "caller-owned"})
with pytest.raises(InvalidRequestError, match="must not override reasoning"):
- siliconflow_provider._build_request_body(request, reasoning=REASONING_ON)
+ siliconflow_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
def test_build_request_body_replays_reasoning_content_verbatim(
@@ -175,8 +186,9 @@ def test_build_request_body_replays_reasoning_content_verbatim(
)
body = siliconflow_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.py
index 46c944e3..29c64c98 100644
--- a/tests/providers/test_streaming_errors.py
+++ b/tests/providers/test_streaming_errors.py
@@ -12,18 +12,15 @@ import openai
import pytest
from free_claude_code.config.nim import NimSettings
-from free_claude_code.core.anthropic import AnthropicEventPresenter, OpenAIToolNameCodec
+from free_claude_code.core.anthropic import AnthropicEventPresenter
from free_claude_code.core.anthropic.stream_contracts import (
parse_sse_text,
)
-from free_claude_code.core.anthropic.streaming import (
- make_response_recovery_body,
- make_text_recovery_body,
-)
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.core.inference import (
InferenceEvent,
InferenceStreamLedger,
+ ReplayCompatibilityScope,
ResponseStarted,
)
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
@@ -35,14 +32,19 @@ from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.openai_chat.provider import (
_OpenAIChatStreamRunner,
)
+from free_claude_code.providers.openai_chat.recovery import (
+ make_response_recovery_body,
+ make_text_recovery_body,
+)
from free_claude_code.providers.openai_chat.tool_calls import (
OpenAIToolCallAssembler,
OpenAIToolCallCollector,
has_generated_output,
iter_heuristic_tool_use_events,
)
+from free_claude_code.providers.openai_compat import OpenAIToolNameCodec
from free_claude_code.providers.stream_recovery import TruncatedProviderStreamError
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -130,7 +132,8 @@ def _make_provider():
def _make_tool_assembler(provider: NvidiaNimProvider) -> OpenAIToolCallAssembler:
return OpenAIToolCallAssembler(
- record_extra_content=provider._record_tool_call_extra_content
+ record_extra_content=provider._record_tool_call_extra_content,
+ replay_scope=ReplayCompatibilityScope("test-chat-route"),
)
@@ -157,12 +160,14 @@ def _make_stream_runner(
request=None,
request_id: str | None = None,
) -> _OpenAIChatStreamRunner:
+ effective_request = request or _make_request()
return _OpenAIChatStreamRunner(
provider,
- request=request or _make_request(),
+ request=effective_request,
+ provider_model=effective_request.model,
input_tokens=0,
request_id=request_id,
- response_model=None,
+ response_model=effective_request.model,
reasoning=DEFAULT_REASONING_POLICY,
)
@@ -217,14 +222,21 @@ async def _collect_stream(
"""Collect all SSE events from a stream."""
presenter = AnthropicEventPresenter()
output: list[str] = []
- async for event in provider.stream_response(request, reasoning=reasoning):
+ async for event in provider.stream_response(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ ):
output.extend(presenter.present(event))
return output
async def _collect_stream_error(provider, request, **kwargs) -> ExecutionFailure:
with pytest.raises(ExecutionFailure) as exc_info:
- [e async for e in provider.stream_response(request, **kwargs)]
+ [
+ e
+ async for e in provider.stream_response(
+ canonical_request(request), **kwargs, provider_model=(request).model
+ )
+ ]
return exc_info.value
@@ -234,7 +246,9 @@ async def _collect_stream_and_error(
events: list[str] = []
presenter = AnthropicEventPresenter()
with pytest.raises(ExecutionFailure) as exc_info:
- async for event in provider.stream_response(request, **kwargs):
+ async for event in provider.stream_response(
+ canonical_request(request), **kwargs, provider_model=(request).model
+ ):
events.extend(presenter.present(event))
return events, exc_info.value
@@ -1936,7 +1950,7 @@ class TestProcessToolCall:
)
def test_tool_name_restores_before_nim_argument_alias_lookup(self):
- """Generic name decoding composes with original-name NIM arg metadata."""
+ """Wire-name argument metadata composes with canonical identity decoding."""
provider = _make_provider()
original = "mcp__nim_argument_composition__" + "x" * 70
request = _make_request(
@@ -1967,7 +1981,9 @@ class TestProcessToolCall:
sse,
tool_names=codec,
tool_name_buffers={},
- tool_argument_aliases={original: {"_fcc_arg_type": "type"}},
+ tool_argument_aliases={
+ codec.encode(original): {"_fcc_arg_type": "type"}
+ },
tool_argument_alias_buffers={},
)
)
@@ -2082,7 +2098,7 @@ class TestProcessToolCall:
assert buffers == {}
def test_buffered_collector_decodes_before_schema_validation(self):
- """Recovery validates the original tool identity, not its wire alias."""
+ """Recovery validates canonically while preserving its upstream wire name."""
original = "mcp__recovery_output__" + "x" * 70
request = _make_request(
tools=[{"name": original, "input_schema": {"type": "object"}}]
@@ -2100,7 +2116,7 @@ class TestProcessToolCall:
calls = collector.completed_calls(request, tool_names=codec)
assert calls is not None
- assert calls[0]["function"]["name"] == original
+ assert calls[0]["function"]["name"] == codec.encode(original)
def test_heuristic_tool_call_restores_original_name(self):
"""Complete heuristic calls share the same outbound name contract."""
@@ -2146,9 +2162,10 @@ class TestProcessToolCall:
"id": "call_split",
"function": {"name": None, "arguments": "{}"},
}
- events1 = list(_make_tool_assembler(provider).process_tool_call(t1, sse))
- events2 = list(_make_tool_assembler(provider).process_tool_call(t2, sse))
- events3 = list(_make_tool_assembler(provider).process_tool_call(t3, sse))
+ assembler = _make_tool_assembler(provider)
+ events1 = list(assembler.process_tool_call(t1, sse))
+ events2 = list(assembler.process_tool_call(t2, sse))
+ events3 = list(assembler.process_tool_call(t3, sse))
combined = _wire(events1 + events2 + events3)
assert "call_split" in combined
assert "Grep" in combined
@@ -2168,8 +2185,9 @@ class TestProcessToolCall:
"id": "call_buf",
"function": {"name": "Read", "arguments": "1}"},
}
- events1 = list(_make_tool_assembler(provider).process_tool_call(t1, sse))
- events2 = list(_make_tool_assembler(provider).process_tool_call(t2, sse))
+ assembler = _make_tool_assembler(provider)
+ events1 = list(assembler.process_tool_call(t1, sse))
+ events2 = list(assembler.process_tool_call(t2, sse))
assert events1 == []
combined = _wire(events1 + events2)
assert "Read" in combined
@@ -2219,11 +2237,12 @@ class TestProcessToolCall:
"function": {"name": None, "arguments": ' "prompt": "test"}'},
}
- events1 = list(_make_tool_assembler(provider).process_tool_call(tc1, sse))
+ assembler = _make_tool_assembler(provider)
+ events1 = list(assembler.process_tool_call(tc1, sse))
assert len(events1) > 0
assert "false" not in _wire(events1).lower()
- events2 = list(_make_tool_assembler(provider).process_tool_call(tc2, sse))
+ events2 = list(assembler.process_tool_call(tc2, sse))
event_text = _wire(events1 + events2)
assert "false" in event_text.lower()
@@ -2236,11 +2255,12 @@ class TestProcessToolCall:
"id": "call_task2",
"function": {"name": "Task", "arguments": "not json"},
}
- events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))
+ assembler = _make_tool_assembler(provider)
+ events = list(assembler.process_tool_call(tc, sse))
assert len(events) > 0
with caplog.at_level("WARNING"):
- flushed = list(_make_tool_assembler(provider).flush_task_arg_buffers(sse))
+ flushed = list(assembler.flush_task_arg_buffers(sse))
assert len(flushed) > 0
assert "{}" in _wire(events + flushed)
assert any("Task args invalid JSON" in r.message for r in caplog.records)
@@ -2385,9 +2405,10 @@ class TestStreamChunkEdgeCases:
"function": {"name": None, "arguments": " never valid }"},
}
- events1 = list(_make_tool_assembler(provider).process_tool_call(tc1, sse))
- events2 = list(_make_tool_assembler(provider).process_tool_call(tc2, sse))
- flushed = list(_make_tool_assembler(provider).flush_task_arg_buffers(sse))
+ assembler = _make_tool_assembler(provider)
+ events1 = list(assembler.process_tool_call(tc1, sse))
+ events2 = list(assembler.process_tool_call(tc2, sse))
+ flushed = list(assembler.flush_task_arg_buffers(sse))
event_text = _wire(events1 + events2 + flushed)
assert "tool_use" in event_text
diff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.py
index bb49fbce..1c93581b 100644
--- a/tests/providers/test_subagent_interception.py
+++ b/tests/providers/test_subagent_interception.py
@@ -5,7 +5,10 @@ import pytest
from free_claude_code.config.nim import NimSettings
from free_claude_code.config.provider_catalog import NVIDIA_NIM_DEFAULT_BASE
-from free_claude_code.core.inference import InferenceBlockLedger
+from free_claude_code.core.inference import (
+ InferenceBlockLedger,
+ ReplayCompatibilityScope,
+)
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.openai_chat.tool_calls import (
OpenAIToolCallAssembler,
@@ -50,7 +53,8 @@ async def test_task_tool_interception():
}
tool_calls = OpenAIToolCallAssembler(
- record_extra_content=provider._record_tool_call_extra_content
+ record_extra_content=provider._record_tool_call_extra_content,
+ replay_scope=ReplayCompatibilityScope("test-chat-route"),
)
# Call the assembler (consume generator to trigger side effects)
diff --git a/tests/providers/test_together.py b/tests/providers/test_together.py
index e5012b76..05be9cfc 100644
--- a/tests/providers/test_together.py
+++ b/tests/providers/test_together.py
@@ -14,6 +14,7 @@ from free_claude_code.config.provider_catalog import TOGETHER_DEFAULT_BASE
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -83,8 +84,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images(
)
body = together_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "zai-org/GLM-5.2"
@@ -112,7 +114,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(
}
)
- body = together_provider._build_request_body(request, reasoning=reasoning)
+ body = together_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
extra_body = body.get("extra_body", {})
for field in ("reasoning", "reasoning_effort", "chat_template_kwargs"):
@@ -141,8 +145,9 @@ def test_build_request_body_replays_documented_reasoning_field(
)
body = together_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
diff --git a/tests/providers/test_vercel.py b/tests/providers/test_vercel.py
index 6f6ffd27..ec2eba08 100644
--- a/tests/providers/test_vercel.py
+++ b/tests/providers/test_vercel.py
@@ -7,7 +7,7 @@ import pytest
from free_claude_code.config.provider_catalog import VERCEL_AI_GATEWAY_DEFAULT_BASE
from tests.inference_support import collect_anthropic
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -80,7 +80,9 @@ def test_build_request_body_keeps_max_tokens(vercel_provider):
"max_tokens": 42,
}
- body = vercel_provider._build_request_body(make_request())
+ body = vercel_provider._build_request_body(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
assert body["messages"][0].get("name") == "alice"
assert body["max_tokens"] == 42
@@ -90,7 +92,9 @@ def test_build_request_body_keeps_max_tokens(vercel_provider):
def test_build_request_body_preserves_caller_extra_body(vercel_provider):
req = make_request(extra_body={"providerOptions": {"openai": {"reasoning": "low"}}})
- body = vercel_provider._build_request_body(req)
+ body = vercel_provider._build_request_body(
+ canonical_request(req), provider_model=(req).model
+ )
assert body["extra_body"] == {"providerOptions": {"openai": {"reasoning": "low"}}}
@@ -119,7 +123,9 @@ async def test_stream_response_text(vercel_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- vercel_provider.stream_response(make_request())
+ vercel_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
@@ -151,7 +157,9 @@ async def test_stream_response_reasoning_content(vercel_provider):
mock_create.return_value = mock_stream()
events = await collect_anthropic(
- vercel_provider.stream_response(make_request())
+ vercel_provider.stream_response(
+ canonical_request(make_request()), provider_model=(make_request()).model
+ )
)
assert any(
diff --git a/tests/providers/test_vertex.py b/tests/providers/test_vertex.py
index 60a30d07..7b2ac29b 100644
--- a/tests/providers/test_vertex.py
+++ b/tests/providers/test_vertex.py
@@ -26,7 +26,7 @@ from free_claude_code.providers.vertex.endpoint import (
vertex_service_endpoint,
)
from free_claude_code.providers.vertex.models import extract_vertex_model_page
-from tests.providers.request_factory import make_messages_request
+from tests.providers.request_factory import canonical_request, make_messages_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -247,7 +247,11 @@ def test_vertex_request_uses_google_thinking_budget_without_named_effort() -> No
thinking={"type": "enabled", "budget_tokens": 2048},
)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["model"] == "google/gemini-3.5-flash"
assert "reasoning_effort" not in body
@@ -264,7 +268,11 @@ def test_vertex_request_maps_reasoning_off_to_zero_budget() -> None:
thinking={"type": "disabled"},
)
- body = provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["extra_body"]["extra_body"]["google"]["thinking_config"] == {
"thinking_budget": 0,
@@ -302,8 +310,9 @@ def test_vertex_reasoning_has_one_google_wire_owner(
provider = _provider()
body = provider._build_request_body(
- make_messages_request("google/gemini", thinking=None),
+ canonical_request(make_messages_request("google/gemini", thinking=None)),
reasoning=reasoning,
+ provider_model=(make_messages_request("google/gemini", thinking=None)).model,
)
wire = _simulate_openai_sdk_wire_json(body)
@@ -329,8 +338,9 @@ def test_vertex_preserves_caller_thinking_config_only_for_provider_default() ->
)
body = provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(request).model,
)
wire = _simulate_openai_sdk_wire_json(body)
@@ -352,8 +362,9 @@ def test_vertex_rejects_caller_thinking_config_with_fcc_reasoning_control() -> N
with pytest.raises(InvalidRequestError, match="thinking_config"):
provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.on(effort=ReasoningEffort.HIGH),
+ provider_model=(request).model,
)
diff --git a/tests/providers/test_wafer.py b/tests/providers/test_wafer.py
index afe7fd98..b0eb7ae8 100644
--- a/tests/providers/test_wafer.py
+++ b/tests/providers/test_wafer.py
@@ -11,6 +11,7 @@ from free_claude_code.core.anthropic.models import Message, MessagesRequest, Too
from free_claude_code.providers.openai_chat import (
OpenAIChatProvider,
)
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
immediate_admission,
@@ -66,7 +67,11 @@ def test_build_request_body_openai_shape_and_defaults(wafer_provider):
}
)
- body = wafer_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = wafer_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["model"] == "DeepSeek-V4-Pro"
assert body["messages"][0] == {"role": "user", "content": "Hello"}
@@ -83,7 +88,11 @@ def test_build_request_body_honors_effective_no_thinking(wafer_provider):
}
)
- body = wafer_provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = wafer_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["reasoning_effort"] == "none"
@@ -97,7 +106,11 @@ def test_build_request_body_preserves_request_disabled_thinking(wafer_provider):
}
)
- body = wafer_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = wafer_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["reasoning_effort"] == "none"
@@ -112,7 +125,11 @@ def test_build_request_body_uses_resolved_policy_without_inspecting_model(
}
)
- body = wafer_provider._build_request_body(request, reasoning=REASONING_OFF)
+ body = wafer_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_OFF,
+ provider_model=(request).model,
+ )
assert body["reasoning_effort"] == "none"
diff --git a/tests/providers/test_wandb.py b/tests/providers/test_wandb.py
index 33a5b26c..fe7fdaab 100644
--- a/tests/providers/test_wandb.py
+++ b/tests/providers/test_wandb.py
@@ -15,6 +15,7 @@ from free_claude_code.config.provider_catalog import WANDB_INFERENCE_DEFAULT_BAS
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -64,7 +65,11 @@ def test_build_request_body_encodes_documented_thinking_control(
reasoning: ReasoningPolicy,
enabled: bool,
) -> None:
- body = wandb_provider._build_request_body(_request(), reasoning=reasoning)
+ body = wandb_provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=reasoning,
+ provider_model=(_request()).model,
+ )
assert body["extra_body"] == {"chat_template_kwargs": {"enable_thinking": enabled}}
@@ -73,8 +78,9 @@ def test_build_request_body_uses_provider_defaults_when_reasoning_is_inherited(
wandb_provider: OpenAIChatProvider,
) -> None:
body = wandb_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(_request()).model,
)
assert "extra_body" not in body
@@ -113,8 +119,9 @@ def test_build_request_body_drops_undocumented_reasoning_replay_but_keeps_tools(
)
body = wandb_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
@@ -126,7 +133,7 @@ def test_build_request_body_drops_undocumented_reasoning_replay_but_keeps_tools(
"type": "function",
"function": {
"name": "read_file",
- "arguments": '{"path": "example.py"}',
+ "arguments": '{"path":"example.py"}',
},
}
],
@@ -155,14 +162,22 @@ def test_build_request_body_rejects_caller_reasoning_override(
request = _request(extra_body={field: "caller-owned"})
with pytest.raises(InvalidRequestError, match="must not override reasoning"):
- wandb_provider._build_request_body(request, reasoning=REASONING_ON)
+ wandb_provider._build_request_body(
+ canonical_request(request),
+ reasoning=REASONING_ON,
+ provider_model=(request).model,
+ )
@pytest.mark.asyncio
async def test_wire_body_uses_current_output_limit_and_thinking_fields(
wandb_provider: OpenAIChatProvider,
) -> None:
- body = wandb_provider._build_request_body(_request(), reasoning=REASONING_ON)
+ body = wandb_provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=REASONING_ON,
+ provider_model=(_request()).model,
+ )
wire_body = await capture_openai_chat_wire_body(body)
diff --git a/tests/providers/test_xai.py b/tests/providers/test_xai.py
index fe3caabd..b59a3af9 100644
--- a/tests/providers/test_xai.py
+++ b/tests/providers/test_xai.py
@@ -14,6 +14,7 @@ from free_claude_code.config.provider_catalog import XAI_DEFAULT_BASE
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
@@ -81,8 +82,9 @@ def test_build_request_body_preserves_common_chat_tools_and_images(
)
body = xai_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "grok-4.5"
@@ -109,7 +111,9 @@ def test_build_request_body_does_not_invent_catalog_wide_reasoning_control(
}
)
- body = xai_provider._build_request_body(request, reasoning=reasoning)
+ body = xai_provider._build_request_body(
+ canonical_request(request), reasoning=reasoning, provider_model=(request).model
+ )
assert "reasoning_effort" not in body
assert "reasoning" not in body.get("extra_body", {})
@@ -136,8 +140,9 @@ def test_build_request_body_replays_prior_reasoning_content(
)
body = xai_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["messages"][1] == {
diff --git a/tests/providers/test_zai.py b/tests/providers/test_zai.py
index 8cc4d0ea..8b0c5975 100644
--- a/tests/providers/test_zai.py
+++ b/tests/providers/test_zai.py
@@ -12,6 +12,7 @@ from free_claude_code.config.provider_catalog import (
)
from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -60,7 +61,11 @@ def test_build_request_body_openai_chat(zai_provider):
}
)
- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = zai_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["model"] == "glm-5.2"
assert body["max_tokens"] == 100
@@ -77,7 +82,11 @@ def test_build_request_body_default_max_tokens(zai_provider):
messages=[Message(role="user", content="x")],
)
- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = zai_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -92,7 +101,11 @@ def test_build_request_body_rejects_caller_extra_body(zai_provider):
)
with pytest.raises(InvalidRequestError, match=r"Z\.ai Chat Completions"):
- zai_provider._build_request_body(request, reasoning=reasoning_for(request))
+ zai_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
def test_build_request_body_disables_zai_thinking(zai_provider):
@@ -104,7 +117,11 @@ def test_build_request_body_disables_zai_thinking(zai_provider):
}
)
- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = zai_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["extra_body"]["thinking"] == {"type": "disabled"}
@@ -123,7 +140,11 @@ def test_build_request_body_replays_prior_reasoning_content(zai_provider):
}
)
- body = zai_provider._build_request_body(request, reasoning=reasoning_for(request))
+ body = zai_provider._build_request_body(
+ canonical_request(request),
+ reasoning=reasoning_for(request),
+ provider_model=(request).model,
+ )
assert body["messages"][0]["reasoning_content"] == "prior"
assert "extra_body" not in body
diff --git a/tests/providers/test_zenmux.py b/tests/providers/test_zenmux.py
index ccbd42ab..9a686590 100644
--- a/tests/providers/test_zenmux.py
+++ b/tests/providers/test_zenmux.py
@@ -1,6 +1,7 @@
"""Tests for the ZenMux OpenAI-chat provider profile."""
import json
+from collections.abc import Mapping
from types import SimpleNamespace
from typing import Any
from unittest.mock import AsyncMock, patch
@@ -18,10 +19,23 @@ from free_claude_code.core.anthropic.stream_contracts import (
text_content,
thinking_content,
)
+from free_claude_code.core.inference import (
+ ReplayArtifact,
+ ReplayArtifactKind,
+ ReplayArtifactOrigin,
+ ReplayAttachment,
+)
+from free_claude_code.core.json_types import JsonValue
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
+from free_claude_code.core.replay_envelope import (
+ decode_replay_envelope,
+ encode_replay_envelope,
+)
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
+from free_claude_code.providers.openai_compat import openai_replay_scope
from tests.inference_support import collect_anthropic
+from tests.providers.request_factory import canonical_request
from tests.providers.support import (
immediate_admission,
make_provider_config,
@@ -53,6 +67,24 @@ def _request(**overrides: Any) -> MessagesRequest:
return MessagesRequest.model_validate(payload)
+def _reasoning_carrier(detail: Mapping[str, JsonValue]) -> str:
+ return encode_replay_envelope(
+ (
+ ReplayArtifact(
+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,
+ kind=ReplayArtifactKind.REASONING_DETAILS,
+ attachment=ReplayAttachment.REASONING,
+ scope=openai_replay_scope(
+ "ZENMUX",
+ "deepseek/deepseek-v4-flash-free",
+ replay_format="chat-completions",
+ ),
+ payload=detail,
+ ),
+ )
+ )
+
+
class AsyncStream:
def __init__(self, chunks: list[Any]) -> None:
self._chunks = chunks
@@ -131,8 +163,9 @@ def test_build_request_body_uses_supported_output_field_tools_and_images(
)
body = zenmux_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assert body["model"] == "deepseek/deepseek-v4-flash-free"
@@ -163,8 +196,9 @@ def test_build_request_body_maps_reasoning_effort_to_documented_vocabulary(
expected: str,
) -> None:
body = zenmux_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.on(effort=effort),
+ provider_model=(_request()).model,
)
assert body["extra_body"]["reasoning"] == {"effort": expected}
@@ -183,7 +217,11 @@ def test_build_request_body_maps_reasoning_control_and_budget(
reasoning: ReasoningPolicy,
expected: dict[str, Any],
) -> None:
- body = zenmux_provider._build_request_body(_request(), reasoning=reasoning)
+ body = zenmux_provider._build_request_body(
+ canonical_request(_request()),
+ reasoning=reasoning,
+ provider_model=(_request()).model,
+ )
assert body["extra_body"]["reasoning"] == expected
@@ -192,8 +230,9 @@ def test_build_request_body_leaves_reasoning_to_provider_by_default(
zenmux_provider: OpenAIChatProvider,
) -> None:
body = zenmux_provider._build_request_body(
- _request(),
+ canonical_request(_request()),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(_request()).model,
)
assert "reasoning" not in body.get("extra_body", {})
@@ -205,8 +244,9 @@ def test_build_request_body_preserves_unrelated_gateway_options(
request = _request(extra_body={"provider": {"fallback": "true"}})
body = zenmux_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.provider_default(),
+ provider_model=(request).model,
)
assert body["extra_body"] == {"provider": {"fallback": "true"}}
@@ -224,8 +264,9 @@ def test_build_request_body_rejects_caller_canonical_override(
with pytest.raises(InvalidRequestError, match="must not override canonical"):
zenmux_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=ReasoningPolicy.on(),
+ provider_model=(request).model,
)
@@ -246,7 +287,7 @@ def test_build_request_body_replays_reasoning_and_signed_details_unchanged(
"role": "assistant",
"content": [
{"type": "thinking", "thinking": "Need a tool."},
- {"type": "redacted_thinking", "data": json.dumps(detail)},
+ {"type": "redacted_thinking", "data": _reasoning_carrier(detail)},
{
"type": "tool_use",
"id": "call_read",
@@ -269,8 +310,9 @@ def test_build_request_body_replays_reasoning_and_signed_details_unchanged(
)
body = zenmux_provider._build_request_body(
- request,
+ canonical_request(request),
reasoning=reasoning_for(request),
+ provider_model=(request).model,
)
assistant = next(
@@ -334,7 +376,11 @@ async def test_stream_preserves_signed_details_without_duplicating_reasoning(
return_value=stream,
):
event_text = "".join(
- await collect_anthropic(zenmux_provider.stream_response(_request()))
+ await collect_anthropic(
+ zenmux_provider.stream_response(
+ canonical_request(_request()), provider_model=(_request()).model
+ )
+ )
)
events = parse_sse_text(event_text)
@@ -347,7 +393,16 @@ async def test_stream_preserves_signed_details_without_duplicating_reasoning(
and event.data.get("content_block", {}).get("type") == "redacted_thinking"
]
assert len(redacted_blocks) == 1
- assert json.loads(redacted_blocks[0]["data"]) == detail
+ artifacts = decode_replay_envelope(
+ redacted_blocks[0]["data"],
+ attachment=ReplayAttachment.REASONING,
+ )
+ assert artifacts is not None
+ assert len(artifacts) == 1
+ assert artifacts[0].kind is ReplayArtifactKind.REASONING_DETAILS
+ assert isinstance(artifacts[0].payload, str)
+ assert json.loads(artifacts[0].payload) == detail
+ assert artifacts[0].scope is not None
assert stream.closed
diff --git a/tests/runtime/test_application_runtime.py b/tests/runtime/test_application_runtime.py
index e493e50e..910f7758 100644
--- a/tests/runtime/test_application_runtime.py
+++ b/tests/runtime/test_application_runtime.py
@@ -15,8 +15,11 @@ from free_claude_code.application.errors import ApplicationUnavailableError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.admin.persistence import PreparedAdminUpdate
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedger
+from free_claude_code.core.inference import (
+ InferenceEvent,
+ InferenceRequest,
+ InferenceStreamLedger,
+)
from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicy
from free_claude_code.messaging.command_context import StopOutcome
from free_claude_code.messaging.platforms.ports import (
@@ -61,8 +64,9 @@ class AdminModelProvider(BaseProvider):
def preflight_stream(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
*,
+ provider_model: str,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
) -> None:
return None
@@ -77,9 +81,10 @@ class AdminModelProvider(BaseProvider):
async def stream_response(
self,
- request: MessagesRequest,
+ request: InferenceRequest,
input_tokens: int = 0,
*,
+ provider_model: str,
request_id: str | None = None,
response_model: str | None = None,
reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,
diff --git a/uv.lock b/uv.lock
index 10c2eeec..32b177d4 100644
--- a/uv.lock
+++ b/uv.lock
@@ -607,7 +607,7 @@ wheels = [
[[package]]
name = "free-claude-code"
-version = "5.14.2"
+version = "5.14.3"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },