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

Move protocol models to their protocol owners (#1044)

Ali Khokhar4a0a0360de6f
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 159eb262..bac39ef6 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -46,15 +46,16 @@ flowchart LR
The installable wheel packages are declared in [pyproject.toml](pyproject.toml):
- [src/free_claude_code/api/](src/free_claude_code/api/) is the HTTP adapter. It owns the FastAPI app, routes, API product
- handlers, protocol serialization, local optimizations, and narrow
- consumer-owned runtime ports.
+ handlers, local optimizations, model-catalog responses, and narrow
+ consumer-owned runtime ports. It consumes protocol types instead of defining
+ them.
- [src/free_claude_code/cli/](src/free_claude_code/cli/) owns console entrypoints, client CLI launchers, process/session
management, and client adapter contracts.
- [src/free_claude_code/config/](src/free_claude_code/config/) owns settings, provider metadata, filesystem paths,
logging setup, constants, and provider ID catalogs.
-- [src/free_claude_code/core/](src/free_claude_code/core/) owns provider-neutral protocol logic: Anthropic conversion,
- SSE construction, OpenAI Responses conversion, stream recovery, token counting,
- and structured trace helpers.
+- [src/free_claude_code/core/](src/free_claude_code/core/) owns provider-neutral protocol logic: wire request and response
+ models, Anthropic conversion, SSE construction, OpenAI Responses conversion,
+ stream recovery, token counting, and structured trace helpers.
- [src/free_claude_code/messaging/](src/free_claude_code/messaging/) owns optional platform adapters, incoming message
handling, tree queues, transcript rendering, persistence, commands, and voice
support.
@@ -69,9 +70,16 @@ The installable wheel packages are declared in [pyproject.toml](pyproject.toml):
[smoke/](smoke/) contains local and live product smoke tests that can launch
subprocesses or touch real services.
-The main ownership rule is that shared Anthropic and Responses protocol behavior
-belongs in [src/free_claude_code/core/](src/free_claude_code/core/). Provider modules should use neutral helpers rather
-than importing behavior from another provider-specific module.
+The main ownership rule is that Anthropic and Responses protocol schemas and
+shared behavior belong in [src/free_claude_code/core/](src/free_claude_code/core/). Routes use those schemas directly for
+wire validation, and provider modules use the same concrete request types and
+neutral helpers instead of importing the API adapter or another provider.
+Protocol consumers use the public `core.anthropic` and
+`core.openai_responses` facades. Low-level core and provider modules may import
+the dependency-leaf `models.py` modules directly so their type dependency is
+explicit; package initialization and those leaves must remain import-order safe.
+The model-list schema stays beside its API-owned construction policy in
+`api/model_catalog.py`; there is no generic API model package.
## Customer-Facing Contract
@@ -444,6 +452,10 @@ retries without the budget while preserving thinking enablement.
Shared provider responsibilities include upstream rate limiting, model listing,
safe error mapping, transport cleanup, thinking/tool handling, retry or recovery
where supported, and returning Anthropic SSE strings to the service layer.
+Every provider and both transport families receive the same concrete
+`MessagesRequest` owned by the Anthropic protocol package. Known wire fields are
+accessed through that model; `Any` and dynamic attribute lookup are reserved for
+SDK response objects and genuinely open-ended nested extension payloads.
Provider-specific inputs that do not apply to other upstreams, such as
Cloudflare's account ID, stay in that provider's factory/client instead of being
added to shared `ProviderConfig`.
@@ -482,6 +494,10 @@ usage quirks such as DeepSeek prompt-cache counters.
[src/free_claude_code/core/anthropic/](src/free_claude_code/core/anthropic/) owns Anthropic-side protocol behavior:
+- `models.py` defines the permissive Messages and token-count wire requests,
+ content/tool/thinking blocks, and Anthropic response envelopes;
+- trace-safe request snapshots stay beside those models so the generic trace
+ module remains protocol-independent and import-order safe;
- content and message conversion for OpenAI-compatible upstreams;
- request serialization primitives shared by provider request policies;
- tool schema and tool-result handling;
@@ -518,6 +534,8 @@ protocol events.
[src/free_claude_code/core/openai_responses/](src/free_claude_code/core/openai_responses/) owns OpenAI Responses support:
+- the permissive `OpenAIResponsesRequest` ingress model used directly by the
+ FastAPI route and the protocol adapter;
- the `OpenAIResponsesAdapter` facade used by the API layer;
- streaming-only `/v1/responses` support for Codex/FCC workflows;
- Responses request conversion into Anthropic Messages payloads;
@@ -530,7 +548,10 @@ an OpenAI-shaped client error because installed FCC/Codex workflows only need
streaming. Request conversion, stream transformation, Anthropic SSE parsing,
Responses SSE event formatting, output item construction, tool identity mapping,
reasoning mapping, ID generation, and error envelope construction each live
-behind the adapter boundary. `stream.py` is the public streaming entrypoint;
+behind the adapter boundary. The concrete request object crosses that boundary
+unchanged; nested Responses input and tool data stays permissive and is
+interpreted by the conversion functions. `stream.py` is the public streaming
+entrypoint;
[src/free_claude_code/core/openai_responses/streaming/](src/free_claude_code/core/openai_responses/streaming/) owns the
block-indexed Responses stream assembler. The package separates Anthropic SSE
dispatch, block state, output ledger ordering, block completion, SSE event
diff --git a/pyproject.toml b/pyproject.toml
index 98268242..68471012 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "free-claude-code"
-version = "3.4.18"
+version = "3.4.19"
description = "Middleware between Claude Code CLI (Anthropic API) and NVIDIA NIM"
readme = "README.md"
requires-python = ">=3.14.0"
diff --git a/smoke/features.py b/smoke/features.py
index f5efeb96..1d52571d 100644
--- a/smoke/features.py
+++ b/smoke/features.py
@@ -272,7 +272,7 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = (
"VS Code protocol-shaped requests work against the proxy",
"readme",
(
- "tests/api/test_models_validators.py::test_messages_request_accepts_adaptive_thinking_type",
+ "tests/core/anthropic/test_models.py::test_messages_request_accepts_adaptive_thinking_type",
),
("test_vscode_and_jetbrains_shaped_requests",),
("test_vscode_protocol_e2e",),
@@ -285,7 +285,7 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = (
"JetBrains/ACP protocol-shaped requests work against the proxy",
"readme",
(
- "tests/api/test_models_validators.py::test_messages_request_accepts_adaptive_thinking_type",
+ "tests/core/anthropic/test_models.py::test_messages_request_accepts_adaptive_thinking_type",
),
("test_vscode_and_jetbrains_shaped_requests",),
("test_jetbrains_protocol_e2e",),
diff --git a/src/free_claude_code/api/detection.py b/src/free_claude_code/api/detection.py
index 08abff64..1dfbc81f 100644
--- a/src/free_claude_code/api/detection.py
+++ b/src/free_claude_code/api/detection.py
@@ -4,9 +4,7 @@ Detects quota checks, title generation, prefix detection, safety classifier,
suggestion mode, and filepath extraction requests to enable targeted handling.
"""
-from free_claude_code.core.anthropic import extract_text_from_content
-
-from .models.anthropic import MessagesRequest
+from free_claude_code.core.anthropic import MessagesRequest, extract_text_from_content
def is_quota_check_request(request_data: MessagesRequest) -> bool:
diff --git a/src/free_claude_code/api/handlers/messages.py b/src/free_claude_code/api/handlers/messages.py
index 3d4b4b2e..3d1605e3 100644
--- a/src/free_claude_code/api/handlers/messages.py
+++ b/src/free_claude_code/api/handlers/messages.py
@@ -9,7 +9,6 @@ from loguru import logger
from free_claude_code.api.detection import is_safety_classifier_request
from free_claude_code.api.model_router import ModelRouter, RoutedMessagesRequest
-from free_claude_code.api.models.anthropic import MessagesRequest
from free_claude_code.api.optimization_handlers import try_optimizations
from free_claude_code.api.provider_execution import (
ProviderExecutionService,
@@ -39,6 +38,7 @@ from free_claude_code.api.web_tools.streaming import stream_web_server_tool_resp
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import (
+ MessagesRequest,
aggregate_anthropic_sse_to_message,
anthropic_error_payload,
anthropic_status_for_error_type,
diff --git a/src/free_claude_code/api/handlers/responses.py b/src/free_claude_code/api/handlers/responses.py
index 3ca2e422..d1f258c1 100644
--- a/src/free_claude_code/api/handlers/responses.py
+++ b/src/free_claude_code/api/handlers/responses.py
@@ -5,8 +5,6 @@ from collections.abc import Callable
from fastapi.responses import JSONResponse
from free_claude_code.api.model_router import ModelRouter
-from free_claude_code.api.models.anthropic import MessagesRequest
-from free_claude_code.api.models.openai_responses import OpenAIResponsesRequest
from free_claude_code.api.provider_execution import ProviderExecutionService
from free_claude_code.api.request_errors import (
http_status_for_unexpected_api_exception,
@@ -19,8 +17,14 @@ from free_claude_code.api.response_streams import (
terminal_execution_error_response,
)
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import get_user_facing_error_message
-from free_claude_code.core.openai_responses import OpenAIResponsesAdapter
+from free_claude_code.core.anthropic import (
+ MessagesRequest,
+ get_user_facing_error_message,
+)
+from free_claude_code.core.openai_responses import (
+ OpenAIResponsesAdapter,
+ OpenAIResponsesRequest,
+)
from free_claude_code.core.trace import trace_event
from free_claude_code.providers.base import BaseProvider
from free_claude_code.providers.exceptions import InvalidRequestError, ProviderError
@@ -70,7 +74,7 @@ class ResponsesHandler:
try:
anthropic_payload = self._responses_adapter.to_anthropic_payload(
- request_payload
+ request_data
)
response_request = MessagesRequest(**anthropic_payload)
require_non_empty_messages(response_request.messages)
@@ -86,7 +90,7 @@ class ResponsesHandler:
return await openai_responses_sse_streaming_response(
self._responses_adapter.iter_sse_from_anthropic(
streamed,
- request_payload,
+ request_data,
),
headers=self._responses_adapter.sse_headers,
pre_start_error_response=lambda exc: self._pre_start_error_response(
diff --git a/src/free_claude_code/api/handlers/token_count.py b/src/free_claude_code/api/handlers/token_count.py
index cfae79a1..59bf80a4 100644
--- a/src/free_claude_code/api/handlers/token_count.py
+++ b/src/free_claude_code/api/handlers/token_count.py
@@ -4,8 +4,6 @@ from fastapi import HTTPException
from loguru import logger
from free_claude_code.api.model_router import ModelRouter
-from free_claude_code.api.models.anthropic import TokenCountRequest
-from free_claude_code.api.models.responses import TokenCountResponse
from free_claude_code.api.provider_execution import TokenCounter
from free_claude_code.api.request_errors import (
http_status_for_unexpected_api_exception,
@@ -15,10 +13,13 @@ from free_claude_code.api.request_errors import (
from free_claude_code.api.request_ids import new_request_id
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import (
+ TokenCountRequest,
+ TokenCountResponse,
+ anthropic_request_snapshot,
get_token_count,
get_user_facing_error_message,
)
-from free_claude_code.core.trace import api_messages_request_snapshot, trace_event
+from free_claude_code.core.trace import trace_event
from free_claude_code.providers.exceptions import ProviderError
@@ -66,7 +67,7 @@ class TokenCountHandler:
request_id=request_id,
message_count=len(routed.request.messages),
input_tokens=tokens,
- snapshot=api_messages_request_snapshot(routed.request),
+ snapshot=anthropic_request_snapshot(routed.request),
)
return TokenCountResponse(input_tokens=tokens)
except ProviderError:
diff --git a/src/free_claude_code/api/model_catalog.py b/src/free_claude_code/api/model_catalog.py
index 04b89495..5ef371dc 100644
--- a/src/free_claude_code/api/model_catalog.py
+++ b/src/free_claude_code/api/model_catalog.py
@@ -1,5 +1,9 @@
"""Model-list response construction for Claude-compatible clients."""
+from typing import Literal
+
+from pydantic import BaseModel
+
from free_claude_code.config.model_refs import configured_chat_model_refs
from free_claude_code.config.settings import Settings
from free_claude_code.core.gateway_model_ids import (
@@ -7,12 +11,29 @@ from free_claude_code.core.gateway_model_ids import (
no_thinking_gateway_model_id,
)
-from .models.responses import ModelResponse, ModelsListResponse
from .ports import RequestRuntimePort
DISCOVERED_MODEL_CREATED_AT = "1970-01-01T00:00:00Z"
+class ModelResponse(BaseModel):
+ object: Literal["model"] = "model"
+ created: int = 0
+ owned_by: str = "free-claude-code"
+ created_at: str
+ display_name: str
+ id: str
+ type: Literal["model"] = "model"
+
+
+class ModelsListResponse(BaseModel):
+ object: Literal["list"] = "list"
+ data: list[ModelResponse]
+ first_id: str | None
+ has_more: bool
+ last_id: str | None
+
+
SUPPORTED_CLAUDE_MODELS = [
ModelResponse(
id="claude-opus-4-20250514",
diff --git a/src/free_claude_code/api/model_router.py b/src/free_claude_code/api/model_router.py
index f4a1fa91..a026a45b 100644
--- a/src/free_claude_code/api/model_router.py
+++ b/src/free_claude_code/api/model_router.py
@@ -7,10 +7,9 @@ from loguru import logger
from free_claude_code.config.model_refs import parse_model_name, parse_provider_type
from free_claude_code.config.provider_ids import SUPPORTED_PROVIDER_IDS
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 .models.anthropic import MessagesRequest, TokenCountRequest
-
@dataclass(frozen=True, slots=True)
class ResolvedModel:
diff --git a/src/free_claude_code/api/models/__init__.py b/src/free_claude_code/api/models/__init__.py
deleted file mode 100644
index f54a732c..00000000
--- a/src/free_claude_code/api/models/__init__.py
+++ /dev/null
@@ -1,45 +0,0 @@
-"""API models exports."""
-
-from .anthropic import (
- ContentBlockImage,
- ContentBlockRedactedThinking,
- ContentBlockText,
- ContentBlockThinking,
- ContentBlockToolResult,
- ContentBlockToolUse,
- Message,
- MessagesRequest,
- Role,
- SystemContent,
- ThinkingConfig,
- TokenCountRequest,
- Tool,
-)
-from .responses import (
- MessagesResponse,
- ModelResponse,
- ModelsListResponse,
- TokenCountResponse,
- Usage,
-)
-
-__all__ = [
- "ContentBlockImage",
- "ContentBlockRedactedThinking",
- "ContentBlockText",
- "ContentBlockThinking",
- "ContentBlockToolResult",
- "ContentBlockToolUse",
- "Message",
- "MessagesRequest",
- "MessagesResponse",
- "ModelResponse",
- "ModelsListResponse",
- "Role",
- "SystemContent",
- "ThinkingConfig",
- "TokenCountRequest",
- "TokenCountResponse",
- "Tool",
- "Usage",
-]
diff --git a/src/free_claude_code/api/models/responses.py b/src/free_claude_code/api/models/responses.py
deleted file mode 100644
index 027df706..00000000
--- a/src/free_claude_code/api/models/responses.py
+++ /dev/null
@@ -1,60 +0,0 @@
-"""Pydantic models for API responses."""
-
-from typing import Any, Literal
-
-from pydantic import BaseModel
-
-from .anthropic import (
- ContentBlockRedactedThinking,
- ContentBlockText,
- ContentBlockThinking,
- ContentBlockToolUse,
-)
-
-
-class TokenCountResponse(BaseModel):
- input_tokens: int
-
-
-class ModelResponse(BaseModel):
- object: Literal["model"] = "model"
- created: int = 0
- owned_by: str = "free-claude-code"
- created_at: str
- display_name: str
- id: str
- type: Literal["model"] = "model"
-
-
-class ModelsListResponse(BaseModel):
- object: Literal["list"] = "list"
- data: list[ModelResponse]
- first_id: str | None
- has_more: bool
- last_id: str | None
-
-
-class Usage(BaseModel):
- input_tokens: int
- output_tokens: int
- cache_creation_input_tokens: int = 0
- cache_read_input_tokens: int = 0
-
-
-class MessagesResponse(BaseModel):
- id: str
- model: str
- role: Literal["assistant"] = "assistant"
- content: list[
- ContentBlockText
- | ContentBlockToolUse
- | ContentBlockThinking
- | ContentBlockRedactedThinking
- | dict[str, Any]
- ]
- type: Literal["message"] = "message"
- stop_reason: (
- Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None
- ) = None
- stop_sequence: str | None = None
- usage: Usage
diff --git a/src/free_claude_code/api/optimization_handlers.py b/src/free_claude_code/api/optimization_handlers.py
index 52871702..452dadcb 100644
--- a/src/free_claude_code/api/optimization_handlers.py
+++ b/src/free_claude_code/api/optimization_handlers.py
@@ -9,6 +9,11 @@ import uuid
from loguru import logger
from free_claude_code.config.settings import Settings
+from free_claude_code.core.anthropic import (
+ MessagesRequest,
+ MessagesResponse,
+ Usage,
+)
from .command_utils import extract_command_prefix, extract_filepaths_from_command
from .detection import (
@@ -18,8 +23,6 @@ from .detection import (
is_suggestion_mode_request,
is_title_generation_request,
)
-from .models.anthropic import MessagesRequest
-from .models.responses import MessagesResponse, Usage
def _text_response(
diff --git a/src/free_claude_code/api/provider_execution.py b/src/free_claude_code/api/provider_execution.py
index e0c6756c..614d03f8 100644
--- a/src/free_claude_code/api/provider_execution.py
+++ b/src/free_claude_code/api/provider_execution.py
@@ -6,9 +6,8 @@ from typing import Any
from loguru import logger
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import get_token_count
+from free_claude_code.core.anthropic import anthropic_request_snapshot, get_token_count
from free_claude_code.core.trace import (
- api_messages_request_snapshot,
trace_event,
traced_async_stream,
)
@@ -77,7 +76,7 @@ class ProviderExecutionService:
),
source="api",
message_count=len(routed.request.messages),
- snapshot=api_messages_request_snapshot(routed.request),
+ snapshot=anthropic_request_snapshot(routed.request),
request_id=request_id,
)
diff --git a/src/free_claude_code/api/routes.py b/src/free_claude_code/api/routes.py
index 9c192b64..ededd254 100644
--- a/src/free_claude_code/api/routes.py
+++ b/src/free_claude_code/api/routes.py
@@ -5,7 +5,12 @@ from loguru import logger
from free_claude_code.config.model_refs import parse_provider_type
from free_claude_code.config.settings import Settings
-from free_claude_code.core.anthropic import get_token_count
+from free_claude_code.core.anthropic import (
+ MessagesRequest,
+ TokenCountRequest,
+ get_token_count,
+)
+from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.trace import trace_event
from .dependencies import (
@@ -15,10 +20,7 @@ from .dependencies import (
resolve_provider,
)
from .handlers import MessagesHandler, ResponsesHandler, TokenCountHandler
-from .model_catalog import build_models_list_response
-from .models.anthropic import MessagesRequest, TokenCountRequest
-from .models.openai_responses import OpenAIResponsesRequest
-from .models.responses import ModelsListResponse
+from .model_catalog import ModelsListResponse, build_models_list_response
from .ports import ApiServices, RequestRuntimeLease
from .request_ids import get_request_id
from .response_streams import bind_response_lifetime
diff --git a/src/free_claude_code/api/web_tools/request.py b/src/free_claude_code/api/web_tools/request.py
index 4b4a8ced..227f18f5 100644
--- a/src/free_claude_code/api/web_tools/request.py
+++ b/src/free_claude_code/api/web_tools/request.py
@@ -1,12 +1,12 @@
"""Detect forced Anthropic web server tool requests."""
-from free_claude_code.api.models.anthropic import MessagesRequest, Tool
+from free_claude_code.core.anthropic import MessagesRequest, Tool
+
+from .parsers import content_text
def request_text(request: MessagesRequest) -> str:
"""Join all user/assistant message content into one string for tool input parsing."""
- from .parsers import content_text
-
return "\n".join(content_text(message.content) for message in request.messages)
@@ -15,8 +15,6 @@ def forced_tool_turn_text(request: MessagesRequest) -> str:
if not request.messages:
return ""
- from .parsers import content_text
-
for message in reversed(request.messages):
if message.role == "user":
return content_text(message.content)
diff --git a/src/free_claude_code/api/web_tools/streaming.py b/src/free_claude_code/api/web_tools/streaming.py
index 5fe63bd7..3885e624 100644
--- a/src/free_claude_code/api/web_tools/streaming.py
+++ b/src/free_claude_code/api/web_tools/streaming.py
@@ -5,7 +5,7 @@ from collections.abc import AsyncIterator
from datetime import UTC, datetime
from typing import Any
-from free_claude_code.api.models.anthropic import MessagesRequest
+from free_claude_code.core.anthropic import MessagesRequest
from free_claude_code.core.anthropic.server_tool_sse import (
SERVER_TOOL_USE,
WEB_FETCH_TOOL_ERROR,
diff --git a/src/free_claude_code/core/anthropic/__init__.py b/src/free_claude_code/core/anthropic/__init__.py
index 81326a09..68dfbbcf 100644
--- a/src/free_claude_code/core/anthropic/__init__.py
+++ b/src/free_claude_code/core/anthropic/__init__.py
@@ -15,8 +15,31 @@ from .errors import (
get_user_facing_error_message,
redact_sensitive_error_text,
)
+from .models import (
+ ContentBlockDocument,
+ ContentBlockImage,
+ ContentBlockRedactedThinking,
+ ContentBlockServerToolUse,
+ ContentBlockText,
+ ContentBlockThinking,
+ ContentBlockToolResult,
+ ContentBlockToolUse,
+ ContentBlockWebFetchToolResult,
+ ContentBlockWebSearchToolResult,
+ Message,
+ MessagesRequest,
+ MessagesResponse,
+ Role,
+ SystemContent,
+ ThinkingConfig,
+ TokenCountRequest,
+ TokenCountResponse,
+ Tool,
+ Usage,
+)
from .native_messages_request import sanitize_native_messages_thinking_policy
from .request_serialization import serialize_tool_result_content
+from .request_snapshot import anthropic_request_snapshot
from .sse_aggregation import aggregate_anthropic_sse_to_message
from .streaming import (
AnthropicStreamLedger,
@@ -33,16 +56,37 @@ from .utils import set_if_not_none
__all__ = [
"AnthropicStreamLedger",
"AnthropicToOpenAIConverter",
+ "ContentBlockDocument",
+ "ContentBlockImage",
+ "ContentBlockRedactedThinking",
+ "ContentBlockServerToolUse",
+ "ContentBlockText",
+ "ContentBlockThinking",
+ "ContentBlockToolResult",
+ "ContentBlockToolUse",
+ "ContentBlockWebFetchToolResult",
+ "ContentBlockWebSearchToolResult",
"ContentChunk",
"ContentType",
"HeuristicToolParser",
+ "Message",
+ "MessagesRequest",
+ "MessagesResponse",
"OpenAIConversionError",
"ReasoningReplayMode",
+ "Role",
"StreamBlockLedger",
+ "SystemContent",
"ThinkTagParser",
+ "ThinkingConfig",
+ "TokenCountRequest",
+ "TokenCountResponse",
+ "Tool",
"ToolBlockState",
+ "Usage",
"aggregate_anthropic_sse_to_message",
"anthropic_error_payload",
+ "anthropic_request_snapshot",
"anthropic_status_for_error_type",
"append_request_id",
"build_base_request_body",
diff --git a/src/free_claude_code/core/anthropic/conversion.py b/src/free_claude_code/core/anthropic/conversion.py
index de747169..5a825a0d 100644
--- a/src/free_claude_code/core/anthropic/conversion.py
+++ b/src/free_claude_code/core/anthropic/conversion.py
@@ -6,9 +6,8 @@ from dataclasses import dataclass, field
from enum import StrEnum
from typing import Any
-from pydantic import BaseModel
-
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
@@ -25,16 +24,16 @@ class ReasoningReplayMode(StrEnum):
REASONING_CONTENT = "reasoning_content"
-def _openai_reject_native_only_top_level_fields(request_data: Any) -> None:
+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.
"""
- if not isinstance(request_data, BaseModel):
- return
- extra = getattr(request_data, "__pydantic_extra__", None)
+ extra = request_data.model_extra
if not extra:
return
raise OpenAIConversionError(
@@ -569,7 +568,7 @@ class AnthropicToOpenAIConverter:
def build_base_request_body(
- request_data: Any,
+ request_data: MessagesRequest,
*,
default_max_tokens: int | None = None,
reasoning_replay: ReasoningReplayMode = ReasoningReplayMode.THINK_TAGS,
@@ -581,7 +580,7 @@ def build_base_request_body(
reasoning_replay=reasoning_replay,
)
- system = getattr(request_data, "system", None)
+ system = request_data.system
if system:
system_msg = AnthropicToOpenAIConverter.convert_system_prompt(system)
if system_msg:
@@ -589,19 +588,19 @@ def build_base_request_body(
body: dict[str, Any] = {"model": request_data.model, "messages": messages}
- max_tokens = getattr(request_data, "max_tokens", None)
+ 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", getattr(request_data, "temperature", None))
- set_if_not_none(body, "top_p", getattr(request_data, "top_p", None))
+ set_if_not_none(body, "temperature", request_data.temperature)
+ set_if_not_none(body, "top_p", request_data.top_p)
- stop_sequences = getattr(request_data, "stop_sequences", None)
+ stop_sequences = request_data.stop_sequences
if stop_sequences:
body["stop"] = stop_sequences
- tools = getattr(request_data, "tools", None)
+ tools = request_data.tools
if tools:
body["tools"] = AnthropicToOpenAIConverter.convert_tools(tools)
- tool_choice = getattr(request_data, "tool_choice", None)
+ tool_choice = request_data.tool_choice
if tool_choice:
body["tool_choice"] = AnthropicToOpenAIConverter.convert_tool_choice(
tool_choice
diff --git a/src/free_claude_code/api/models/anthropic.py b/src/free_claude_code/core/anthropic/models.py
similarity index 84%
rename from src/free_claude_code/api/models/anthropic.py
rename to src/free_claude_code/core/anthropic/models.py
index 7f38a2ca..105c12a4 100644
--- a/src/free_claude_code/api/models/anthropic.py
+++ b/src/free_claude_code/core/anthropic/models.py
@@ -1,4 +1,4 @@
-"""Pydantic models for Anthropic-compatible requests."""
+"""Pydantic models for the Anthropic Messages protocol."""
from enum import StrEnum
from typing import Any, Literal
@@ -6,9 +6,6 @@ from typing import Any, Literal
from pydantic import BaseModel, ConfigDict, Field, model_validator
-# =============================================================================
-# Content Block Types
-# =============================================================================
class Role(StrEnum):
user = "user"
assistant = "assistant"
@@ -16,7 +13,7 @@ class Role(StrEnum):
class _AnthropicBlockBase(BaseModel):
- """Pass through provider fields (e.g. ``cache_control``) for native transports."""
+ """Pass through protocol extensions such as ``cache_control``."""
model_config = ConfigDict(extra="allow")
@@ -138,9 +135,6 @@ def _normalize_system_role_messages(data: Any) -> Any:
return normalized
-# =============================================================================
-# Message Types
-# =============================================================================
class Message(BaseModel):
role: Literal["user", "assistant"]
content: (
@@ -163,8 +157,6 @@ class Message(BaseModel):
class Tool(_AnthropicBlockBase):
name: str
- # Anthropic server tools (e.g. web_search beta tools) include a ``type`` and
- # may omit ``input_schema`` because the provider owns the schema.
type: str | None = None
description: str | None = None
input_schema: dict[str, Any] | None = None
@@ -176,9 +168,6 @@ class ThinkingConfig(BaseModel):
budget_tokens: int | None = None
-# =============================================================================
-# Request Models
-# =============================================================================
class MessagesRequest(BaseModel):
model_config = ConfigDict(extra="allow")
@@ -188,7 +177,6 @@ class MessagesRequest(BaseModel):
return _normalize_system_role_messages(data)
model: str
- # Internal routing / debug: accepted on parse but not serialized to providers.
original_model: str | None = Field(default=None, exclude=True)
resolved_provider_model: str | None = Field(default=None, exclude=True)
max_tokens: int | None = None
@@ -203,12 +191,10 @@ class MessagesRequest(BaseModel):
tools: list[Tool] | None = None
tool_choice: dict[str, Any] | None = None
thinking: ThinkingConfig | None = None
- # Native Anthropic / SDK client hints: ignored (not forwarded) for OpenAI Chat conversion.
context_management: dict[str, Any] | None = None
output_config: dict[str, Any] | None = None
mcp_servers: list[dict[str, Any]] | None = None
extra_body: dict[str, Any] | None = None
- # Beta feature flags sent by Claude Code as a body field; accepted but never forwarded.
betas: list[str] | None = Field(default=None, exclude=True)
@@ -232,3 +218,33 @@ class TokenCountRequest(BaseModel):
output_config: dict[str, Any] | None = None
mcp_servers: list[dict[str, Any]] | None = None
betas: list[str] | None = Field(default=None, exclude=True)
+
+
+class TokenCountResponse(BaseModel):
+ input_tokens: int
+
+
+class Usage(BaseModel):
+ input_tokens: int
+ output_tokens: int
+ cache_creation_input_tokens: int = 0
+ cache_read_input_tokens: int = 0
+
+
+class MessagesResponse(BaseModel):
+ id: str
+ model: str
+ role: Literal["assistant"] = "assistant"
+ content: list[
+ ContentBlockText
+ | ContentBlockToolUse
+ | ContentBlockThinking
+ | ContentBlockRedactedThinking
+ | dict[str, Any]
+ ]
+ type: Literal["message"] = "message"
+ stop_reason: (
+ Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None
+ ) = None
+ stop_sequence: str | None = None
+ usage: Usage
diff --git a/src/free_claude_code/core/anthropic/native_messages_request.py b/src/free_claude_code/core/anthropic/native_messages_request.py
index 36dadaa2..77b45ade 100644
--- a/src/free_claude_code/core/anthropic/native_messages_request.py
+++ b/src/free_claude_code/core/anthropic/native_messages_request.py
@@ -1,9 +1,8 @@
"""Native Anthropic Messages request body construction (JSON-ready dicts)."""
-from collections.abc import Sequence
from typing import Any
-from pydantic import BaseModel
+from .models import MessagesRequest
_REQUEST_FIELDS = (
"model",
@@ -26,58 +25,17 @@ _REQUEST_FIELDS = (
)
-def _serialize_value(value: Any) -> Any:
- """Convert Pydantic models and lightweight objects into JSON-ready values."""
- if isinstance(value, BaseModel):
- return value.model_dump(exclude_none=True)
- if isinstance(value, dict):
- return {
- key: _serialize_value(item)
- for key, item in value.items()
- if item is not None
- }
- if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
- return [_serialize_value(item) for item in value]
- if value is None or isinstance(value, str | int | float | bool):
- return value
- if hasattr(value, "__dict__"):
- return {
- key: _serialize_value(item)
- for key, item in vars(value).items()
- if not key.startswith("_") and item is not None
- }
- return value
-
-
-def _dump_request_fields(request_data: Any) -> dict[str, Any]:
+def _dump_request_fields(request_data: MessagesRequest) -> dict[str, Any]:
"""Extract the public Anthropic request fields."""
- if isinstance(request_data, BaseModel):
- raw = request_data.model_dump(exclude_none=True)
- return {
- field: raw[field]
- for field in _REQUEST_FIELDS
- if field in raw and raw[field] is not None
- }
-
- dump = getattr(request_data, "model_dump", None)
- if callable(dump):
- raw = dump(exclude_none=True)
- if isinstance(raw, dict):
- return {
- field: raw[field]
- for field in _REQUEST_FIELDS
- if field in raw and raw[field] is not None
- }
-
- dumped: dict[str, Any] = {}
- for field in _REQUEST_FIELDS:
- value = getattr(request_data, field, None)
- if value is not None:
- dumped[field] = _serialize_value(value)
- return dumped
-
-
-def dump_raw_messages_request(request_data: Any) -> dict[str, Any]:
+ raw = request_data.model_dump(exclude_none=True)
+ return {
+ field: raw[field]
+ for field in _REQUEST_FIELDS
+ if field in raw and raw[field] is not None
+ }
+
+
+def dump_raw_messages_request(request_data: MessagesRequest) -> dict[str, Any]:
"""Public JSON-ready dict of Anthropic public request fields (for native adapters)."""
return _dump_request_fields(request_data)
@@ -139,7 +97,7 @@ def sanitize_native_messages_thinking_policy(
def build_base_native_anthropic_request_body(
- request: Any,
+ request: MessagesRequest,
*,
default_max_tokens: int,
thinking_enabled: bool,
diff --git a/src/free_claude_code/core/anthropic/request_snapshot.py b/src/free_claude_code/core/anthropic/request_snapshot.py
new file mode 100644
index 00000000..75c1d5bb
--- /dev/null
+++ b/src/free_claude_code/core/anthropic/request_snapshot.py
@@ -0,0 +1,36 @@
+"""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",
+ "thinking_enabled",
+ )
+ 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/recovery.py b/src/free_claude_code/core/anthropic/streaming/recovery.py
index ddbd4384..d6edb394 100644
--- a/src/free_claude_code/core/anthropic/streaming/recovery.py
+++ b/src/free_claude_code/core/anthropic/streaming/recovery.py
@@ -15,6 +15,7 @@ from loguru import logger
from free_claude_code.core.trace import trace_event
+from ..models import MessagesRequest
from .transient_errors import retryable_transient_status
EARLY_TRANSPARENT_TOTAL_ATTEMPTS = 5
@@ -248,19 +249,19 @@ def is_retryable_stream_error(exc: BaseException) -> bool:
)
-def tool_schemas_by_name(request: Any) -> dict[str, ToolSchema]:
+def tool_schemas_by_name(request: MessagesRequest) -> dict[str, ToolSchema]:
"""Return Anthropic tool input schemas keyed by tool name."""
schemas: dict[str, ToolSchema] = {}
- tools = getattr(request, "tools", None)
+ tools = request.tools
if not tools:
return schemas
for tool in tools:
- name = _tool_attr(tool, "name")
- if not isinstance(name, str) or not name:
+ name = tool.name
+ if not name:
continue
- schema = _tool_attr(tool, "input_schema")
- if not isinstance(schema, dict):
+ schema = tool.input_schema
+ if schema is None:
schema = {"type": "object"}
schemas[name] = ToolSchema(name=name, input_schema=deepcopy(schema))
return schemas
@@ -379,12 +380,6 @@ def make_tool_repair_body(
return recovery
-def _tool_attr(tool: Any, attr: str) -> Any:
- if isinstance(tool, dict):
- return tool.get(attr)
- return getattr(tool, attr, None)
-
-
def _copied_messages(body: dict[str, Any]) -> list[Any]:
messages = body.get("messages")
return deepcopy(messages) if isinstance(messages, list) else []
diff --git a/src/free_claude_code/core/openai_responses/__init__.py b/src/free_claude_code/core/openai_responses/__init__.py
index 524caf07..37c7b444 100644
--- a/src/free_claude_code/core/openai_responses/__init__.py
+++ b/src/free_claude_code/core/openai_responses/__init__.py
@@ -1,5 +1,6 @@
"""OpenAI Responses protocol adapter."""
from .adapter import OpenAIResponsesAdapter
+from .models import OpenAIResponsesRequest
-__all__ = ["OpenAIResponsesAdapter"]
+__all__ = ["OpenAIResponsesAdapter", "OpenAIResponsesRequest"]
diff --git a/src/free_claude_code/core/openai_responses/adapter.py b/src/free_claude_code/core/openai_responses/adapter.py
index f05cdf46..6fe414e1 100644
--- a/src/free_claude_code/core/openai_responses/adapter.py
+++ b/src/free_claude_code/core/openai_responses/adapter.py
@@ -1,11 +1,12 @@
"""Facade for OpenAI Responses protocol adaptation."""
-from collections.abc import AsyncIterable, AsyncIterator, Mapping
+from collections.abc import AsyncIterable, AsyncIterator
from typing import Any, ClassVar
from .errors import ResponsesConversionError, openai_error_payload
from .events import OPENAI_RESPONSES_SSE_HEADERS
from .input import convert_request_to_anthropic_payload
+from .models import OpenAIResponsesRequest
from .stream import iter_responses_sse_from_anthropic
@@ -15,13 +16,13 @@ class OpenAIResponsesAdapter:
ConversionError: ClassVar[type[ResponsesConversionError]] = ResponsesConversionError
sse_headers: ClassVar[dict[str, str]] = OPENAI_RESPONSES_SSE_HEADERS
- def to_anthropic_payload(self, request: Mapping[str, Any]) -> dict[str, Any]:
+ def to_anthropic_payload(self, request: OpenAIResponsesRequest) -> dict[str, Any]:
return convert_request_to_anthropic_payload(request)
def iter_sse_from_anthropic(
self,
chunks: AsyncIterable[Any],
- request: Mapping[str, Any],
+ request: OpenAIResponsesRequest,
) -> AsyncIterator[str]:
return iter_responses_sse_from_anthropic(chunks, request)
diff --git a/src/free_claude_code/core/openai_responses/input.py b/src/free_claude_code/core/openai_responses/input.py
index 1d3cb97d..3fc2232f 100644
--- a/src/free_claude_code/core/openai_responses/input.py
+++ b/src/free_claude_code/core/openai_responses/input.py
@@ -6,6 +6,7 @@ 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,
reasoning_text_from_item,
@@ -24,18 +25,18 @@ from .tools import (
def convert_request_to_anthropic_payload(
- request: Mapping[str, Any],
+ request: OpenAIResponsesRequest,
) -> dict[str, Any]:
"""Convert an OpenAI Responses request into an Anthropic Messages payload."""
system_parts: list[str] = []
- if instructions := optional_str(request.get("instructions")):
+ if instructions := request.instructions:
system_parts.append(instructions)
messages: list[dict[str, Any]] = []
pending_reasoning: str | None = None
quarantined_function_call_ids: set[str] = set()
- for item in _iter_input_items(request.get("input")):
+ for item in _iter_input_items(request.input):
pending_reasoning = _append_input_item(
item,
messages=messages,
@@ -49,24 +50,26 @@ def convert_request_to_anthropic_payload(
raise ResponsesConversionError("Responses request input must contain a message")
payload: dict[str, Any] = {
- "model": required_str(request.get("model"), "model"),
+ "model": required_str(request.model, "model"),
"messages": messages,
"stream": True,
}
if system_parts:
payload["system"] = "\n\n".join(system_parts)
- _copy_if_present(request, payload, "temperature")
- _copy_if_present(request, payload, "top_p")
- if request.get("max_output_tokens") is not None:
- payload["max_tokens"] = request["max_output_tokens"]
- if isinstance(request.get("metadata"), dict):
- payload["metadata"] = request["metadata"]
-
- if thinking := responses_reasoning_to_thinking(request.get("reasoning")):
+ 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 thinking := responses_reasoning_to_thinking(request.reasoning):
payload["thinking"] = thinking
- raw_tool_choice = request.get("tool_choice")
- tools = convert_tools(request.get("tools"))
+ 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)
@@ -352,10 +355,3 @@ def _text_from_part(part: Mapping[str, Any]) -> str:
if text := optional_str(part.get("output_text")):
return text
return ""
-
-
-def _copy_if_present(
- source: Mapping[str, Any], target: dict[str, Any], field_name: str
-) -> None:
- if source.get(field_name) is not None:
- target[field_name] = source[field_name]
diff --git a/src/free_claude_code/api/models/openai_responses.py b/src/free_claude_code/core/openai_responses/models.py
similarity index 100%
rename from src/free_claude_code/api/models/openai_responses.py
rename to src/free_claude_code/core/openai_responses/models.py
diff --git a/src/free_claude_code/core/openai_responses/stream.py b/src/free_claude_code/core/openai_responses/stream.py
index 5f64e062..a71547d4 100644
--- a/src/free_claude_code/core/openai_responses/stream.py
+++ b/src/free_claude_code/core/openai_responses/stream.py
@@ -1,19 +1,20 @@
"""Translate Anthropic SSE streams into OpenAI Responses SSE streams."""
import asyncio
-from collections.abc import AsyncIterable, AsyncIterator, Mapping
+from collections.abc import AsyncIterable, AsyncIterator
from typing import Any
from free_claude_code.core.anthropic import get_user_facing_error_message
from free_claude_code.core.trace import trace_event
from .anthropic_sse import iter_sse_events
+from .models import OpenAIResponsesRequest
from .streaming import ResponsesStreamAssembler
async def iter_responses_sse_from_anthropic(
chunks: AsyncIterable[Any],
- request: Mapping[str, Any],
+ request: OpenAIResponsesRequest,
) -> AsyncIterator[str]:
"""Yield Responses SSE events translated from an Anthropic SSE stream."""
diff --git a/src/free_claude_code/core/openai_responses/streaming/assembler.py b/src/free_claude_code/core/openai_responses/streaming/assembler.py
index 3dd1e93e..535fd5bd 100644
--- a/src/free_claude_code/core/openai_responses/streaming/assembler.py
+++ b/src/free_claude_code/core/openai_responses/streaming/assembler.py
@@ -16,6 +16,7 @@ from ..ids import (
new_reasoning_item_id,
new_response_id,
)
+from ..models import OpenAIResponsesRequest
from ..tools import responses_tool_identity_from_anthropic_name
from . import event_builders as events
from .blocks import ReasoningBlockState, TextBlockState, ToolBlockState
@@ -30,7 +31,7 @@ from .ledger import ResponsesOutputLedger
class ResponsesStreamAssembler:
"""Assemble Responses SSE events from indexed Anthropic content blocks."""
- def __init__(self, request: Mapping[str, Any]) -> None:
+ def __init__(self, request: OpenAIResponsesRequest) -> None:
self._request = request
self._response_id = new_response_id()
self._created_at = int(time.time())
@@ -77,13 +78,21 @@ class ResponsesStreamAssembler:
"object": "response",
"created_at": self._created_at,
"status": status,
- "model": str(self._request.get("model", "")),
+ "model": self._request.model,
"output": self._ledger.output(),
- "parallel_tool_calls": bool(self._request.get("parallel_tool_calls", True)),
- "tool_choice": self._request.get("tool_choice", "auto"),
- "temperature": self._request.get("temperature"),
- "top_p": self._request.get("top_p"),
- "max_output_tokens": self._request.get("max_output_tokens"),
+ "parallel_tool_calls": (
+ True
+ if self._request.parallel_tool_calls is None
+ else self._request.parallel_tool_calls
+ ),
+ "tool_choice": (
+ "auto"
+ if self._request.tool_choice is None
+ else self._request.tool_choice
+ ),
+ "temperature": self._request.temperature,
+ "top_p": self._request.top_p,
+ "max_output_tokens": self._request.max_output_tokens,
"usage": self._ledger.usage(),
"error": error,
}
@@ -248,7 +257,7 @@ class ResponsesStreamAssembler:
if self.terminal:
return chunks
identity = responses_tool_identity_from_anthropic_name(
- self._request, _string_value(block.get("name"))
+ self._request.tools, _string_value(block.get("name"))
)
state = ToolBlockState(
index=index,
diff --git a/src/free_claude_code/core/openai_responses/tools.py b/src/free_claude_code/core/openai_responses/tools.py
index 8b898e64..259e75e7 100644
--- a/src/free_claude_code/core/openai_responses/tools.py
+++ b/src/free_claude_code/core/openai_responses/tools.py
@@ -122,12 +122,11 @@ def responses_tool_name_to_anthropic_name(
def responses_tool_identity_from_anthropic_name(
- request: Mapping[str, Any], anthropic_name: str
+ tools: list[dict[str, Any]] | None, anthropic_name: str
) -> ResponsesToolIdentity:
"""Return the Responses namespace/name represented by an Anthropic tool name."""
- tools = request.get("tools")
- if not isinstance(tools, list):
+ if tools is None:
return ResponsesToolIdentity(kind="function", name=anthropic_name)
for tool in tools:
if not isinstance(tool, dict):
diff --git a/src/free_claude_code/core/trace.py b/src/free_claude_code/core/trace.py
index 471f0392..9eb822a3 100644
--- a/src/free_claude_code/core/trace.py
+++ b/src/free_claude_code/core/trace.py
@@ -30,7 +30,7 @@ _SECRET_VALUE_KEYS = frozenset(
)
-def _sanitize_trace_value(obj: Any) -> Any:
+def sanitize_trace_value(obj: Any) -> Any:
"""Recursively copy JSON-like structures redacting credential-shaped keys."""
if isinstance(obj, Mapping):
out: dict[str, Any] = {}
@@ -38,16 +38,16 @@ def _sanitize_trace_value(obj: Any) -> Any:
if str(k).lower() in _SECRET_VALUE_KEYS:
out[str(k)] = "<redacted>"
else:
- out[str(k)] = _sanitize_trace_value(v)
+ out[str(k)] = sanitize_trace_value(v)
return out
if isinstance(obj, tuple | list):
- return [_sanitize_trace_value(x) for x in obj]
+ return [sanitize_trace_value(x) for x in obj]
return obj
def trace_event(*, stage: str, event: str, source: str, **fields: Any) -> None:
"""Emit one structured TRACE row (merged into JSON by the log sink)."""
- payload = _sanitize_trace_value(
+ payload = sanitize_trace_value(
{
"stage": stage,
"event": event,
@@ -58,37 +58,6 @@ def trace_event(*, stage: str, event: str, source: str, **fields: Any) -> None:
logger.bind(trace_payload=payload).info("TRACE {}", event)
-def api_messages_request_snapshot(req: Any) -> dict[str, Any]:
- """Return a sanitized snapshot of an Anthropic ``MessagesRequest``-like body."""
- if hasattr(req, "model_dump"):
- data = req.model_dump(mode="python")
- elif isinstance(req, Mapping):
- data = dict(req)
- else:
- data = {}
-
- snapshot: dict[str, Any] = {}
- for key in (
- "model",
- "messages",
- "system",
- "tools",
- "tool_choice",
- "max_tokens",
- "thinking",
- "temperature",
- "top_p",
- "top_k",
- "stop_sequences",
- "metadata",
- "stream",
- "thinking_enabled",
- ):
- if key in data and data[key] is not None:
- snapshot[key] = data[key]
- return _sanitize_trace_value(snapshot)
-
-
def extract_claude_session_id_from_headers(headers: Mapping[str, str]) -> str | None:
"""Best-effort session id forwarded by Claude Code / SDK via HTTP."""
lowered = {str(k).lower(): v for k, v in headers.items() if isinstance(v, str)}
@@ -191,7 +160,7 @@ def provider_chat_body_snapshot(body: Mapping[str, Any]) -> dict[str, Any]:
"""Sanitized OpenAI-compat chat body subset for traces (conversation text verbatim)."""
keys = ("model", "messages", "tools", "tool_choice", "temperature", "max_tokens")
snap = {k: body[k] for k in keys if k in body and body[k] is not None}
- return _sanitize_trace_value(snap)
+ return sanitize_trace_value(snap)
def provider_native_messages_body_snapshot(body: Mapping[str, Any]) -> dict[str, Any]:
@@ -211,4 +180,4 @@ def provider_native_messages_body_snapshot(body: Mapping[str, Any]) -> dict[str,
"stop_sequences",
)
snap = {k: body[k] for k in keys if k in body and body[k] is not None}
- return _sanitize_trace_value(snap)
+ return sanitize_trace_value(snap)
diff --git a/src/free_claude_code/providers/base.py b/src/free_claude_code/providers/base.py
index 0d90c8f0..f471d951 100644
--- a/src/free_claude_code/providers/base.py
+++ b/src/free_claude_code/providers/base.py
@@ -2,11 +2,11 @@
from abc import ABC, abstractmethod
from collections.abc import AsyncIterator
-from typing import Any
from pydantic import BaseModel
from free_claude_code.config.constants import HTTP_CONNECT_TIMEOUT_DEFAULT
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.model_listing import (
ProviderModelInfo,
model_infos_from_ids,
@@ -41,10 +41,10 @@ class BaseProvider(ABC):
self._config = config
def _is_thinking_enabled(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> bool:
"""Return whether thinking should be enabled for this request."""
- thinking = getattr(request, "thinking", None)
+ thinking = request.thinking
config_enabled = (
self._config.enable_thinking
if thinking_enabled is None
@@ -52,30 +52,14 @@ class BaseProvider(ABC):
)
request_enabled = True
if thinking is not None:
- thinking_type = (
- thinking.get("type")
- if isinstance(thinking, dict)
- else getattr(thinking, "type", None)
- )
- if isinstance(thinking, dict):
- enabled = thinking.get("enabled")
- enabled_supplied = "enabled" in thinking
- else:
- enabled = getattr(thinking, "enabled", None)
- fields_set = getattr(thinking, "model_fields_set", None)
- enabled_supplied = (
- "enabled" in fields_set
- if isinstance(fields_set, set | frozenset)
- else enabled is not None
- )
- if enabled_supplied and enabled is not None:
- request_enabled = bool(enabled)
- if thinking_type == "disabled":
+ if "enabled" in thinking.model_fields_set and thinking.enabled is not None:
+ request_enabled = thinking.enabled
+ if thinking.type == "disabled":
request_enabled = False
return config_enabled and request_enabled
def preflight_stream(
- self, request: Any, *, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, *, thinking_enabled: bool | None = None
) -> None:
"""Eagerly validate/build the upstream request before opening an SSE stream.
@@ -146,7 +130,7 @@ class BaseProvider(ABC):
@abstractmethod
async def stream_response(
self,
- request: Any,
+ request: MessagesRequest,
input_tokens: int = 0,
*,
request_id: str | None = None,
diff --git a/src/free_claude_code/providers/cerebras/client.py b/src/free_claude_code/providers/cerebras/client.py
index 9fbbfdf2..2e828d95 100644
--- a/src/free_claude_code/providers/cerebras/client.py
+++ b/src/free_claude_code/providers/cerebras/client.py
@@ -1,7 +1,6 @@
"""Cerebras Inference provider (OpenAI-compatible chat completions)."""
-from typing import Any
-
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import CEREBRAS_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -31,7 +30,7 @@ class CerebrasProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/cloudflare/client.py b/src/free_claude_code/providers/cloudflare/client.py
index 493880d7..f8d73f99 100644
--- a/src/free_claude_code/providers/cloudflare/client.py
+++ b/src/free_claude_code/providers/cloudflare/client.py
@@ -6,6 +6,7 @@ from urllib.parse import quote
import httpx
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import CLOUDFLARE_AI_REST_ROOT
from free_claude_code.providers.exceptions import (
@@ -119,7 +120,7 @@ class CloudflareProvider(OpenAIChatTransport):
await maybe_await_aclose(response)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
@@ -143,7 +144,7 @@ class CloudflareProvider(OpenAIChatTransport):
def _apply_cloudflare_request_quirks(
- body: dict[str, Any], _request: Any, thinking_enabled: bool
+ body: dict[str, Any], _request: MessagesRequest, thinking_enabled: bool
) -> None:
"""Attach Cloudflare Workers AI chat-template thinking control."""
extra_body = body.setdefault("extra_body", {})
diff --git a/src/free_claude_code/providers/codestral/client.py b/src/free_claude_code/providers/codestral/client.py
index 3bbb1bc9..3a45f160 100644
--- a/src/free_claude_code/providers/codestral/client.py
+++ b/src/free_claude_code/providers/codestral/client.py
@@ -1,7 +1,6 @@
"""Mistral Codestral provider (OpenAI-compatible chat on codestral.mistral.ai)."""
-from typing import Any
-
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import CODESTRAL_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -31,7 +30,7 @@ class CodestralProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/cohere/client.py b/src/free_claude_code/providers/cohere/client.py
index 4ee70798..3cfc03b8 100644
--- a/src/free_claude_code/providers/cohere/client.py
+++ b/src/free_claude_code/providers/cohere/client.py
@@ -4,6 +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.providers.base import ProviderConfig
from free_claude_code.providers.defaults import COHERE_DEFAULT_BASE
from free_claude_code.providers.exceptions import InvalidRequestError
@@ -55,7 +56,7 @@ class CohereProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
@@ -66,9 +67,9 @@ class CohereProvider(OpenAIChatTransport):
def _apply_cohere_request_quirks(
- body: dict[str, Any], request_data: Any, thinking_enabled: bool
+ body: dict[str, Any], request_data: MessagesRequest, thinking_enabled: bool
) -> None:
- _merge_allowed_extra_body(body, getattr(request_data, "extra_body", None))
+ _merge_allowed_extra_body(body, request_data.extra_body)
body["reasoning_effort"] = "high" if thinking_enabled else "none"
diff --git a/src/free_claude_code/providers/deepseek/client.py b/src/free_claude_code/providers/deepseek/client.py
index ec70b8dc..9510d0b5 100644
--- a/src/free_claude_code/providers/deepseek/client.py
+++ b/src/free_claude_code/providers/deepseek/client.py
@@ -2,6 +2,7 @@
from typing import Any
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import DEEPSEEK_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -24,7 +25,7 @@ class DeepSeekProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_deepseek_request_body(
request,
diff --git a/src/free_claude_code/providers/deepseek/compat.py b/src/free_claude_code/providers/deepseek/compat.py
index 3f813ea0..c379fec8 100644
--- a/src/free_claude_code/providers/deepseek/compat.py
+++ b/src/free_claude_code/providers/deepseek/compat.py
@@ -1,13 +1,13 @@
"""DeepSeek Anthropic-to-OpenAI chat request policy."""
from collections.abc import Mapping
-from types import SimpleNamespace
from typing import Any
from loguru import logger
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
from free_claude_code.core.anthropic import serialize_tool_result_content
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.native_messages_request import (
dump_raw_messages_request,
)
@@ -38,12 +38,14 @@ _OMITTED_ATTACHMENT_TEXT = (
_OMITTED_ATTACHMENT_BLOCK = {"type": "text", "text": _OMITTED_ATTACHMENT_TEXT}
-def build_deepseek_request_body(request_data: Any, *, thinking_enabled: bool) -> dict:
+def build_deepseek_request_body(
+ request_data: MessagesRequest, *, thinking_enabled: bool
+) -> dict:
"""Build a DeepSeek Chat Completions body from an Anthropic request."""
logger.debug(
"DEEPSEEK_REQUEST: chat build model={} msgs={}",
- getattr(request_data, "model", "?"),
- len(getattr(request_data, "messages", [])),
+ request_data.model,
+ len(request_data.messages),
)
data = dump_raw_messages_request(request_data)
@@ -91,7 +93,7 @@ def build_deepseek_request_body(request_data: Any, *, thinking_enabled: bool) ->
)
)
- sanitized_request = _request_from_dict(request_data, data)
+ sanitized_request = MessagesRequest.model_validate(data)
body = build_openai_chat_request_body(
sanitized_request,
thinking_enabled=effective_thinking_enabled,
@@ -420,15 +422,8 @@ def _downgrade_forced_tool_choice(data: dict[str, Any]) -> None:
data["tool_choice"] = {"type": "auto"}
-def _request_from_dict(request_data: Any, data: dict[str, Any]) -> Any:
- validator = getattr(type(request_data), "model_validate", None)
- if callable(validator):
- return validator(data)
- return SimpleNamespace(**data)
-
-
def _apply_deepseek_chat_extras(
- body: dict[str, Any], _request_data: Any, thinking_enabled: bool
+ body: dict[str, Any], _request_data: MessagesRequest, thinking_enabled: bool
) -> None:
if not thinking_enabled or body.get("model") == "deepseek-reasoner":
return
diff --git a/src/free_claude_code/providers/fireworks/client.py b/src/free_claude_code/providers/fireworks/client.py
index b5371096..7a7bcf55 100644
--- a/src/free_claude_code/providers/fireworks/client.py
+++ b/src/free_claude_code/providers/fireworks/client.py
@@ -1,8 +1,7 @@
"""Fireworks AI provider using OpenAI-compatible Chat Completions."""
-from typing import Any
-
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import FIREWORKS_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -38,7 +37,7 @@ class FireworksProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/gemini/client.py b/src/free_claude_code/providers/gemini/client.py
index 8f199ddc..91dbd8e4 100644
--- a/src/free_claude_code/providers/gemini/client.py
+++ b/src/free_claude_code/providers/gemini/client.py
@@ -3,6 +3,7 @@
from copy import deepcopy
from typing import Any
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import GEMINI_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -45,7 +46,7 @@ class GeminiProvider(OpenAIChatTransport):
self._tool_call_extra_content_by_id[tool_call_id] = deepcopy(extra_content)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/gemini/quirks.py b/src/free_claude_code/providers/gemini/quirks.py
index 4aceb55c..6e238c6d 100644
--- a/src/free_claude_code/providers/gemini/quirks.py
+++ b/src/free_claude_code/providers/gemini/quirks.py
@@ -3,19 +3,21 @@
from copy import deepcopy
from typing import Any, cast
+from free_claude_code.core.anthropic.models import MessagesRequest
+
GEMINI_SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator"
def apply_gemini_request_quirks(
body: dict[str, Any],
- request_data: Any,
+ request_data: MessagesRequest,
thinking_enabled: bool,
*,
tool_call_extra_content_by_id: dict[str, dict[str, Any]] | None = None,
) -> None:
"""Apply Google-specific request extensions after common OpenAI conversion."""
extra_body: dict[str, Any] = {}
- request_extra = getattr(request_data, "extra_body", None)
+ request_extra = request_data.extra_body
if isinstance(request_extra, dict):
extra_body.update(deepcopy(request_extra))
diff --git a/src/free_claude_code/providers/github_models/client.py b/src/free_claude_code/providers/github_models/client.py
index d4bdeeff..a6fc61ed 100644
--- a/src/free_claude_code/providers/github_models/client.py
+++ b/src/free_claude_code/providers/github_models/client.py
@@ -5,6 +5,7 @@ from typing import Any
import httpx
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import GITHUB_MODELS_DEFAULT_BASE
from free_claude_code.providers.exceptions import ModelListResponseError
@@ -82,7 +83,7 @@ class GitHubModelsProvider(OpenAIChatTransport):
await maybe_await_aclose(response)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/groq/client.py b/src/free_claude_code/providers/groq/client.py
index 630f6f93..c7efcdbf 100644
--- a/src/free_claude_code/providers/groq/client.py
+++ b/src/free_claude_code/providers/groq/client.py
@@ -1,7 +1,6 @@
"""Groq provider implementation (OpenAI-compatible chat completions)."""
-from typing import Any
-
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import GROQ_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -34,7 +33,7 @@ class GroqProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/huggingface/client.py b/src/free_claude_code/providers/huggingface/client.py
index 7fff4640..2e2b7800 100644
--- a/src/free_claude_code/providers/huggingface/client.py
+++ b/src/free_claude_code/providers/huggingface/client.py
@@ -1,10 +1,10 @@
"""Hugging Face Inference Providers implementation."""
from copy import deepcopy
-from typing import Any
from free_claude_code.core.anthropic import 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.providers.base import ProviderConfig
from free_claude_code.providers.defaults import HUGGINGFACE_DEFAULT_BASE
from free_claude_code.providers.exceptions import InvalidRequestError
@@ -25,7 +25,7 @@ class HuggingFaceProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
"""Build a Hugging Face Chat Completions body.
@@ -42,7 +42,7 @@ class HuggingFaceProvider(OpenAIChatTransport):
except OpenAIConversionError as exc:
raise InvalidRequestError(str(exc)) from exc
- request_extra = getattr(request, "extra_body", None)
+ request_extra = request.extra_body
if isinstance(request_extra, dict) and request_extra:
body["extra_body"] = deepcopy(request_extra)
diff --git a/src/free_claude_code/providers/kimi/client.py b/src/free_claude_code/providers/kimi/client.py
index 530ab425..8e412a6b 100644
--- a/src/free_claude_code/providers/kimi/client.py
+++ b/src/free_claude_code/providers/kimi/client.py
@@ -3,6 +3,7 @@
from typing import Any
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import KIMI_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -34,7 +35,7 @@ class KimiProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
effective_thinking_enabled = self._is_thinking_enabled(
request, thinking_enabled
@@ -48,7 +49,7 @@ class KimiProvider(OpenAIChatTransport):
def _apply_kimi_thinking_policy(
- body: dict[str, Any], _request: Any, thinking_enabled: bool
+ body: dict[str, Any], _request: MessagesRequest, thinking_enabled: bool
) -> None:
if thinking_enabled:
return
diff --git a/src/free_claude_code/providers/lmstudio/client.py b/src/free_claude_code/providers/lmstudio/client.py
index 6240cf30..071b9a11 100644
--- a/src/free_claude_code/providers/lmstudio/client.py
+++ b/src/free_claude_code/providers/lmstudio/client.py
@@ -12,7 +12,6 @@ heuristic recovery on top.
"""
import time
-from typing import Any
import httpx
from loguru import logger
@@ -23,6 +22,7 @@ from free_claude_code.core.anthropic import (
get_token_count,
)
from free_claude_code.core.anthropic.conversion import OpenAIConversionError
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import LMSTUDIO_DEFAULT_BASE
from free_claude_code.providers.exceptions import InvalidRequestError
@@ -51,7 +51,7 @@ class LMStudioProvider(OpenAIChatTransport):
self._loaded_context_cache: tuple[float, int | None] = (0.0, None)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
"""Build an OpenAI chat body from the Anthropic request.
@@ -69,19 +69,19 @@ class LMStudioProvider(OpenAIChatTransport):
raise InvalidRequestError(str(exc)) from exc
def preflight_stream(
- self, request: Any, *, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, *, thinking_enabled: bool | None = None
) -> None:
super().preflight_stream(request, thinking_enabled=thinking_enabled)
self._preflight_context_budget(request)
- def _preflight_context_budget(self, request: Any) -> None:
+ def _preflight_context_budget(self, request: MessagesRequest) -> None:
loaded_context = self._loaded_context_length()
if loaded_context is None:
return
estimate = get_token_count(
- getattr(request, "messages", []) or [],
- getattr(request, "system", None),
- getattr(request, "tools", None),
+ request.messages,
+ request.system,
+ request.tools,
)
# The estimate is cl100k-based and undercounts local tokenizers
# (observed ~8% low vs devstral); a request above 90% of the loaded
diff --git a/src/free_claude_code/providers/minimax/client.py b/src/free_claude_code/providers/minimax/client.py
index d59153bf..a97a94c9 100644
--- a/src/free_claude_code/providers/minimax/client.py
+++ b/src/free_claude_code/providers/minimax/client.py
@@ -3,6 +3,7 @@
from typing import Any
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import MINIMAX_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -32,7 +33,7 @@ class MiniMaxProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
effective_thinking_enabled = self._is_thinking_enabled(
request, thinking_enabled
@@ -46,7 +47,7 @@ class MiniMaxProvider(OpenAIChatTransport):
def _apply_minimax_thinking_policy(
- body: dict[str, Any], _request: Any, thinking_enabled: bool
+ body: dict[str, Any], _request: MessagesRequest, thinking_enabled: bool
) -> None:
extra_body = body.setdefault("extra_body", {})
if not isinstance(extra_body, dict):
diff --git a/src/free_claude_code/providers/mistral/client.py b/src/free_claude_code/providers/mistral/client.py
index 15731329..3a2839b4 100644
--- a/src/free_claude_code/providers/mistral/client.py
+++ b/src/free_claude_code/providers/mistral/client.py
@@ -4,6 +4,7 @@ from typing import Any
from loguru import logger
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import MISTRAL_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -36,7 +37,7 @@ class MistralProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
effective_thinking_enabled = self._is_thinking_enabled(
request, thinking_enabled
diff --git a/src/free_claude_code/providers/nvidia_nim/client.py b/src/free_claude_code/providers/nvidia_nim/client.py
index 61cd6db4..0adc3f65 100644
--- a/src/free_claude_code/providers/nvidia_nim/client.py
+++ b/src/free_claude_code/providers/nvidia_nim/client.py
@@ -7,6 +7,7 @@ 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.providers.base import ProviderConfig
from free_claude_code.providers.defaults import NVIDIA_NIM_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -44,7 +45,7 @@ class NvidiaNimProvider(OpenAIChatTransport):
self._nim_settings = nim_settings
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
"""Internal helper for tests and shared building."""
return build_nim_request_body(
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 5179cecc..532d9002 100644
--- a/src/free_claude_code/providers/nvidia_nim/request_options.py
+++ b/src/free_claude_code/providers/nvidia_nim/request_options.py
@@ -4,6 +4,7 @@ from typing import Any
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
from free_claude_code.providers.transports.openai_chat import (
OpenAIChatRequestPolicy,
build_openai_chat_request_body,
@@ -15,7 +16,7 @@ _REQUEST_POLICY = OpenAIChatRequestPolicy(provider_name="NIM")
def build_nim_request_body(
- request_data: Any, nim: NimSettings, *, thinking_enabled: bool
+ request_data: MessagesRequest, nim: NimSettings, *, thinking_enabled: bool
) -> dict[str, Any]:
"""Build OpenAI-format request body from Anthropic request plus NIM settings."""
return build_openai_chat_request_body(
@@ -35,7 +36,7 @@ def build_nim_request_body(
def apply_nim_request_options(
body: dict[str, Any],
- request_data: Any,
+ request_data: MessagesRequest,
thinking_enabled: bool,
*,
nim: NimSettings,
@@ -43,7 +44,7 @@ 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 getattr(request_data, "max_tokens", None)
+ max_tokens = body.get("max_tokens") or request_data.max_tokens
if max_tokens is None:
max_tokens = nim.max_tokens
elif nim.max_tokens:
@@ -68,7 +69,7 @@ def apply_nim_request_options(
body["parallel_tool_calls"] = nim.parallel_tool_calls
extra_body: dict[str, Any] = {}
- request_extra = getattr(request_data, "extra_body", None)
+ request_extra = request_data.extra_body
if request_extra:
extra_body.update(request_extra)
@@ -79,7 +80,7 @@ def apply_nim_request_options(
if isinstance(chat_template_kwargs, dict):
chat_template_kwargs.setdefault("reasoning_budget", max_tokens)
- req_top_k = getattr(request_data, "top_k", None)
+ req_top_k = request_data.top_k
top_k = req_top_k if req_top_k is not None else nim.top_k
_set_extra(extra_body, "top_k", top_k, ignore_value=-1)
_set_extra(extra_body, "min_p", nim.min_p, ignore_value=0.0)
diff --git a/src/free_claude_code/providers/open_router/client.py b/src/free_claude_code/providers/open_router/client.py
index b2bd5ddc..de694177 100644
--- a/src/free_claude_code/providers/open_router/client.py
+++ b/src/free_claude_code/providers/open_router/client.py
@@ -5,6 +5,7 @@ from collections.abc import Iterator, Mapping, Sequence
from typing import Any
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest, ThinkingConfig
from free_claude_code.core.anthropic.streaming import AnthropicStreamLedger
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import OPENROUTER_DEFAULT_BASE
@@ -44,7 +45,7 @@ class OpenRouterProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
effective_thinking_enabled = self._is_thinking_enabled(
request, thinking_enabled
@@ -83,7 +84,7 @@ class OpenRouterProvider(OpenAIChatTransport):
def _apply_openrouter_reasoning_policy(
- body: dict[str, Any], request: Any, thinking_enabled: bool
+ body: dict[str, Any], request: MessagesRequest, thinking_enabled: bool
) -> None:
if not thinking_enabled:
return
@@ -94,17 +95,17 @@ def _apply_openrouter_reasoning_policy(
if not isinstance(reasoning, dict):
return
reasoning.setdefault("enabled", True)
- budget_tokens = _thinking_budget_tokens(getattr(request, "thinking", None))
+ budget_tokens = _thinking_budget_tokens(request.thinking)
if isinstance(budget_tokens, int):
reasoning.setdefault("max_tokens", budget_tokens)
def _apply_openrouter_reasoning_details_replay(
- body: dict[str, Any], request: Any, thinking_enabled: bool
+ body: dict[str, Any], request: MessagesRequest, thinking_enabled: bool
) -> None:
if not thinking_enabled:
return
- assistant_details = _assistant_reasoning_details(getattr(request, "messages", []))
+ assistant_details = _assistant_reasoning_details(request.messages)
if not assistant_details:
return
messages = body.get("messages")
@@ -159,11 +160,8 @@ def _redacted_reasoning_details(content: Any) -> list[dict[str, Any]]:
return details
-def _thinking_budget_tokens(thinking: Any) -> int | None:
- if isinstance(thinking, Mapping):
- value = thinking.get("budget_tokens")
- else:
- value = getattr(thinking, "budget_tokens", None)
+def _thinking_budget_tokens(thinking: ThinkingConfig | None) -> int | None:
+ value = thinking.budget_tokens if thinking is not None else None
return value if isinstance(value, int) and not isinstance(value, bool) else None
diff --git a/src/free_claude_code/providers/opencode/client.py b/src/free_claude_code/providers/opencode/client.py
index aa7c6d1d..2e37d8d7 100644
--- a/src/free_claude_code/providers/opencode/client.py
+++ b/src/free_claude_code/providers/opencode/client.py
@@ -1,7 +1,6 @@
"""OpenCode Zen provider implementation (OpenAI-compatible Chat Completions)."""
-from typing import Any
-
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import OPENCODE_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -32,7 +31,7 @@ class OpenCodeProvider(OpenAIChatTransport):
self._request_policy = OpenAIChatRequestPolicy(provider_name=provider_name)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/sambanova/client.py b/src/free_claude_code/providers/sambanova/client.py
index 094b0c62..94d210c8 100644
--- a/src/free_claude_code/providers/sambanova/client.py
+++ b/src/free_claude_code/providers/sambanova/client.py
@@ -1,7 +1,6 @@
"""SambaNova Cloud provider implementation (OpenAI-compatible chat completions)."""
-from typing import Any
-
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import SAMBANOVA_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -30,7 +29,7 @@ class SambaNovaProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/transports/anthropic_messages/recovery.py b/src/free_claude_code/providers/transports/anthropic_messages/recovery.py
index 3e974d70..112a99ab 100644
--- a/src/free_claude_code/providers/transports/anthropic_messages/recovery.py
+++ b/src/free_claude_code/providers/transports/anthropic_messages/recovery.py
@@ -5,6 +5,7 @@ from typing import Any
import httpx
+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.anthropic.streaming import (
MIDSTREAM_RECOVERY_ATTEMPTS,
@@ -51,9 +52,7 @@ class AnthropicMessagesRecovery:
response = await self._transport._rate_limiter.execute_with_retry(
self._transport._validated_stream_send, body, req_tag=req_tag
)
- state = self._transport._new_stream_state(
- None, thinking_enabled=thinking_enabled
- )
+ state = self._transport._new_stream_state()
chunks = [
chunk
async for chunk in self._iter_stream_chunks(
@@ -115,7 +114,7 @@ class AnthropicMessagesRecovery:
self,
*,
body: dict[str, Any],
- request: Any,
+ request: MessagesRequest,
ledger: AnthropicStreamLedger,
error: Exception,
request_id: str | None,
diff --git a/src/free_claude_code/providers/transports/anthropic_messages/request_policy.py b/src/free_claude_code/providers/transports/anthropic_messages/request_policy.py
index 2da8cf48..ad92beab 100644
--- a/src/free_claude_code/providers/transports/anthropic_messages/request_policy.py
+++ b/src/free_claude_code/providers/transports/anthropic_messages/request_policy.py
@@ -7,13 +7,14 @@ from typing import Any, Literal
from loguru import logger
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.native_messages_request import (
build_base_native_anthropic_request_body,
)
from free_claude_code.providers.exceptions import InvalidRequestError
NativeExtraBodyPolicy = Literal["drop", "reject"]
-NativeMessagesPostprocessor = Callable[[dict[str, Any], Any, bool], None]
+NativeMessagesPostprocessor = Callable[[dict[str, Any], MessagesRequest, bool], None]
@dataclass(frozen=True, slots=True)
@@ -28,7 +29,7 @@ class NativeMessagesRequestPolicy:
def build_native_messages_request_body(
- request_data: Any,
+ request_data: MessagesRequest,
*,
thinking_enabled: bool,
policy: NativeMessagesRequestPolicy,
@@ -38,8 +39,8 @@ def build_native_messages_request_body(
logger.debug(
"{}_REQUEST: native build model={} msgs={}",
policy.provider_name,
- getattr(request_data, "model", "?"),
- len(getattr(request_data, "messages", [])),
+ request_data.model,
+ len(request_data.messages),
)
body = build_base_native_anthropic_request_body(
@@ -66,10 +67,10 @@ def build_native_messages_request_body(
def _apply_extra_body_policy(
body: dict[str, Any],
- request_data: Any,
+ request_data: MessagesRequest,
policy: NativeMessagesRequestPolicy,
) -> None:
- extra = getattr(request_data, "extra_body", None)
+ extra = request_data.extra_body
if not extra:
return
diff --git a/src/free_claude_code/providers/transports/anthropic_messages/stream.py b/src/free_claude_code/providers/transports/anthropic_messages/stream.py
index 2d9fa89d..041cb207 100644
--- a/src/free_claude_code/providers/transports/anthropic_messages/stream.py
+++ b/src/free_claude_code/providers/transports/anthropic_messages/stream.py
@@ -5,6 +5,7 @@ from typing import Any
import httpx
+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.anthropic.streaming import (
AnthropicStreamLedger,
@@ -44,7 +45,7 @@ class AnthropicMessagesStreamAdapter:
self,
transport: Any,
*,
- request: Any,
+ request: MessagesRequest,
input_tokens: int,
request_id: str | None,
thinking_enabled: bool | None,
@@ -85,9 +86,7 @@ class AnthropicMessagesStreamAdapter:
response: httpx.Response | None = None
sent_any_event = False
- state = self._transport._new_stream_state(
- self._request, thinking_enabled=thinking_enabled
- )
+ state = self._transport._new_stream_state()
ledger = self._new_ledger()
recovery = RecoveryController(provider_name=tag, request_id=self._request_id)
@@ -171,9 +170,7 @@ class AnthropicMessagesStreamAdapter:
if response is not None and not response.is_closed:
await maybe_await_aclose(response)
response = None
- state = self._transport._new_stream_state(
- self._request, thinking_enabled=thinking_enabled
- )
+ state = self._transport._new_stream_state()
ledger = self._new_ledger()
sent_any_event = False
continue
diff --git a/src/free_claude_code/providers/transports/anthropic_messages/transport.py b/src/free_claude_code/providers/transports/anthropic_messages/transport.py
index 6c74338f..263d0195 100644
--- a/src/free_claude_code/providers/transports/anthropic_messages/transport.py
+++ b/src/free_claude_code/providers/transports/anthropic_messages/transport.py
@@ -5,6 +5,7 @@ from typing import Any, Literal
import httpx
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.native_sse_block_policy import (
NativeSseBlockPolicyState,
transform_native_sse_block_event,
@@ -110,7 +111,7 @@ class AnthropicMessagesTransport(BaseProvider):
return {"Content-Type": "application/json"}
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
"""Build a native Anthropic request body."""
thinking_enabled = self._is_thinking_enabled(request, thinking_enabled)
@@ -120,7 +121,7 @@ class AnthropicMessagesTransport(BaseProvider):
)
def _build_request_body_with_resolved_thinking(
- self, request: Any, *, thinking_enabled: bool
+ self, request: MessagesRequest, *, thinking_enabled: bool
) -> dict:
"""Build a native Anthropic request body after thinking is resolved."""
return build_native_messages_request_body(
@@ -154,7 +155,7 @@ class AnthropicMessagesTransport(BaseProvider):
log_api_error_tracebacks=self._config.log_api_error_tracebacks,
)
- def _new_stream_state(self, request: Any, *, thinking_enabled: bool) -> Any:
+ def _new_stream_state(self) -> NativeSseBlockPolicyState | None:
"""Return per-stream provider state for event transformation."""
if self.stream_chunk_mode == "line":
return NativeSseBlockPolicyState()
@@ -205,7 +206,7 @@ class AnthropicMessagesTransport(BaseProvider):
async def stream_response(
self,
- request: Any,
+ request: MessagesRequest,
input_tokens: int = 0,
*,
request_id: str | None = None,
diff --git a/src/free_claude_code/providers/transports/openai_chat/recovery.py b/src/free_claude_code/providers/transports/openai_chat/recovery.py
index 812ff1f5..e38b9fb5 100644
--- a/src/free_claude_code/providers/transports/openai_chat/recovery.py
+++ b/src/free_claude_code/providers/transports/openai_chat/recovery.py
@@ -3,6 +3,7 @@
from collections.abc import Awaitable, Callable
from typing import Any
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.streaming import (
MIDSTREAM_RECOVERY_ATTEMPTS,
AnthropicStreamLedger,
@@ -86,7 +87,7 @@ class OpenAIChatRecovery:
*,
body: dict[str, Any],
ledger: AnthropicStreamLedger,
- request: Any,
+ request: MessagesRequest,
request_id: str | None,
error: Exception,
tool_argument_alias_buffers: dict[int, str],
@@ -166,7 +167,7 @@ class OpenAIChatRecovery:
*,
body: dict[str, Any],
ledger: AnthropicStreamLedger,
- request: Any,
+ request: MessagesRequest,
tool_argument_alias_buffers: dict[int, str],
) -> list[str] | None:
schemas = tool_schemas_by_name(request)
diff --git a/src/free_claude_code/providers/transports/openai_chat/request_policy.py b/src/free_claude_code/providers/transports/openai_chat/request_policy.py
index 85e8d7eb..b70b4c88 100644
--- a/src/free_claude_code/providers/transports/openai_chat/request_policy.py
+++ b/src/free_claude_code/providers/transports/openai_chat/request_policy.py
@@ -9,10 +9,11 @@ from loguru import logger
from free_claude_code.core.anthropic import 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.providers.exceptions import InvalidRequestError
MaxTokensField = Literal["max_tokens", "max_completion_tokens"]
-OpenAIChatPostprocessor = Callable[[dict[str, Any], Any, bool], None]
+OpenAIChatPostprocessor = Callable[[dict[str, Any], MessagesRequest, bool], None]
ExtraBodyValidator = Callable[[dict[str, Any]], None]
@@ -32,7 +33,7 @@ class OpenAIChatRequestPolicy:
def build_openai_chat_request_body(
- request_data: Any,
+ request_data: MessagesRequest,
*,
thinking_enabled: bool,
policy: OpenAIChatRequestPolicy,
@@ -42,8 +43,8 @@ def build_openai_chat_request_body(
logger.debug(
"{}_REQUEST: conversion start model={} msgs={}",
policy.provider_name,
- getattr(request_data, "model", "?"),
- len(getattr(request_data, "messages", [])),
+ request_data.model,
+ len(request_data.messages),
)
try:
body = build_base_request_body(
@@ -56,7 +57,7 @@ def build_openai_chat_request_body(
except OpenAIConversionError as exc:
raise InvalidRequestError(str(exc)) from exc
- request_extra = getattr(request_data, "extra_body", None)
+ request_extra = request_data.extra_body
if isinstance(request_extra, dict) and request_extra:
if policy.reject_extra_body_message:
raise InvalidRequestError(policy.reject_extra_body_message)
diff --git a/src/free_claude_code/providers/transports/openai_chat/stream.py b/src/free_claude_code/providers/transports/openai_chat/stream.py
index 263e3b6c..3037e17f 100644
--- a/src/free_claude_code/providers/transports/openai_chat/stream.py
+++ b/src/free_claude_code/providers/transports/openai_chat/stream.py
@@ -12,6 +12,7 @@ from free_claude_code.core.anthropic import (
HeuristicToolParser,
ThinkTagParser,
)
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.streaming import (
AnthropicStreamLedger,
RecoveryController,
@@ -41,7 +42,7 @@ class OpenAIChatStreamAdapter:
self,
transport: Any,
*,
- request: Any,
+ request: MessagesRequest,
input_tokens: int,
request_id: str | None,
thinking_enabled: bool | None,
diff --git a/src/free_claude_code/providers/transports/openai_chat/tool_calls.py b/src/free_claude_code/providers/transports/openai_chat/tool_calls.py
index c719fa73..7c3d7e3e 100644
--- a/src/free_claude_code/providers/transports/openai_chat/tool_calls.py
+++ b/src/free_claude_code/providers/transports/openai_chat/tool_calls.py
@@ -5,6 +5,7 @@ import uuid
from collections.abc import Callable, Iterator
from typing import Any
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.streaming import (
AnthropicStreamLedger,
tool_schemas_by_name,
@@ -80,7 +81,9 @@ def started_tool_states(ledger: AnthropicStreamLedger) -> list[tuple[int, Any]]:
]
-def all_emitted_tools_complete(ledger: AnthropicStreamLedger, request: Any) -> bool:
+def all_emitted_tools_complete(
+ ledger: AnthropicStreamLedger, request: MessagesRequest
+) -> bool:
"""Return whether every emitted tool block has schema-valid input."""
return ledger.can_salvage_tool_use(tool_schemas_by_name(request))
diff --git a/src/free_claude_code/providers/transports/openai_chat/transport.py b/src/free_claude_code/providers/transports/openai_chat/transport.py
index ad818306..2c1feaed 100644
--- a/src/free_claude_code/providers/transports/openai_chat/transport.py
+++ b/src/free_claude_code/providers/transports/openai_chat/transport.py
@@ -8,6 +8,7 @@ import httpx
from loguru import logger
from openai import AsyncOpenAI
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.streaming import AnthropicStreamLedger
from free_claude_code.providers.base import BaseProvider, ProviderConfig
from free_claude_code.providers.error_mapping import (
@@ -82,7 +83,7 @@ class OpenAIChatTransport(BaseProvider):
@abstractmethod
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
"""Build request body. Must be implemented by subclasses."""
@@ -208,7 +209,7 @@ class OpenAIChatTransport(BaseProvider):
async def stream_response(
self,
- request: Any,
+ request: MessagesRequest,
input_tokens: int = 0,
*,
request_id: str | None = None,
diff --git a/src/free_claude_code/providers/vercel/client.py b/src/free_claude_code/providers/vercel/client.py
index 11235481..caaf2bef 100644
--- a/src/free_claude_code/providers/vercel/client.py
+++ b/src/free_claude_code/providers/vercel/client.py
@@ -1,7 +1,6 @@
"""Vercel AI Gateway provider implementation."""
-from typing import Any
-
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import VERCEL_AI_GATEWAY_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -30,7 +29,7 @@ class VercelProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return build_openai_chat_request_body(
request,
diff --git a/src/free_claude_code/providers/wafer/client.py b/src/free_claude_code/providers/wafer/client.py
index 54022b6e..873fddd2 100644
--- a/src/free_claude_code/providers/wafer/client.py
+++ b/src/free_claude_code/providers/wafer/client.py
@@ -3,6 +3,7 @@
from typing import Any
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import WAFER_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -31,7 +32,7 @@ class WaferProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
effective_thinking_enabled = self._is_thinking_enabled(
request, thinking_enabled
@@ -45,7 +46,7 @@ class WaferProvider(OpenAIChatTransport):
def _apply_wafer_thinking_policy(
- body: dict[str, Any], _request: Any, thinking_enabled: bool
+ body: dict[str, Any], _request: MessagesRequest, thinking_enabled: bool
) -> None:
extra_body = body.setdefault("extra_body", {})
if isinstance(extra_body, dict):
diff --git a/src/free_claude_code/providers/zai/client.py b/src/free_claude_code/providers/zai/client.py
index e5d85b57..47b31e68 100644
--- a/src/free_claude_code/providers/zai/client.py
+++ b/src/free_claude_code/providers/zai/client.py
@@ -3,6 +3,7 @@
from typing import Any
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import ZAI_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
@@ -34,7 +35,7 @@ class ZaiProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
effective_thinking_enabled = self._is_thinking_enabled(
request, thinking_enabled
@@ -48,7 +49,7 @@ class ZaiProvider(OpenAIChatTransport):
def _apply_zai_thinking_policy(
- body: dict[str, Any], _request: Any, thinking_enabled: bool
+ body: dict[str, Any], _request: MessagesRequest, thinking_enabled: bool
) -> None:
extra_body = body.setdefault("extra_body", {})
if not isinstance(extra_body, dict):
diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.py
index c8290820..baa756ac 100644
--- a/tests/api/test_api_handlers.py
+++ b/tests/api/test_api_handlers.py
@@ -11,14 +11,14 @@ from free_claude_code.api.handlers import (
ResponsesHandler,
TokenCountHandler,
)
-from free_claude_code.api.models.anthropic import (
+from free_claude_code.config.settings import Settings
+from free_claude_code.core.anthropic.models import (
Message,
MessagesRequest,
TokenCountRequest,
)
-from free_claude_code.api.models.openai_responses import OpenAIResponsesRequest
-from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic.streaming import format_sse_event
+from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.providers.base import BaseProvider, ProviderConfig
from free_claude_code.providers.exceptions import InvalidRequestError, RateLimitError
diff --git a/tests/api/test_detection.py b/tests/api/test_detection.py
index 2ad900a9..800e65b5 100644
--- a/tests/api/test_detection.py
+++ b/tests/api/test_detection.py
@@ -7,7 +7,7 @@ from free_claude_code.api.detection import (
is_prefix_detection_request,
is_safety_classifier_request,
)
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
def _make_request(content: str, **kwargs) -> MessagesRequest:
diff --git a/tests/api/test_model_router.py b/tests/api/test_model_router.py
index b0ce861c..65bd352f 100644
--- a/tests/api/test_model_router.py
+++ b/tests/api/test_model_router.py
@@ -3,12 +3,12 @@ from unittest.mock import patch
import pytest
from free_claude_code.api.model_router import ModelRouter
-from free_claude_code.api.models.anthropic import (
+from free_claude_code.config.settings import Settings
+from free_claude_code.core.anthropic.models import (
Message,
MessagesRequest,
TokenCountRequest,
)
-from free_claude_code.config.settings import Settings
@pytest.fixture
diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.py
index 98a210d1..6e619beb 100644
--- a/tests/api/test_openai_responses.py
+++ b/tests/api/test_openai_responses.py
@@ -99,6 +99,24 @@ def test_create_response_stream_routes_through_provider(
assert provider.stream_kwargs[0]["request_id"] == response.headers["request-id"]
+def test_create_response_accepts_unknown_top_level_extensions(
+ responses_client: tuple[TestClient, FakeProvider],
+) -> None:
+ client, provider = responses_client
+
+ response = client.post(
+ "/v1/responses",
+ json={
+ "model": "nvidia_nim/test-model",
+ "input": "Hello",
+ "provider_extension": {"enabled": True},
+ },
+ )
+
+ assert response.status_code == 200
+ assert provider.requests[0].messages[0].content == "Hello"
+
+
def test_create_response_pre_start_provider_error_returns_openai_error() -> None:
provider = PreStartFailingProvider()
app = create_test_app()
diff --git a/tests/api/test_optimization_handlers.py b/tests/api/test_optimization_handlers.py
index 32d494e4..b4d78285 100644
--- a/tests/api/test_optimization_handlers.py
+++ b/tests/api/test_optimization_handlers.py
@@ -2,11 +2,6 @@
from unittest.mock import patch
-from free_claude_code.api.models.anthropic import (
- ContentBlockText,
- Message,
- MessagesRequest,
-)
from free_claude_code.api.optimization_handlers import (
try_filepath_mock,
try_optimizations,
@@ -16,6 +11,11 @@ from free_claude_code.api.optimization_handlers import (
try_title_skip,
)
from free_claude_code.config.settings import Settings
+from free_claude_code.core.anthropic.models import (
+ ContentBlockText,
+ Message,
+ MessagesRequest,
+)
def _make_request(
diff --git a/tests/api/test_request_utils.py b/tests/api/test_request_utils.py
index e129c784..fb0d4c65 100644
--- a/tests/api/test_request_utils.py
+++ b/tests/api/test_request_utils.py
@@ -10,8 +10,8 @@ from free_claude_code.api.detection import (
is_quota_check_request,
is_title_generation_request,
)
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
from free_claude_code.core.anthropic import get_token_count
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
class TestQuotaCheckRequest:
diff --git a/tests/api/test_request_utils_filepaths_and_suggestions.py b/tests/api/test_request_utils_filepaths_and_suggestions.py
index 75b6e2ac..67a88ee4 100644
--- a/tests/api/test_request_utils_filepaths_and_suggestions.py
+++ b/tests/api/test_request_utils_filepaths_and_suggestions.py
@@ -7,7 +7,7 @@ from free_claude_code.api.detection import (
is_filepath_extraction_request,
is_suggestion_mode_request,
)
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
def _mk_req(messages, tools=None, system=None):
diff --git a/tests/api/test_safe_logging.py b/tests/api/test_safe_logging.py
index a0fc3aed..c47e3a25 100644
--- a/tests/api/test_safe_logging.py
+++ b/tests/api/test_safe_logging.py
@@ -8,9 +8,9 @@ from fastapi.responses import JSONResponse
from free_claude_code.api import provider_execution, request_errors
from free_claude_code.api.handlers import MessagesHandler, TokenCountHandler
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import AnthropicStreamLedger
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
@pytest.mark.asyncio
@@ -197,7 +197,7 @@ def test_count_tokens_unexpected_error_default_logs_exclude_exception_text():
settings,
token_counter=boom,
)
- from free_claude_code.api.models.anthropic import TokenCountRequest
+ from free_claude_code.core.anthropic.models import TokenCountRequest
req = TokenCountRequest(
model="claude-3-haiku-20240307",
diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.py
index bd0d477c..d6772e7b 100644
--- a/tests/api/test_web_server_tools.py
+++ b/tests/api/test_web_server_tools.py
@@ -13,7 +13,6 @@ from free_claude_code.api.model_router import (
ResolvedModel,
RoutedMessagesRequest,
)
-from free_claude_code.api.models.anthropic import Message, MessagesRequest, Tool
from free_claude_code.api.web_tools import egress as web_egress
from free_claude_code.api.web_tools.egress import (
WebFetchEgressPolicy,
@@ -29,6 +28,7 @@ from free_claude_code.api.web_tools.request import is_web_server_tool_request
from free_claude_code.api.web_tools.streaming import stream_web_server_tool_response
from free_claude_code.config.provider_catalog import PROVIDER_CATALOG
from free_claude_code.config.settings import Settings
+from free_claude_code.core.anthropic.models import Message, MessagesRequest, Tool
from free_claude_code.core.anthropic.stream_contracts import (
assert_anthropic_stream_contract,
parse_sse_text,
diff --git a/tests/contracts/test_import_boundaries.py b/tests/contracts/test_import_boundaries.py
index aa6faaef..db6487ee 100644
--- a/tests/contracts/test_import_boundaries.py
+++ b/tests/contracts/test_import_boundaries.py
@@ -123,6 +123,69 @@ def test_provider_adapters_do_not_import_runtime_layers() -> None:
assert offenders == []
+def test_anthropic_request_boundaries_use_the_protocol_model() -> None:
+ """Known Messages fields must not cross core/provider boundaries by duck typing."""
+ repo_root = Path(__file__).resolve().parents[2]
+ roots = [
+ repo_root / "src" / "free_claude_code" / "core" / "anthropic",
+ repo_root / "src" / "free_claude_code" / "providers",
+ ]
+ request_names = {"request", "request_data"}
+ protocol_fields = {
+ "extra_body",
+ "max_tokens",
+ "messages",
+ "model",
+ "stop_sequences",
+ "system",
+ "temperature",
+ "thinking",
+ "tool_choice",
+ "tools",
+ "top_k",
+ "top_p",
+ }
+ offenders: list[str] = []
+
+ for root in roots:
+ 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 isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+ arguments = [
+ *node.args.posonlyargs,
+ *node.args.args,
+ *node.args.kwonlyargs,
+ ]
+ for argument in arguments:
+ if argument.arg.lstrip("_") not in request_names:
+ continue
+ if isinstance(argument.annotation, ast.Name) and (
+ argument.annotation.id == "Any"
+ ):
+ offenders.append(
+ f"{relative}:{argument.lineno}: "
+ f"{node.name}({argument.arg}: Any)"
+ )
+ if not isinstance(node, ast.Call) or not (
+ isinstance(node.func, ast.Name)
+ and node.func.id == "getattr"
+ and len(node.args) >= 2
+ and isinstance(node.args[0], ast.Name)
+ and node.args[0].id.lstrip("_") in request_names
+ and isinstance(node.args[1], ast.Constant)
+ and node.args[1].value in protocol_fields
+ ):
+ continue
+ offenders.append(
+ f"{relative}:{node.lineno}: "
+ f"getattr({node.args[0].id}, {node.args[1].value!r})"
+ )
+
+ assert sorted(offenders) == []
+
+
def test_core_does_not_import_product_packages() -> None:
"""Neutral ``core`` must stay independent of API, workers, and providers."""
repo_root = Path(__file__).resolve().parents[2]
@@ -527,6 +590,7 @@ def test_openai_responses_uses_adapter_boundary() -> None:
"ids.py",
"input.py",
"items.py",
+ "models.py",
"reasoning.py",
"stream.py",
"tools.py",
@@ -548,10 +612,19 @@ def test_openai_responses_uses_adapter_boundary() -> None:
responses_handler = handlers_root / "responses.py"
responses_handler_text = responses_handler.read_text(encoding="utf-8")
- assert (
- "from free_claude_code.core.openai_responses import OpenAIResponsesAdapter"
- in responses_handler_text
+ assert "free_claude_code.core.openai_responses" in set(
+ _imports_from(responses_handler, repo_root)
)
+ assert "OpenAIResponsesAdapter" in responses_handler_text
+ assert "OpenAIResponsesRequest" in responses_handler_text
+ assert not (
+ repo_root
+ / "src"
+ / "free_claude_code"
+ / "api"
+ / "models"
+ / "openai_responses.py"
+ ).exists()
routes_text = (
repo_root / "src" / "free_claude_code" / "api" / "routes.py"
).read_text(encoding="utf-8")
@@ -578,13 +651,14 @@ def test_openai_responses_uses_adapter_boundary() -> None:
offenders.append(f"{rel}: {imported}")
assert sorted(offenders) == []
- adapter_importers: list[str] = []
+ responses_importers: list[str] = []
for path in (repo_root / "src" / "free_claude_code" / "api").rglob("*.py"):
imports = set(_imports_from(path, repo_root))
if "free_claude_code.core.openai_responses" in imports:
- adapter_importers.append(path.relative_to(repo_root).as_posix())
- assert sorted(adapter_importers) == [
- "src/free_claude_code/api/handlers/responses.py"
+ responses_importers.append(path.relative_to(repo_root).as_posix())
+ assert sorted(responses_importers) == [
+ "src/free_claude_code/api/handlers/responses.py",
+ "src/free_claude_code/api/routes.py",
]
response_handler_imports = set(_imports_from(responses_handler, repo_root))
diff --git a/tests/api/test_models_validators.py b/tests/core/anthropic/test_models.py
similarity index 63%
rename from tests/api/test_models_validators.py
rename to tests/core/anthropic/test_models.py
index c8c79396..10ff809c 100644
--- a/tests/api/test_models_validators.py
+++ b/tests/core/anthropic/test_models.py
@@ -1,4 +1,12 @@
-from free_claude_code.api.models.anthropic import (
+import pytest
+
+from free_claude_code.core.anthropic.conversion import (
+ OpenAIConversionError,
+ build_base_request_body,
+)
+from free_claude_code.core.anthropic.models import (
+ ContentBlockDocument,
+ ContentBlockWebFetchToolResult,
Message,
MessagesRequest,
TokenCountRequest,
@@ -218,3 +226,106 @@ def test_messages_request_accepts_redacted_thinking_blocks():
"type": "redacted_thinking",
"data": "opaque",
}
+
+
+def test_document_and_web_fetch_blocks_preserve_protocol_extensions() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "document",
+ "source": {"type": "base64", "data": "encoded"},
+ "cache_control": {"type": "ephemeral"},
+ },
+ {
+ "type": "web_fetch_tool_result",
+ "tool_use_id": "srvtoolu_1",
+ "content": {"url": "https://example.com"},
+ "provider_extension": True,
+ },
+ ],
+ }
+ ],
+ }
+ )
+
+ content = request.messages[0].content
+ assert isinstance(content, list)
+ assert isinstance(content[0], ContentBlockDocument)
+ assert content[0].model_dump()["cache_control"] == {"type": "ephemeral"}
+ assert isinstance(content[1], ContentBlockWebFetchToolResult)
+ assert content[1].model_dump()["provider_extension"] is True
+
+
+def test_content_block_descriptions_remain_in_the_public_schema() -> None:
+ definitions = MessagesRequest.model_json_schema()["$defs"]
+
+ assert definitions["ContentBlockDocument"]["description"] == (
+ "Anthropic document block (e.g. PDF files via the Files API)."
+ )
+ assert definitions["ContentBlockServerToolUse"]["description"] == (
+ "Anthropic server-side tool invocation (e.g. ``web_search``, ``web_fetch``)."
+ )
+
+
+def test_messages_request_dump_preserves_public_defaults_and_excludes_internal_fields() -> (
+ None
+):
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [{"role": "user", "content": "hello"}],
+ "thinking": {"type": "adaptive"},
+ "original_model": "original",
+ "resolved_provider_model": "provider/model",
+ "betas": ["feature-beta"],
+ "client_extension": {"enabled": True},
+ }
+ )
+
+ dumped = request.model_dump(exclude_none=True)
+
+ assert dumped == {
+ "model": "model",
+ "messages": [{"role": "user", "content": "hello"}],
+ "stream": True,
+ "thinking": {"enabled": True, "type": "adaptive"},
+ "client_extension": {"enabled": True},
+ }
+
+
+def test_token_count_request_accepts_extras_but_excludes_internal_fields() -> None:
+ request = TokenCountRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [{"role": "user", "content": "hello"}],
+ "original_model": "original",
+ "resolved_provider_model": "provider/model",
+ "betas": ["feature-beta"],
+ "client_extension": "accepted",
+ }
+ )
+
+ assert request.model_extra == {"client_extension": "accepted"}
+ assert request.model_dump(exclude_none=True) == {
+ "model": "model",
+ "messages": [{"role": "user", "content": "hello"}],
+ "client_extension": "accepted",
+ }
+
+
+def test_openai_conversion_rejects_unknown_top_level_anthropic_extensions() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "model",
+ "messages": [{"role": "user", "content": "hello"}],
+ "client_extension": True,
+ }
+ )
+
+ with pytest.raises(OpenAIConversionError, match="client_extension"):
+ build_base_request_body(request)
diff --git a/tests/api/test_anthropic_request_passthrough.py b/tests/core/anthropic/test_request_serialization.py
similarity index 99%
rename from tests/api/test_anthropic_request_passthrough.py
rename to tests/core/anthropic/test_request_serialization.py
index c5d8b073..3eab7f99 100644
--- a/tests/api/test_anthropic_request_passthrough.py
+++ b/tests/core/anthropic/test_request_serialization.py
@@ -1,6 +1,7 @@
"""Pydantic passthrough of Anthropic protocol fields (e.g. ``cache_control``)."""
-from free_claude_code.api.models.anthropic import (
+from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import (
ContentBlockServerToolUse,
ContentBlockText,
ContentBlockWebSearchToolResult,
@@ -9,7 +10,6 @@ from free_claude_code.api.models.anthropic import (
SystemContent,
Tool,
)
-from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
from free_claude_code.core.anthropic.native_messages_request import (
build_base_native_anthropic_request_body,
)
diff --git a/tests/api/test_response_models.py b/tests/core/anthropic/test_response_models.py
similarity index 97%
rename from tests/api/test_response_models.py
rename to tests/core/anthropic/test_response_models.py
index a26e0784..4889411c 100644
--- a/tests/api/test_response_models.py
+++ b/tests/core/anthropic/test_response_models.py
@@ -1,11 +1,9 @@
-"""Tests for api/models/responses.py Pydantic response models."""
+"""Tests for Anthropic protocol response models."""
-from free_claude_code.api.models.anthropic import (
+from free_claude_code.core.anthropic.models import (
ContentBlockText,
ContentBlockThinking,
ContentBlockToolUse,
-)
-from free_claude_code.api.models.responses import (
MessagesResponse,
TokenCountResponse,
Usage,
diff --git a/tests/core/openai_responses/test_conversion.py b/tests/core/openai_responses/test_conversion.py
index 58e88810..60619e1e 100644
--- a/tests/core/openai_responses/test_conversion.py
+++ b/tests/core/openai_responses/test_conversion.py
@@ -1,13 +1,22 @@
+from typing import Any
+
import pytest
-from free_claude_code.core.openai_responses import OpenAIResponsesAdapter
+from free_claude_code.core.openai_responses import (
+ OpenAIResponsesAdapter,
+ OpenAIResponsesRequest,
+)
_ADAPTER = OpenAIResponsesAdapter()
_CONVERSION_ERROR = OpenAIResponsesAdapter.ConversionError
+def _to_anthropic_payload(request: dict[str, Any]) -> dict[str, Any]:
+ return _ADAPTER.to_anthropic_payload(OpenAIResponsesRequest.model_validate(request))
+
+
def test_responses_string_input_converts_to_anthropic_message() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"instructions": "System instructions",
@@ -29,7 +38,7 @@ def test_responses_string_input_converts_to_anthropic_message() -> None:
def test_responses_messages_tools_and_tool_results_convert() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "deepseek/deepseek-chat",
"input": [
@@ -109,7 +118,7 @@ def test_responses_messages_tools_and_tool_results_convert() -> None:
def test_responses_tool_choice_none_disables_forwarded_tools() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "deepseek/deepseek-chat",
"input": "Reply without tools",
@@ -132,7 +141,7 @@ def test_responses_tool_choice_none_disables_forwarded_tools() -> None:
def test_responses_namespace_tools_flatten_for_anthropic() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": "Use JS",
@@ -178,7 +187,7 @@ def test_responses_namespace_tools_flatten_for_anthropic() -> None:
def test_responses_namespaced_tool_choice_type_tool_flattens_for_anthropic() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": "Use JS",
@@ -207,7 +216,7 @@ def test_responses_namespaced_tool_choice_type_tool_flattens_for_anthropic() ->
def test_responses_custom_tool_converts_to_anthropic_string_tool() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": "Use apply_patch",
@@ -250,7 +259,7 @@ def test_responses_custom_tool_converts_to_anthropic_string_tool() -> None:
def test_responses_namespaced_custom_tool_flattens_for_anthropic() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": "Use shell",
@@ -284,7 +293,7 @@ def test_responses_namespaced_custom_tool_flattens_for_anthropic() -> None:
def test_responses_passive_codex_built_in_tools_are_ignored() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": "Hello",
@@ -307,7 +316,7 @@ def test_responses_passive_codex_built_in_tools_are_ignored() -> None:
def test_responses_namespaced_prior_function_call_flattens_tool_use_name() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
@@ -331,7 +340,7 @@ def test_responses_namespaced_prior_function_call_flattens_tool_use_name() -> No
def test_responses_prior_custom_tool_call_flattens_tool_use_name() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
@@ -377,7 +386,7 @@ def test_responses_prior_custom_tool_call_flattens_tool_use_name() -> None:
def test_responses_groups_consecutive_prior_tool_calls() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
@@ -419,7 +428,7 @@ def test_responses_groups_consecutive_prior_tool_calls() -> None:
def test_responses_groups_consecutive_prior_tool_outputs() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
@@ -472,7 +481,7 @@ def test_responses_groups_consecutive_prior_tool_outputs() -> None:
def test_responses_reasoning_between_tool_call_and_output_attaches_to_tool_message() -> (
None
):
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
@@ -501,7 +510,7 @@ def test_responses_reasoning_between_tool_call_and_output_attaches_to_tool_messa
def test_responses_empty_reasoning_attaches_to_prior_tool_call() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
@@ -529,7 +538,7 @@ def test_responses_empty_reasoning_attaches_to_prior_tool_call() -> None:
def test_responses_unsupported_tool_type_is_clear() -> None:
with pytest.raises(_CONVERSION_ERROR, match="Unsupported Responses tool type"):
- _ADAPTER.to_anthropic_payload(
+ _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": "Hello",
@@ -539,7 +548,7 @@ def test_responses_unsupported_tool_type_is_clear() -> None:
def test_responses_malformed_prior_function_call_is_quarantined() -> None:
- payload = _ADAPTER.to_anthropic_payload(
+ payload = _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
@@ -600,7 +609,7 @@ def test_responses_malformed_prior_function_call_is_quarantined() -> None:
def test_responses_malformed_only_function_call_still_has_no_routable_message() -> None:
with pytest.raises(_CONVERSION_ERROR, match="must contain a message"):
- _ADAPTER.to_anthropic_payload(
+ _to_anthropic_payload(
{
"model": "nvidia_nim/test-model",
"input": [
diff --git a/tests/core/openai_responses/test_openai_responses_models.py b/tests/core/openai_responses/test_openai_responses_models.py
new file mode 100644
index 00000000..354555e4
--- /dev/null
+++ b/tests/core/openai_responses/test_openai_responses_models.py
@@ -0,0 +1,94 @@
+"""Wire-compatibility tests for core-owned OpenAI Responses models."""
+
+import pytest
+from pydantic import ValidationError
+
+from free_claude_code.core.openai_responses import OpenAIResponsesRequest
+
+
+def test_responses_request_preserves_defaults_and_unknown_extensions() -> None:
+ request = OpenAIResponsesRequest.model_validate(
+ {
+ "model": "provider/model",
+ "input": "hello",
+ "provider_extension": {"enabled": True},
+ }
+ )
+
+ assert request.stream is True
+ assert request.model_extra == {"provider_extension": {"enabled": True}}
+ assert request.model_dump(mode="json", exclude_none=True) == {
+ "model": "provider/model",
+ "input": "hello",
+ "stream": True,
+ "provider_extension": {"enabled": True},
+ }
+
+
[email protected](("stream", "expected"), [(False, False), (None, None)])
+def test_responses_request_preserves_explicit_stream_values(
+ stream: bool | None,
+ expected: bool | None,
+) -> None:
+ request = OpenAIResponsesRequest.model_validate(
+ {"model": "provider/model", "input": "hello", "stream": stream}
+ )
+
+ assert request.stream is expected
+
+
+def test_responses_request_keeps_permissive_nested_protocol_shapes() -> None:
+ payload = {
+ "model": "provider/model",
+ "input": [
+ {"role": "user", "content": [{"type": "input_text", "text": "hi"}]},
+ {
+ "type": "function_call",
+ "call_id": "call_1",
+ "name": "lookup",
+ "arguments": "{}",
+ },
+ ],
+ "tools": [
+ {
+ "type": "namespace",
+ "name": "mcp__tools",
+ "tools": [{"type": "custom", "name": "apply_patch"}],
+ }
+ ],
+ "tool_choice": {"type": "custom", "name": "apply_patch"},
+ "metadata": {"trace": ["a", 1]},
+ "reasoning": {"effort": "high", "provider_hint": {"mode": "extended"}},
+ }
+
+ request = OpenAIResponsesRequest.model_validate(payload)
+
+ dumped = request.model_dump(mode="json", exclude_none=True)
+ for field_name, value in payload.items():
+ assert dumped[field_name] == value
+
+
+def test_responses_request_preserves_existing_pydantic_coercion() -> None:
+ request = OpenAIResponsesRequest.model_validate(
+ {
+ "model": "provider/model",
+ "stream": "true",
+ "temperature": "0.2",
+ "max_output_tokens": "32",
+ }
+ )
+
+ assert request.stream is True
+ assert request.temperature == 0.2
+ assert request.max_output_tokens == 32
+
+
+def test_responses_request_still_requires_model() -> None:
+ with pytest.raises(ValidationError):
+ OpenAIResponsesRequest.model_validate({"input": "hello"})
+
+
+def test_responses_request_keeps_openapi_component_name() -> None:
+ assert OpenAIResponsesRequest.model_json_schema()["title"] == (
+ "OpenAIResponsesRequest"
+ )
diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.py
index e8283f94..939a67f3 100644
--- a/tests/core/openai_responses/test_sse.py
+++ b/tests/core/openai_responses/test_sse.py
@@ -5,15 +5,27 @@ import pytest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.anthropic.streaming import format_sse_event
-from free_claude_code.core.openai_responses import OpenAIResponsesAdapter
+from free_claude_code.core.openai_responses import (
+ OpenAIResponsesAdapter,
+ OpenAIResponsesRequest,
+)
_ADAPTER = OpenAIResponsesAdapter()
+def _responses_sse(
+ chunks: AsyncIterator[str], request: dict[str, Any]
+) -> AsyncIterator[str]:
+ return _ADAPTER.iter_sse_from_anthropic(
+ chunks,
+ OpenAIResponsesRequest.model_validate(request),
+ )
+
+
@pytest.mark.asyncio
async def test_anthropic_text_stream_converts_to_responses_sse() -> None:
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(_anthropic_text_stream("Hello Codex")),
{"model": "nvidia_nim/test-model", "stream": True},
)
@@ -28,15 +40,52 @@ async def test_anthropic_text_stream_converts_to_responses_sse() -> None:
]
assert "response.output_text.delta" in event_names
assert events[-1].event == "response.completed"
- assert events[-1].data["response"]["output"][0]["content"][0]["text"] == (
- "Hello Codex"
+ completed = events[-1].data["response"]
+ assert completed["output"][0]["content"][0]["text"] == "Hello Codex"
+ assert completed["parallel_tool_calls"] is True
+ assert completed["tool_choice"] == "auto"
+
+
+async def test_response_payload_preserves_explicit_request_options() -> None:
+ response = await _completed_response_from_sse(
+ _aiter(_anthropic_text_stream("done")),
+ {
+ "model": "nvidia_nim/test-model",
+ "parallel_tool_calls": False,
+ "tool_choice": "none",
+ "temperature": 0.0,
+ "top_p": 0.0,
+ "max_output_tokens": 0,
+ },
)
+ assert response["parallel_tool_calls"] is False
+ assert response["tool_choice"] == "none"
+ assert response["temperature"] == 0.0
+ assert response["top_p"] == 0.0
+ assert response["max_output_tokens"] == 0
+
+
+async def test_response_payload_maps_explicit_null_options_to_wire_defaults() -> None:
+ response = await _completed_response_from_sse(
+ _aiter(_anthropic_text_stream("done")),
+ {
+ "model": "nvidia_nim/test-model",
+ "parallel_tool_calls": None,
+ "tool_choice": None,
+ },
+ )
+
+ assert response["parallel_tool_calls"] is True
+ assert response["tool_choice"] == "auto"
+
@pytest.mark.asyncio
async def test_anthropic_tool_stream_converts_to_function_call_item() -> None:
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(_anthropic_tool_stream()),
{"model": "nvidia_nim/test-model", "stream": True},
)
@@ -67,7 +116,7 @@ async def test_anthropic_function_tool_arguments_are_normalized() -> None:
@pytest.mark.asyncio
async def test_anthropic_malformed_function_tool_arguments_fail_response() -> None:
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(_anthropic_tool_stream(partial_json='{"value":"FCC" "bad"}')),
{"model": "nvidia_nim/test-model", "stream": True},
)
@@ -93,7 +142,7 @@ async def test_anthropic_malformed_function_tool_arguments_fail_on_eof() -> None
include_block_stop=False,
)
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(stream[:-1]),
{"model": "nvidia_nim/test-model", "stream": True},
)
@@ -107,7 +156,7 @@ async def test_anthropic_malformed_function_tool_arguments_fail_on_eof() -> None
@pytest.mark.asyncio
async def test_namespaced_anthropic_tool_stream_restores_responses_namespace() -> None:
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(_anthropic_tool_stream(tool_name="mcp__node_repl__js")),
{
"model": "nvidia_nim/test-model",
@@ -140,7 +189,7 @@ async def test_namespaced_anthropic_tool_stream_restores_responses_namespace() -
@pytest.mark.asyncio
async def test_anthropic_custom_tool_stream_converts_to_custom_tool_call() -> None:
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(
_anthropic_tool_stream(
tool_name="apply_patch",
@@ -198,7 +247,7 @@ async def test_custom_tool_input_remains_free_form_when_not_json() -> None:
@pytest.mark.asyncio
async def test_anthropic_error_stream_converts_to_response_failed_event() -> None:
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(
[
format_sse_event(
@@ -374,7 +423,7 @@ async def test_pending_tool_blocks_flush_on_message_stop_and_eof(
@pytest.mark.asyncio
async def test_overlapping_text_and_tool_blocks_keep_reserved_output_indexes() -> None:
text = await _collect_sse(
- _ADAPTER.iter_sse_from_anthropic(
+ _responses_sse(
_aiter(_overlapping_text_tool_stream()),
{"model": "nvidia_nim/test-model", "stream": True},
)
@@ -423,7 +472,7 @@ async def _completed_response_from_sse(
chunks: AsyncIterator[str],
request: dict[str, object],
) -> dict[str, Any]:
- text = await _collect_sse(_ADAPTER.iter_sse_from_anthropic(chunks, request))
+ text = await _collect_sse(_responses_sse(chunks, request))
events = parse_sse_text(text)
assert events[-1].event == "response.completed"
return events[-1].data["response"]
diff --git a/tests/core/test_protocol_model_ownership.py b/tests/core/test_protocol_model_ownership.py
new file mode 100644
index 00000000..64631bd1
--- /dev/null
+++ b/tests/core/test_protocol_model_ownership.py
@@ -0,0 +1,99 @@
+"""Protocol models live with the protocol logic that consumes them."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+from free_claude_code.core.anthropic import (
+ MessagesRequest as PublicMessagesRequest,
+)
+from free_claude_code.core.anthropic import (
+ MessagesResponse,
+ TokenCountResponse,
+)
+from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.openai_responses import (
+ OpenAIResponsesRequest as PublicOpenAIResponsesRequest,
+)
+from free_claude_code.core.openai_responses.models import OpenAIResponsesRequest
+
+
+def test_anthropic_request_model_is_core_owned_and_permissive() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "provider-model",
+ "messages": [{"role": "user", "content": "hello"}],
+ "provider_extension": {"enabled": True},
+ }
+ )
+
+ assert MessagesRequest.__module__ == "free_claude_code.core.anthropic.models"
+ assert PublicMessagesRequest is MessagesRequest
+ assert request.model_extra == {"provider_extension": {"enabled": True}}
+
+
+def test_responses_request_model_is_core_owned_and_permissive() -> None:
+ request = OpenAIResponsesRequest.model_validate(
+ {
+ "model": "provider-model",
+ "input": "hello",
+ "provider_extension": {"enabled": True},
+ }
+ )
+
+ assert (
+ OpenAIResponsesRequest.__module__
+ == "free_claude_code.core.openai_responses.models"
+ )
+ assert PublicOpenAIResponsesRequest is OpenAIResponsesRequest
+ assert request.model_extra == {"provider_extension": {"enabled": True}}
+
+
+def test_anthropic_response_models_are_protocol_owned() -> None:
+ assert MessagesResponse.__module__ == "free_claude_code.core.anthropic.models"
+ assert TokenCountResponse.__module__ == "free_claude_code.core.anthropic.models"
+
+
+def test_api_adapter_does_not_own_protocol_models() -> None:
+ api_models = Path(__file__).resolve().parents[2] / "src/free_claude_code/api/models"
+
+ assert not (api_models / "__init__.py").exists()
+ assert not (api_models / "anthropic.py").exists()
+ assert not (api_models / "openai_responses.py").exists()
+ assert not (api_models / "responses.py").exists()
+
+
+def test_protocol_models_and_transport_consumers_are_import_order_independent() -> None:
+ import_orders = (
+ (
+ "free_claude_code.core.trace",
+ "free_claude_code.core.anthropic",
+ "free_claude_code.providers.base",
+ "free_claude_code.api.routes",
+ ),
+ ("free_claude_code.cli.managed.session",),
+ (
+ "free_claude_code.core.anthropic.models",
+ "free_claude_code.providers.base",
+ "free_claude_code.providers.transports.openai_chat.transport",
+ "free_claude_code.providers.transports.anthropic_messages.transport",
+ "free_claude_code.api.routes",
+ ),
+ (
+ "free_claude_code.api.routes",
+ "free_claude_code.providers.transports.anthropic_messages.transport",
+ "free_claude_code.providers.transports.openai_chat.transport",
+ "free_claude_code.providers.base",
+ "free_claude_code.core.anthropic.models",
+ ),
+ )
+
+ for modules in import_orders:
+ script = "; ".join(f"import {module}" for module in modules)
+ completed = subprocess.run(
+ [sys.executable, "-c", script],
+ capture_output=True,
+ check=False,
+ text=True,
+ )
+ assert completed.returncode == 0, completed.stderr
diff --git a/tests/core/test_trace.py b/tests/core/test_trace.py
index 0c9dbc23..cdea643a 100644
--- a/tests/core/test_trace.py
+++ b/tests/core/test_trace.py
@@ -38,9 +38,9 @@ def test_trace_payload_merged_into_json_line(tmp_path) -> None:
def test_sanitize_masks_nested_api_key_strings() -> None:
"""Credential-shaped keys redact without touching normal message text."""
- from free_claude_code.core.trace import _sanitize_trace_value
+ from free_claude_code.core.trace import sanitize_trace_value
- out = _sanitize_trace_value(
+ out = sanitize_trace_value(
{"outer": {"api_key": "secret", "text": "visible"}},
)
assert out["outer"]["api_key"] == "<redacted>"
diff --git a/tests/providers/request_factory.py b/tests/providers/request_factory.py
new file mode 100644
index 00000000..bce4cff2
--- /dev/null
+++ b/tests/providers/request_factory.py
@@ -0,0 +1,25 @@
+"""Concrete Anthropic request factory for provider tests."""
+
+from typing import Any
+
+from free_claude_code.core.anthropic.models import MessagesRequest
+
+
+def make_messages_request(
+ model: str = "test-model", **overrides: Any
+) -> MessagesRequest:
+ """Build a real Messages request with provider-test defaults."""
+ data: dict[str, Any] = {
+ "model": model,
+ "messages": [{"role": "user", "content": "Hello"}],
+ "max_tokens": 100,
+ "temperature": 0.5,
+ "top_p": 0.9,
+ "system": "System prompt",
+ "stop_sequences": None,
+ "tools": [],
+ "extra_body": {},
+ "thinking": {"enabled": True},
+ }
+ data.update(overrides)
+ return MessagesRequest.model_validate(data)
diff --git a/tests/providers/test_anthropic_messages.py b/tests/providers/test_anthropic_messages.py
index fa52deda..d3eba10e 100644
--- a/tests/providers/test_anthropic_messages.py
+++ b/tests/providers/test_anthropic_messages.py
@@ -23,6 +23,7 @@ from free_claude_code.providers.transports.anthropic_messages import (
from free_claude_code.providers.transports.anthropic_messages.recovery import (
AnthropicMessagesRecovery,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
@@ -39,23 +40,6 @@ class NativeProvider(AnthropicMessagesTransport):
return {"Content-Type": "application/json", "X-Test": "1"}
-class MockRequest:
- model = "test-model"
-
- def __init__(self, *, thinking_enabled: bool = True, body: dict | None = None):
- self.thinking = MagicMock()
- self.thinking.enabled = thinking_enabled
- self._body = body or {
- "model": self.model,
- "messages": [{"role": "user", "content": "Hello"}],
- "extra_body": {"ignored": True},
- "thinking": {"enabled": thinking_enabled},
- }
-
- def model_dump(self, exclude_none=True):
- return dict(self._body)
-
-
class FakeResponse:
def __init__(
self,
@@ -166,7 +150,7 @@ def test_default_request_body_strips_internal_fields(provider_config):
rate_limiter=passthrough_rate_limiter(),
)
- body = provider._build_request_body(MockRequest())
+ body = provider._build_request_body(make_messages_request(max_tokens=None))
assert body["model"] == "test-model"
assert body["thinking"] == {"type": "enabled"}
@@ -179,12 +163,9 @@ def test_default_request_body_preserves_thinking_budget(provider_config):
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest(
- body={
- "model": "test-model",
- "messages": [{"role": "user", "content": "Hello"}],
- "thinking": {"type": "enabled", "budget_tokens": 4096},
- }
+ req = make_messages_request(
+ max_tokens=None,
+ thinking={"type": "enabled", "budget_tokens": 4096},
)
body = provider._build_request_body(req)
@@ -225,7 +206,7 @@ async def test_stream_uses_retry_builds_request_and_closes_response(
mock_rate_limiter,
):
provider = NativeProvider(provider_config, rate_limiter=mock_rate_limiter)
- req = MockRequest()
+ req = make_messages_request()
request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
response = FakeResponse(
lines=[
@@ -272,7 +253,7 @@ async def test_late_error_after_native_message_stop_keeps_successful_lifecycle(
mock_rate_limiter,
):
provider = NativeProvider(provider_config, rate_limiter=mock_rate_limiter)
- req = MockRequest()
+ req = make_messages_request()
lines = [
"event: message_start",
'data: {"type":"message_start"}',
@@ -317,7 +298,7 @@ async def test_stream_maps_pre_start_non_200_to_provider_error_and_closes_respon
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
response = FakeResponse(status_code=500, text="Internal Server Error")
with (
@@ -347,7 +328,7 @@ async def test_precommit_native_error_raises_without_leaking_open_block(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
mid = "msg_midstream_err"
msg_start = format_sse_event(
"message_start",
@@ -402,7 +383,7 @@ async def test_midstream_error_after_native_message_delta_does_not_duplicate_ter
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
msg_start = format_sse_event(
"message_start",
{
@@ -506,7 +487,7 @@ async def test_native_text_recovery_closes_thinking_before_text_suffix():
) as mock_collect:
events = await recovery.events(
body={"messages": []},
- request=MockRequest(),
+ request=make_messages_request(),
ledger=ledger,
error=TimeoutError("cutoff"),
request_id="req_native_recovery",
@@ -544,7 +525,7 @@ async def test_clean_eof_after_complete_native_tool_call_salvages_tool_use(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
msg_start = format_sse_event(
"message_start",
{
@@ -617,7 +598,7 @@ async def test_clean_eof_after_native_text_continues_with_overlap_trim(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
msg_start = format_sse_event(
"message_start",
{
@@ -831,7 +812,7 @@ async def test_truncated_native_recovery_stream_falls_back_to_error_tail(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
msg_start = format_sse_event(
"message_start",
{
@@ -916,7 +897,7 @@ async def test_precommit_native_holdback_retries_without_leaking_partial(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
msg_start = format_sse_event(
"message_start",
diff --git a/tests/providers/test_anthropic_messages_429_retry.py b/tests/providers/test_anthropic_messages_429_retry.py
index e1fc286e..74100f56 100644
--- a/tests/providers/test_anthropic_messages_429_retry.py
+++ b/tests/providers/test_anthropic_messages_429_retry.py
@@ -8,10 +8,10 @@ import pytest
from free_claude_code.core.anthropic.stream_contracts import event_names, parse_sse_text
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import ProviderError
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import retrying_rate_limiter
from tests.providers.test_anthropic_messages import (
FakeResponse,
- MockRequest,
NativeProvider,
)
@@ -40,7 +40,7 @@ def provider_config():
async def test_native_stream_retries_on_http_429_then_streams(provider_config):
"""First response 429 (closed), second 200 streams; send is called twice."""
provider = NativeProvider(provider_config, rate_limiter=retrying_rate_limiter())
- req = MockRequest()
+ req = make_messages_request()
request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
ok_lines = [
"event: message_start",
@@ -89,7 +89,7 @@ async def test_native_stream_retries_on_http_5xx_then_streams(
):
"""First response is retryable 5xx (closed); second 200 streams; send twice."""
provider = NativeProvider(provider_config, rate_limiter=retrying_rate_limiter())
- req = MockRequest()
+ req = make_messages_request()
request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
ok_lines = [
"event: message_start",
@@ -137,7 +137,7 @@ async def test_native_stream_retries_on_pre_send_connection_error_then_streams(
):
"""Pre-response HTTPX transport errors retry through execute_with_retry."""
provider = NativeProvider(provider_config, rate_limiter=retrying_rate_limiter())
- req = MockRequest()
+ req = make_messages_request()
request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
ok_lines = [
"event: message_start",
@@ -191,7 +191,7 @@ async def test_native_stream_5xx_retry_exhausted(provider_config, status_code, s
provider_config,
rate_limiter=retrying_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
bad = FakeResponse(status_code=status_code, text="upstream error")
@@ -221,7 +221,7 @@ async def test_native_stream_connection_error_retry_exhausted(provider_config):
provider_config,
rate_limiter=retrying_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
with (
@@ -260,7 +260,7 @@ async def test_non_retryable_4xx_http_error_not_retried(provider_config):
provider_config,
rate_limiter=retrying_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
err = FakeResponse(status_code=400, text="Bad Request")
with (
diff --git a/tests/providers/test_cerebras.py b/tests/providers/test_cerebras.py
index 64d01590..6baaee03 100644
--- a/tests/providers/test_cerebras.py
+++ b/tests/providers/test_cerebras.py
@@ -6,29 +6,12 @@ import pytest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.cerebras import CEREBRAS_DEFAULT_BASE, CerebrasProvider
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "llama3.1-8b"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("llama3.1-8b", **overrides)
@pytest.fixture
@@ -66,7 +49,7 @@ 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 = MockRequest()
+ req = make_request()
body = cerebras_provider._build_request_body(req)
assert body["model"] == "llama3.1-8b"
@@ -85,7 +68,7 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():
),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
body = provider._build_request_body(req)
roles = [m.get("role") for m in body.get("messages", [])]
@@ -102,7 +85,7 @@ def test_build_request_body_remaps_max_tokens_preserves_message_name(cerebras_pr
"messages": [{"role": "user", "name": "alice", "content": "hi"}],
"max_tokens": 42,
}
- req = MockRequest()
+ req = make_request()
body = cerebras_provider._build_request_body(req)
assert body["messages"][0].get("name") == "alice"
@@ -120,14 +103,14 @@ 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(MockRequest())
+ body = cerebras_provider._build_request_body(make_request())
assert body["max_completion_tokens"] == 77
assert "max_tokens" not in body
def test_build_request_body_preserves_caller_extra_body(cerebras_provider):
- req = MockRequest(extra_body={"clear_thinking": False})
+ req = make_request(extra_body={"clear_thinking": False})
body = cerebras_provider._build_request_body(req)
@@ -139,7 +122,7 @@ def test_build_request_body_preserves_caller_extra_body(cerebras_provider):
@pytest.mark.asyncio
async def test_stream_response_text(cerebras_provider):
"""Text content deltas are emitted as text blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -172,7 +155,7 @@ async def test_stream_response_text(cerebras_provider):
@pytest.mark.asyncio
async def test_stream_response_reasoning_content(cerebras_provider):
"""reasoning_content deltas are emitted as thinking blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
diff --git a/tests/providers/test_cloudflare.py b/tests/providers/test_cloudflare.py
index 10fbcc70..d5bf4c9e 100644
--- a/tests/providers/test_cloudflare.py
+++ b/tests/providers/test_cloudflare.py
@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock, patch
import httpx
import pytest
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.cloudflare import (
diff --git a/tests/providers/test_codestral.py b/tests/providers/test_codestral.py
index ddec523c..f5d85325 100644
--- a/tests/providers/test_codestral.py
+++ b/tests/providers/test_codestral.py
@@ -9,29 +9,12 @@ from free_claude_code.providers.codestral import (
CODESTRAL_DEFAULT_BASE,
CodestralProvider,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "devstral-small-latest"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("devstral-small-latest", **overrides)
@pytest.fixture
@@ -69,7 +52,7 @@ def test_default_base_url():
def test_build_request_body_basic(codestral_provider):
"""Basic request body conversion works for Codestral."""
- req = MockRequest()
+ req = make_request()
body = codestral_provider._build_request_body(req)
assert body["model"] == "devstral-small-latest"
@@ -88,7 +71,7 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():
),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
body = provider._build_request_body(req)
roles = [m.get("role") for m in body.get("messages", [])]
@@ -98,7 +81,7 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():
@pytest.mark.asyncio
async def test_stream_response_text(codestral_provider):
"""Text content deltas are emitted as text blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -131,7 +114,7 @@ async def test_stream_response_text(codestral_provider):
@pytest.mark.asyncio
async def test_stream_response_reasoning_content(codestral_provider):
"""reasoning_content deltas are emitted as thinking blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
diff --git a/tests/providers/test_cohere.py b/tests/providers/test_cohere.py
index 264b90ab..121e9e1d 100644
--- a/tests/providers/test_cohere.py
+++ b/tests/providers/test_cohere.py
@@ -7,29 +7,12 @@ import pytest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.cohere import COHERE_DEFAULT_BASE, CohereProvider
from free_claude_code.providers.exceptions import InvalidRequestError
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "command-a-plus-05-2026"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("command-a-plus-05-2026", **overrides)
@pytest.fixture
@@ -96,7 +79,7 @@ def test_build_request_body_sanitizes_documented_unsupported_fields(cohere_provi
"parallel_tool_calls": True,
}
- body = cohere_provider._build_request_body(MockRequest())
+ body = cohere_provider._build_request_body(make_request())
assert body["messages"][0].get("name") is None
assert body["max_tokens"] == 42
@@ -117,7 +100,7 @@ def test_build_request_body_sanitizes_documented_unsupported_fields(cohere_provi
def test_build_request_body_maps_thinking_enabled_to_reasoning_high(cohere_provider):
- body = cohere_provider._build_request_body(MockRequest())
+ body = cohere_provider._build_request_body(make_request())
assert body["reasoning_effort"] == "high"
@@ -137,7 +120,7 @@ def test_build_request_body_preserves_replayed_reasoning_content(cohere_provider
],
}
- body = cohere_provider._build_request_body(MockRequest())
+ body = cohere_provider._build_request_body(make_request())
assert body["messages"] == [
{
@@ -161,13 +144,13 @@ def test_build_request_body_maps_thinking_disabled_to_reasoning_none():
rate_limiter=passthrough_rate_limiter(),
)
- body = provider._build_request_body(MockRequest())
+ body = provider._build_request_body(make_request())
assert body["reasoning_effort"] == "none"
def test_build_request_body_promotes_allowed_extra_body(cohere_provider):
- req = MockRequest(
+ req = make_request(
extra_body={
"frequency_penalty": 0.1,
"presence_penalty": 0.2,
@@ -186,7 +169,7 @@ def test_build_request_body_promotes_allowed_extra_body(cohere_provider):
def test_build_request_body_rejects_unsupported_extra_body(cohere_provider):
- req = MockRequest(extra_body={"documents": [{"text": "x"}]})
+ req = make_request(extra_body={"documents": [{"text": "x"}]})
with pytest.raises(InvalidRequestError, match="Unsupported"):
cohere_provider._build_request_body(req)
@@ -216,7 +199,7 @@ async def test_stream_response_text(cohere_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in cohere_provider.stream_response(MockRequest())
+ event async for event in cohere_provider.stream_response(make_request())
]
assert any(
@@ -251,7 +234,7 @@ async def test_stream_response_tool_call(cohere_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in cohere_provider.stream_response(MockRequest())
+ event async for event in cohere_provider.stream_response(make_request())
]
assert any(
@@ -286,7 +269,7 @@ async def test_stream_response_reasoning_content(cohere_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in cohere_provider.stream_response(MockRequest())
+ event async for event in cohere_provider.stream_response(make_request())
]
assert any(
diff --git a/tests/providers/test_converter.py b/tests/providers/test_converter.py
index 8cfe5b36..ed656caa 100644
--- a/tests/providers/test_converter.py
+++ b/tests/providers/test_converter.py
@@ -2,13 +2,13 @@ import json
import pytest
-from free_claude_code.api.models.anthropic import MessagesRequest
from free_claude_code.core.anthropic import (
AnthropicToOpenAIConverter,
OpenAIConversionError,
ReasoningReplayMode,
build_base_request_body,
)
+from free_claude_code.core.anthropic.models import MessagesRequest
# --- Mock Classes ---
diff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.py
index b85358ed..a1659126 100644
--- a/tests/providers/test_deepseek.py
+++ b/tests/providers/test_deepseek.py
@@ -6,13 +6,13 @@ from unittest.mock import AsyncMock, patch
import pytest
-from free_claude_code.api.models.anthropic import (
+from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import (
ContentBlockImage,
Message,
MessagesRequest,
Tool,
)
-from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.deepseek import (
diff --git a/tests/providers/test_fireworks.py b/tests/providers/test_fireworks.py
index 4615e1d0..ee02b0d1 100644
--- a/tests/providers/test_fireworks.py
+++ b/tests/providers/test_fireworks.py
@@ -4,8 +4,8 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import InvalidRequestError
from free_claude_code.providers.fireworks import FIREWORKS_BASE_URL, FireworksProvider
diff --git a/tests/providers/test_gemini.py b/tests/providers/test_gemini.py
index 2725fdbd..40b390d3 100644
--- a/tests/providers/test_gemini.py
+++ b/tests/providers/test_gemini.py
@@ -9,29 +9,12 @@ from free_claude_code.providers.gemini import GEMINI_DEFAULT_BASE, GeminiProvide
from free_claude_code.providers.gemini.quirks import (
GEMINI_SKIP_THOUGHT_SIGNATURE_VALIDATOR,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "models/gemini-3.1-flash-lite"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("models/gemini-3.1-flash-lite", **overrides)
def _simulate_openai_sdk_wire_json(body: dict) -> dict:
@@ -82,7 +65,7 @@ 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 = MockRequest()
+ req = make_request()
body = gemini_provider._build_request_body(req)
assert body["model"] == "models/gemini-3.1-flash-lite"
@@ -102,7 +85,7 @@ def test_build_request_body_basic(gemini_provider):
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 = MockRequest()
+ req = make_request()
body = gemini_provider._build_request_body(req)
wire_json = _simulate_openai_sdk_wire_json(body)
@@ -130,7 +113,7 @@ def test_build_request_body_global_disable_sets_reasoning_none():
),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
body = provider._build_request_body(req)
assert body["reasoning_effort"] == "none"
@@ -139,7 +122,7 @@ def test_build_request_body_global_disable_sets_reasoning_none():
def test_build_request_body_preserves_caller_extra_body(gemini_provider):
- req = MockRequest(extra_body={"metadata": {"user": "u1"}})
+ req = make_request(extra_body={"metadata": {"user": "u1"}})
body = gemini_provider._build_request_body(req)
@@ -154,7 +137,7 @@ def test_build_request_body_preserves_caller_extra_body(gemini_provider):
def test_build_request_body_merges_caller_nested_google(gemini_provider):
- req = MockRequest(
+ req = make_request(
extra_body={
"metadata": {"user": "u1"},
"extra_body": {
@@ -184,13 +167,13 @@ def test_build_request_body_merges_caller_nested_google(gemini_provider):
def test_build_request_body_preserves_tool_call_extra_content(gemini_provider):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage("user", "Find files"),
- MockMessage(
- "assistant",
- [
+ {"role": "user", "content": "Find files"},
+ {
+ "role": "assistant",
+ "content": [
{
"type": "tool_use",
"id": "function-call-1",
@@ -199,19 +182,19 @@ def test_build_request_body_preserves_tool_call_extra_content(gemini_provider):
"extra_content": {
"google": {"thought_signature": "sig-from-client"}
},
- }
+ },
],
- ),
- MockMessage(
- "user",
- [
+ },
+ {
+ "role": "user",
+ "content": [
{
"type": "tool_result",
"tool_use_id": "function-call-1",
"content": "[]",
- }
+ },
],
- ),
+ },
],
)
@@ -227,31 +210,31 @@ def test_build_request_body_uses_cached_tool_call_signature(gemini_provider):
gemini_provider._record_tool_call_extra_content(
"function-call-1", {"google": {"thought_signature": "sig-from-cache"}}
)
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage("user", "Find files"),
- MockMessage(
- "assistant",
- [
+ {"role": "user", "content": "Find files"},
+ {
+ "role": "assistant",
+ "content": [
{
"type": "tool_use",
"id": "function-call-1",
"name": "Glob",
"input": {"pattern": "*.py"},
- }
+ },
],
- ),
- MockMessage(
- "user",
- [
+ },
+ {
+ "role": "user",
+ "content": [
{
"type": "tool_result",
"tool_use_id": "function-call-1",
"content": "[]",
- }
+ },
],
- ),
+ },
],
)
@@ -266,13 +249,13 @@ def test_build_request_body_uses_cached_tool_call_signature(gemini_provider):
def test_build_request_body_adds_gemini3_current_turn_fallback_signature(
gemini_provider,
):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage("user", "Find files"),
- MockMessage(
- "assistant",
- [
+ {"role": "user", "content": "Find files"},
+ {
+ "role": "assistant",
+ "content": [
{
"type": "tool_use",
"id": "function-call-1",
@@ -286,10 +269,10 @@ def test_build_request_body_adds_gemini3_current_turn_fallback_signature(
"input": {"file_path": "a.py"},
},
],
- ),
- MockMessage(
- "user",
- [
+ },
+ {
+ "role": "user",
+ "content": [
{
"type": "tool_result",
"tool_use_id": "function-call-1",
@@ -301,7 +284,7 @@ def test_build_request_body_adds_gemini3_current_turn_fallback_signature(
"content": "contents",
},
],
- ),
+ },
],
)
@@ -316,7 +299,7 @@ def test_build_request_body_adds_gemini3_current_turn_fallback_signature(
@pytest.mark.asyncio
async def test_stream_response_text(gemini_provider):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -359,7 +342,7 @@ async def test_stream_response_text(gemini_provider):
@pytest.mark.asyncio
async def test_stream_response_preserves_tool_call_extra_content(gemini_provider):
- req = MockRequest()
+ req = make_request()
mock_tc = MagicMock()
mock_tc.index = 0
@@ -407,7 +390,7 @@ async def test_stream_response_preserves_tool_call_extra_content(gemini_provider
@pytest.mark.asyncio
async def test_stream_response_reasoning_content(gemini_provider):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
diff --git a/tests/providers/test_github_models.py b/tests/providers/test_github_models.py
index b9deedb6..908475b4 100644
--- a/tests/providers/test_github_models.py
+++ b/tests/providers/test_github_models.py
@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock, patch
import httpx
import pytest
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import ModelListResponseError
diff --git a/tests/providers/test_groq.py b/tests/providers/test_groq.py
index db0e9f5c..83308109 100644
--- a/tests/providers/test_groq.py
+++ b/tests/providers/test_groq.py
@@ -6,29 +6,12 @@ import pytest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.groq import GROQ_DEFAULT_BASE, GroqProvider
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "llama-3.3-70b-versatile"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("llama-3.3-70b-versatile", **overrides)
@pytest.fixture
@@ -64,7 +47,7 @@ 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 = MockRequest()
+ req = make_request()
body = groq_provider._build_request_body(req)
assert body["model"] == "llama-3.3-70b-versatile"
@@ -83,7 +66,7 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():
),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
body = provider._build_request_body(req)
roles = [m.get("role") for m in body.get("messages", [])]
@@ -111,7 +94,7 @@ def test_build_request_body_sanitizes_and_remaps_via_mock_converter(groq_provide
"max_tokens": 42,
"n": 4,
}
- req = MockRequest()
+ req = make_request()
body = groq_provider._build_request_body(req)
msgs = body["messages"]
@@ -133,14 +116,14 @@ 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(MockRequest())
+ body = groq_provider._build_request_body(make_request())
assert body["max_completion_tokens"] == 77
assert "max_tokens" not in body
def test_build_request_body_preserves_caller_extra_body(groq_provider):
- req = MockRequest(extra_body={"metadata": {"user": "u1"}})
+ req = make_request(extra_body={"metadata": {"user": "u1"}})
body = groq_provider._build_request_body(req)
@@ -152,7 +135,7 @@ def test_build_request_body_preserves_caller_extra_body(groq_provider):
@pytest.mark.asyncio
async def test_stream_response_text(groq_provider):
"""Text content deltas are emitted as text blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -185,7 +168,7 @@ async def test_stream_response_text(groq_provider):
@pytest.mark.asyncio
async def test_stream_response_reasoning_content(groq_provider):
"""reasoning_content deltas are emitted as thinking blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
diff --git a/tests/providers/test_huggingface.py b/tests/providers/test_huggingface.py
index 57ef35c9..2e090c91 100644
--- a/tests/providers/test_huggingface.py
+++ b/tests/providers/test_huggingface.py
@@ -10,36 +10,12 @@ from free_claude_code.providers.huggingface import (
HUGGINGFACE_DEFAULT_BASE,
HuggingFaceProvider,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content, reasoning_content=None):
- self.role = role
- self.content = content
- self.reasoning_content = reasoning_content
-
-
-class MockBlock:
- def __init__(self, **kwargs):
- for key, value in kwargs.items():
- setattr(self, key, value)
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "openai/gpt-oss-120b:fastest"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("openai/gpt-oss-120b:fastest", **overrides)
@pytest.fixture
@@ -100,7 +76,7 @@ def test_build_request_body_keeps_max_tokens(huggingface_provider):
"max_tokens": 42,
}
- body = huggingface_provider._build_request_body(MockRequest())
+ body = huggingface_provider._build_request_body(make_request())
mock_convert.assert_called_once()
assert (
@@ -114,7 +90,7 @@ def test_build_request_body_keeps_max_tokens(huggingface_provider):
def test_build_request_body_preserves_caller_extra_body(huggingface_provider):
extra_body = {"provider": "auto", "routing": {"bill_to": "my-org"}}
- req = MockRequest(extra_body=extra_body)
+ req = make_request(extra_body=extra_body)
body = huggingface_provider._build_request_body(req)
@@ -126,16 +102,16 @@ def test_build_request_body_preserves_caller_extra_body(huggingface_provider):
def test_build_request_body_does_not_replay_prior_thinking_blocks(
huggingface_provider,
):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="hidden prior thought"),
- MockBlock(type="text", text="visible answer"),
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "hidden prior thought"},
+ {"type": "text", "text": "visible answer"},
],
- )
+ }
],
)
@@ -149,14 +125,14 @@ def test_build_request_body_does_not_replay_prior_thinking_blocks(
def test_build_request_body_does_not_replay_top_level_reasoning_content(
huggingface_provider,
):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
- "assistant",
- "visible answer",
- reasoning_content="hidden prior reasoning",
- )
+ {
+ "role": "assistant",
+ "content": "visible answer",
+ "reasoning_content": "hidden prior reasoning",
+ }
],
)
@@ -190,7 +166,8 @@ async def test_stream_response_text(huggingface_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in huggingface_provider.stream_response(MockRequest())
+ event
+ async for event in huggingface_provider.stream_response(make_request())
]
assert any(
@@ -223,7 +200,8 @@ async def test_stream_response_reasoning_content(huggingface_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in huggingface_provider.stream_response(MockRequest())
+ event
+ async for event in huggingface_provider.stream_response(make_request())
]
assert any(
diff --git a/tests/providers/test_kimi.py b/tests/providers/test_kimi.py
index fd9c85bd..16a040e5 100644
--- a/tests/providers/test_kimi.py
+++ b/tests/providers/test_kimi.py
@@ -5,8 +5,8 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import KIMI_DEFAULT_BASE
from free_claude_code.providers.exceptions import InvalidRequestError
diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.py
index ff6d7120..efc73e91 100644
--- a/tests/providers/test_llamacpp.py
+++ b/tests/providers/test_llamacpp.py
@@ -10,40 +10,10 @@ from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import ProviderError
from free_claude_code.providers.llamacpp import LlamaCppProvider
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "llamacpp-community/qwen2.5-7b-instruct"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.extra_body = {}
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for k, v in kwargs.items():
- setattr(self, k, v)
-
- def model_dump(self, exclude_none=True):
- return {
- "model": self.model,
- "messages": [{"role": m.role, "content": m.content} for m in self.messages],
- "max_tokens": self.max_tokens,
- "temperature": self.temperature,
- "extra_body": self.extra_body,
- "thinking": {"enabled": self.thinking.enabled} if self.thinking else None,
- }
+LLAMACPP_MODEL = "llamacpp-community/qwen2.5-7b-instruct"
async def _minimal_native_lines():
@@ -117,7 +87,7 @@ async def test_stream_response_omits_thinking_when_globally_disabled(llamacpp_co
llamacpp_config.model_copy(update={"enable_thinking": False}),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request(LLAMACPP_MODEL)
mock_response = MagicMock()
mock_response.status_code = 200
@@ -142,7 +112,7 @@ async def test_stream_response_omits_thinking_when_globally_disabled(llamacpp_co
@pytest.mark.asyncio
async def test_stream_response(llamacpp_provider):
"""Test streaming native Anthropic response."""
- req = MockRequest()
+ req = make_messages_request(LLAMACPP_MODEL)
mock_response = MagicMock()
mock_response.status_code = 200
@@ -197,14 +167,13 @@ async def test_stream_response(llamacpp_provider):
@pytest.mark.asyncio
async def test_stream_response_adds_max_tokens_if_missing(llamacpp_provider):
"""Fallback max_tokens to 81920 if not present."""
- req = MockRequest()
+ req = make_messages_request(LLAMACPP_MODEL, max_tokens=None)
mock_response = MagicMock()
mock_response.status_code = 200
mock_response.aiter_lines = _minimal_native_lines
with (
- patch.object(req, "model_dump", return_value={"model": "test"}),
patch.object(llamacpp_provider._client, "build_request") as mock_build,
patch.object(
llamacpp_provider._client,
@@ -223,7 +192,7 @@ async def test_stream_response_adds_max_tokens_if_missing(llamacpp_provider):
@pytest.mark.asyncio
async def test_stream_error_status_code(llamacpp_provider):
"""Pre-start non-200 status code raises for API-level non-200 handling."""
- req = MockRequest()
+ req = make_messages_request(LLAMACPP_MODEL)
mock_response = MagicMock()
mock_response.status_code = 500
@@ -260,7 +229,7 @@ async def test_stream_error_status_code(llamacpp_provider):
@pytest.mark.asyncio
async def test_stream_network_error(llamacpp_provider):
"""Pre-start network errors raise for API-level non-200 handling."""
- req = MockRequest()
+ req = make_messages_request(LLAMACPP_MODEL)
with (
patch.object(
@@ -289,7 +258,7 @@ async def test_stream_network_error(llamacpp_provider):
@pytest.mark.asyncio
async def test_stream_error_405_mentions_upstream_provider(llamacpp_provider):
- req = MockRequest()
+ req = make_messages_request(LLAMACPP_MODEL)
mock_response = MagicMock()
mock_response.status_code = 405
@@ -327,19 +296,19 @@ def test_build_request_body_disabled_thinking_strips_native_thinking_history(
"""With thinking disabled, prior assistant thinking/redacted blocks are omitted."""
config = llamacpp_config.model_copy(update={"enable_thinking": False})
provider = LlamaCppProvider(config, rate_limiter=passthrough_rate_limiter())
- messages = [
- MockMessage("user", "Hi"),
- MockMessage(
- "assistant",
- [
- {"type": "thinking", "thinking": "p"},
- {"type": "redacted_thinking", "data": "ZGF0YQ=="},
- ],
- ),
- ]
- req = MockRequest(
+ req = make_messages_request(
+ LLAMACPP_MODEL,
system=None,
- messages=messages,
+ messages=[
+ {"role": "user", "content": "Hi"},
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "p"},
+ {"type": "redacted_thinking", "data": "ZGF0YQ=="},
+ ],
+ },
+ ],
)
body = provider._build_request_body(req, thinking_enabled=False)
asst = body["messages"][1]
diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.py
index 4c8293a2..fa327800 100644
--- a/tests/providers/test_lmstudio.py
+++ b/tests/providers/test_lmstudio.py
@@ -9,29 +9,12 @@ from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import InvalidRequestError
from free_claude_code.providers.lmstudio import LMStudioProvider
from free_claude_code.providers.lmstudio.client import LMSTUDIO_DEFAULT_BASE
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "lmstudio-community/qwen2.5-7b-instruct"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("lmstudio-community/qwen2.5-7b-instruct", **overrides)
@pytest.fixture
@@ -68,7 +51,7 @@ def test_default_base_url_constant():
def test_build_request_body_basic(lmstudio_provider):
- req = MockRequest()
+ req = make_request()
body = lmstudio_provider._build_request_body(req)
assert body["model"] == "lmstudio-community/qwen2.5-7b-instruct"
@@ -78,13 +61,19 @@ def test_build_request_body_basic(lmstudio_provider):
def test_build_request_body_never_replays_prior_thinking(lmstudio_provider):
"""Mistral-family templates have no assistant reasoning field; prior-turn
thinking must never be replayed regardless of the enable_thinking setting."""
- req = MockRequest(
+ req = make_request(
messages=[
- MockMessage("user", "hi"),
- MockMessage(
- "assistant",
- [{"type": "thinking", "thinking": "prior reasoning", "signature": "s"}],
- ),
+ {"role": "user", "content": "hi"},
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "thinking",
+ "thinking": "prior reasoning",
+ "signature": "s",
+ }
+ ],
+ },
]
)
body = lmstudio_provider._build_request_body(req)
@@ -97,7 +86,7 @@ def test_build_request_body_never_replays_prior_thinking(lmstudio_provider):
@pytest.mark.asyncio
async def test_stream_response_text(lmstudio_provider):
"""Text content deltas are emitted as text blocks (via the OpenAI chat transport)."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -138,14 +127,16 @@ async def test_cleanup(lmstudio_provider):
def test_preflight_context_budget_noop_when_context_length_unknown(lmstudio_provider):
"""No LM Studio /api/v0/models data available -> preflight is a no-op (fail open)."""
with patch.object(lmstudio_provider, "_loaded_context_length", return_value=None):
- lmstudio_provider._preflight_context_budget(MockRequest()) # must not raise
+ lmstudio_provider._preflight_context_budget(make_request()) # must not raise
def test_preflight_context_budget_allows_request_under_budget(lmstudio_provider):
with patch.object(
lmstudio_provider, "_loaded_context_length", return_value=100_000
):
- req = MockRequest(messages=[MockMessage("user", "hi")], system=None, tools=[])
+ req = make_request(
+ messages=[{"role": "user", "content": "hi"}], system=None, tools=[]
+ )
lmstudio_provider._preflight_context_budget(req) # must not raise
@@ -158,7 +149,7 @@ def test_preflight_context_budget_rejects_request_over_90_percent(lmstudio_provi
),
pytest.raises(InvalidRequestError, match="prompt is too long"),
):
- lmstudio_provider._preflight_context_budget(MockRequest())
+ lmstudio_provider._preflight_context_budget(make_request())
def test_loaded_context_length_reads_max_across_loaded_models(lmstudio_provider):
diff --git a/tests/providers/test_minimax.py b/tests/providers/test_minimax.py
index 3168f4cf..85106745 100644
--- a/tests/providers/test_minimax.py
+++ b/tests/providers/test_minimax.py
@@ -5,8 +5,8 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
-from free_claude_code.api.models.anthropic import Message, MessagesRequest, Tool
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import Message, MessagesRequest, Tool
from free_claude_code.core.anthropic.stream_contracts import (
parse_sse_text,
text_content,
diff --git a/tests/providers/test_mistral.py b/tests/providers/test_mistral.py
index 1b9e8611..2be75f83 100644
--- a/tests/providers/test_mistral.py
+++ b/tests/providers/test_mistral.py
@@ -10,48 +10,12 @@ from httpx import Request, Response
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import ProviderError
from free_claude_code.providers.mistral import MISTRAL_DEFAULT_BASE, MistralProvider
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content, reasoning_content=None):
- self.role = role
- self.content = content
- self.reasoning_content = reasoning_content
-
-
-class MockBlock:
- def __init__(self, **kwargs):
- for key, value in kwargs.items():
- setattr(self, key, value)
-
-
-class MockTool:
- def __init__(self):
- self.name = "echo"
- self.description = "Echo a value"
- self.input_schema = {
- "type": "object",
- "properties": {"value": {"type": "string"}},
- "required": ["value"],
- }
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "devstral-small-latest"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.tool_choice = None
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("devstral-small-latest", **overrides)
@pytest.fixture
@@ -89,7 +53,7 @@ def test_default_base_url():
def test_build_request_body_basic(mistral_provider):
"""Basic request body conversion works for Mistral."""
- req = MockRequest()
+ req = make_request()
body = mistral_provider._build_request_body(req)
assert body["model"] == "devstral-small-latest"
@@ -100,32 +64,32 @@ def test_build_request_body_basic(mistral_provider):
def test_build_request_body_replays_prior_thinking_as_mistral_chunks(
mistral_provider,
):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="Need the tool."),
- MockBlock(type="text", text="Calling the tool."),
- MockBlock(
- type="tool_use",
- id="toolu_1",
- name="echo",
- input={"value": "x"},
- ),
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "Need the tool."},
+ {"type": "text", "text": "Calling the tool."},
+ {
+ "type": "tool_use",
+ "id": "toolu_1",
+ "name": "echo",
+ "input": {"value": "x"},
+ },
],
- ),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="toolu_1",
- content="result",
- )
+ },
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "tool_result",
+ "tool_use_id": "toolu_1",
+ "content": "result",
+ }
],
- ),
+ },
],
)
@@ -144,8 +108,18 @@ def test_build_request_body_replays_prior_thinking_as_mistral_chunks(
def test_build_request_body_preserves_tools_tool_choice_and_params(mistral_provider):
- req = MockRequest(
- tools=[MockTool()],
+ req = make_request(
+ tools=[
+ {
+ "name": "echo",
+ "description": "Echo a value",
+ "input_schema": {
+ "type": "object",
+ "properties": {"value": {"type": "string"}},
+ "required": ["value"],
+ },
+ }
+ ],
tool_choice={"type": "tool", "name": "echo"},
stop_sequences=["STOP"],
)
@@ -172,7 +146,7 @@ def test_build_request_body_global_disable_blocks_reasoning_mapping():
),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
body = provider._build_request_body(req)
assert "reasoning_effort" not in body
@@ -190,16 +164,16 @@ def test_build_request_body_thinking_disabled_strips_prior_mistral_thinking():
),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="Hidden."),
- MockBlock(type="text", text="Visible."),
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "Hidden."},
+ {"type": "text", "text": "Visible."},
],
- ),
+ },
],
)
@@ -212,7 +186,7 @@ def test_build_request_body_thinking_disabled_strips_prior_mistral_thinking():
@pytest.mark.asyncio
async def test_stream_response_text(mistral_provider):
"""Text content deltas are emitted as text blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -245,7 +219,7 @@ async def test_stream_response_text(mistral_provider):
@pytest.mark.asyncio
async def test_stream_response_reasoning_content(mistral_provider):
"""reasoning_content deltas are emitted as thinking blocks."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -277,7 +251,7 @@ async def test_stream_response_reasoning_content(mistral_provider):
@pytest.mark.asyncio
async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -314,7 +288,7 @@ async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):
@pytest.mark.asyncio
async def test_stream_response_native_mistral_text_chunk(mistral_provider):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -346,7 +320,7 @@ async def test_stream_response_native_mistral_text_chunk(mistral_provider):
async def test_stream_response_preserves_native_thinking_and_string_text(
mistral_provider,
):
- req = MockRequest()
+ req = make_request()
mock_chunk = SimpleNamespace(
choices=[
@@ -384,7 +358,7 @@ async def test_stream_response_preserves_native_thinking_and_string_text(
async def test_stream_response_preserves_native_reasoning_and_string_text(
mistral_provider,
):
- req = MockRequest()
+ req = make_request()
mock_chunk = SimpleNamespace(
choices=[
@@ -420,7 +394,7 @@ async def test_stream_response_preserves_native_reasoning_and_string_text(
async def test_stream_response_preserves_mixed_native_content_array(
mistral_provider,
):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -460,7 +434,7 @@ async def test_stream_response_preserves_mixed_native_content_array(
async def test_stream_response_suppresses_native_mistral_thinking_when_disabled(
mistral_provider,
):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -505,31 +479,31 @@ async def test_stream_response_suppresses_native_mistral_thinking_when_disabled(
async def test_stream_response_retries_without_mistral_reasoning_on_rejection(
mistral_provider,
):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="Need the tool."),
- MockBlock(
- type="tool_use",
- id="toolu_reasoning",
- name="echo",
- input={"value": "FCC_TOOL"},
- ),
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "Need the tool."},
+ {
+ "type": "tool_use",
+ "id": "toolu_reasoning",
+ "name": "echo",
+ "input": {"value": "FCC_TOOL"},
+ },
],
- ),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="toolu_reasoning",
- content="result",
- )
+ },
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "tool_result",
+ "tool_use_id": "toolu_reasoning",
+ "content": "result",
+ }
],
- ),
+ },
],
)
@@ -572,32 +546,32 @@ async def test_stream_response_retries_without_mistral_reasoning_on_rejection(
async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools(
mistral_provider,
):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="Need the tool."),
- MockBlock(type="text", text="Visible history."),
- MockBlock(
- type="tool_use",
- id="toolu_reasoning",
- name="echo",
- input={"value": "FCC_TOOL"},
- ),
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "Need the tool."},
+ {"type": "text", "text": "Visible history."},
+ {
+ "type": "tool_use",
+ "id": "toolu_reasoning",
+ "name": "echo",
+ "input": {"value": "FCC_TOOL"},
+ },
],
- ),
- MockMessage(
- "user",
- [
- MockBlock(
- type="tool_result",
- tool_use_id="toolu_reasoning",
- content="result",
- )
+ },
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "tool_result",
+ "tool_use_id": "toolu_reasoning",
+ "content": "result",
+ }
],
- ),
+ },
],
)
@@ -632,7 +606,7 @@ async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools(
async def test_stream_response_retries_on_mistral_422_reasoning_rejection(
mistral_provider,
):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -668,16 +642,16 @@ async def test_stream_response_retries_on_mistral_422_reasoning_rejection(
async def test_stream_response_retries_when_model_disables_reasoning_input(
mistral_provider,
):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
- "assistant",
- [
- MockBlock(type="thinking", thinking="Need context."),
- MockBlock(type="text", text="Visible history."),
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "Need context."},
+ {"type": "text", "text": "Visible history."},
],
- )
+ }
],
)
@@ -720,7 +694,7 @@ async def test_stream_response_retries_when_model_disables_reasoning_input(
@pytest.mark.asyncio
async def test_stream_response_unrelated_bad_request_does_not_retry(mistral_provider):
- req = MockRequest()
+ req = make_request()
error = _make_bad_request_error("Unsupported field: top_k")
with patch.object(
@@ -739,7 +713,7 @@ async def test_stream_response_unrelated_bad_request_does_not_retry(mistral_prov
async def test_stream_response_generic_thinking_error_does_not_retry(
mistral_provider,
):
- req = MockRequest()
+ req = make_request()
error = _make_bad_request_error("The model was thinking, but top_k is unsupported")
with patch.object(
diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.py
index cff23c25..79b24a62 100644
--- a/tests/providers/test_nvidia_nim.py
+++ b/tests/providers/test_nvidia_nim.py
@@ -12,44 +12,26 @@ from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.nvidia_nim.tool_schema import (
NIM_TOOL_ARGUMENT_ALIASES_KEY,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-# Mock data classes
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
+def message(role, content):
+ return {"role": role, "content": content}
-class MockTool:
- def __init__(self, name, description, input_schema):
- self.name = name
- self.description = description
- self.input_schema = input_schema
+def tool(name, description, input_schema):
+ return {"name": name, "description": description, "input_schema": input_schema}
-class MockBlock:
- def __init__(self, **kwargs):
- for key, value in kwargs.items():
- setattr(self, key, value)
+def block(**fields):
+ return fields
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "test-model"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = ["STOP"]
- self.tools = []
- self.extra_body = {}
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for k, v in kwargs.items():
- setattr(self, k, v)
+def make_request(**overrides):
+ model = overrides.pop("model", "test-model")
+ overrides.setdefault("stop_sequences", ["STOP"])
+ return make_messages_request(model, **overrides)
def _input_json_deltas(events):
@@ -165,7 +147,7 @@ async def test_build_request_body(provider_config):
nim_settings=NimSettings(),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
body = provider._build_request_body(req)
assert body["model"] == "test-model"
@@ -191,7 +173,7 @@ async def test_build_request_body_omits_reasoning_when_globally_disabled(
nim_settings=NimSettings(),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
body = provider._build_request_body(req)
extra = body.get("extra_body", {})
@@ -208,7 +190,7 @@ async def test_build_request_body_omits_reasoning_when_request_disables_thinking
nim_settings=NimSettings(),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
req.thinking.enabled = False
body = provider._build_request_body(req)
@@ -220,31 +202,29 @@ async def test_build_request_body_omits_reasoning_when_request_disables_thinking
def test_preflight_and_build_request_issue_206_post_tool_text(nim_provider):
"""Regression: assistant message with tool_use then text plus tool results (GitHub #206)."""
tool_id = "toolu_issue_206"
- req = MockRequest(
+ req = make_request(
messages=[
- MockMessage("user", "Use echo once."),
- MockMessage(
+ message("user", "Use echo once."),
+ message(
"assistant",
[
- MockBlock(
+ block(
type="tool_use",
id=tool_id,
name="echo_smoke",
input={"value": "FCC_206"},
),
- MockBlock(
+ block(
type="text",
text="Commentary after the tool row.",
),
],
),
- MockMessage(
+ message(
"user",
[
- MockBlock(
- type="tool_result", tool_use_id=tool_id, content="FCC_206"
- ),
- MockBlock(type="text", text="What was echoed?"),
+ block(type="tool_result", tool_use_id=tool_id, content="FCC_206"),
+ block(type="text", text="What was echoed?"),
],
),
],
@@ -258,7 +238,7 @@ def test_preflight_and_build_request_issue_206_post_tool_text(nim_provider):
@pytest.mark.asyncio
async def test_stream_response_text(nim_provider):
"""Test streaming text response."""
- req = MockRequest()
+ req = make_request()
# Create mock chunks
mock_chunk1 = MagicMock()
@@ -307,7 +287,7 @@ async def test_stream_response_text(nim_provider):
@pytest.mark.asyncio
async def test_stream_response_thinking_reasoning_content(nim_provider):
"""Test streaming with native reasoning_content."""
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -356,7 +336,7 @@ async def test_stream_response_suppresses_thinking_when_disabled(provider_config
nim_settings=NimSettings(),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -399,7 +379,7 @@ async def test_stream_response_retries_without_chat_template(provider_config):
nim_settings=NimSettings(chat_template="custom_template"),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest(model="mistralai/mixtral-8x7b-instruct-v0.1")
+ req = make_request(model="mistralai/mixtral-8x7b-instruct-v0.1")
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -455,7 +435,7 @@ async def test_stream_response_retries_without_chat_template_kwargs_issue_993(
nim_settings=NimSettings(),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest(model="mistralai/mistral-small-4-119b-2603")
+ req = make_request(model="mistralai/mistral-small-4-119b-2603")
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -507,7 +487,7 @@ async def test_stream_response_does_not_retry_unrelated_bad_request(provider_con
nim_settings=NimSettings(chat_template="custom_template"),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest(model="mistralai/mixtral-8x7b-instruct-v0.1")
+ req = make_request(model="mistralai/mixtral-8x7b-instruct-v0.1")
with patch.object(
provider._client.chat.completions, "create", new_callable=AsyncMock
@@ -524,7 +504,7 @@ async def test_stream_response_does_not_retry_unrelated_bad_request(provider_con
@pytest.mark.asyncio
async def test_tool_call_stream(nim_provider):
"""Test streaming tool calls."""
- req = MockRequest()
+ req = make_request()
# Mock tool call delta
mock_tc = MagicMock()
@@ -562,9 +542,9 @@ async def test_tool_call_stream(nim_provider):
@pytest.mark.asyncio
async def test_stream_response_restores_aliased_tool_arguments(nim_provider):
"""NIM-safe argument aliases are restored before Anthropic SSE emission."""
- req = MockRequest(
+ req = make_request(
tools=[
- MockTool(
+ tool(
"Grep",
"Search file contents",
{
@@ -613,9 +593,9 @@ async def test_stream_response_restores_aliased_tool_arguments(nim_provider):
@pytest.mark.asyncio
async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provider):
"""Chunked aliased args are emitted once as restored Claude Code args."""
- req = MockRequest(
+ req = make_request(
tools=[
- MockTool(
+ tool(
"Grep",
"Search file contents",
{
@@ -658,9 +638,9 @@ async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provid
@pytest.mark.asyncio
async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provider):
- req = MockRequest(
+ req = make_request(
tools=[
- MockTool(
+ tool(
"NotionLike",
"Nested type schema",
{
@@ -704,9 +684,9 @@ async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provid
@pytest.mark.asyncio
async def test_stream_response_task_tool_still_forces_background_false(nim_provider):
- req = MockRequest(
+ req = make_request(
tools=[
- MockTool(
+ tool(
"Task",
"Run a subagent",
{
@@ -750,7 +730,7 @@ async def test_stream_response_task_tool_still_forces_background_false(nim_provi
@pytest.mark.asyncio
async def test_stream_response_retries_without_reasoning_budget(nim_provider):
- req = MockRequest()
+ req = make_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -791,7 +771,7 @@ async def test_stream_response_retries_without_reasoning_budget(nim_provider):
async def test_stream_response_retries_without_budget_for_thinking_token_error(
nim_provider,
):
- req = MockRequest(model="meta/llama-3.3-70b-instruct")
+ req = make_request(model="meta/llama-3.3-70b-instruct")
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -834,14 +814,14 @@ async def test_stream_response_retries_without_budget_for_thinking_token_error(
@pytest.mark.asyncio
async def test_stream_response_retries_without_reasoning_content(nim_provider):
- req = MockRequest(
+ req = make_request(
system=None,
messages=[
- MockMessage(
+ message(
"assistant",
[
- MockBlock(type="thinking", thinking="Need the tool."),
- MockBlock(
+ block(type="thinking", thinking="Need the tool."),
+ block(
type="tool_use",
id="toolu_reasoning",
name="echo_smoke",
@@ -849,10 +829,10 @@ async def test_stream_response_retries_without_reasoning_content(nim_provider):
),
],
),
- MockMessage(
+ message(
"user",
[
- MockBlock(
+ block(
type="tool_result",
tool_use_id="toolu_reasoning",
content="result",
@@ -897,7 +877,7 @@ async def test_stream_response_retries_without_reasoning_content(nim_provider):
async def test_stream_response_bad_request_without_reasoning_budget_does_not_retry(
nim_provider,
):
- req = MockRequest()
+ req = make_request()
error = _make_bad_request_error("Unsupported field: top_k")
with patch.object(
@@ -916,7 +896,7 @@ async def test_stream_response_bad_request_without_reasoning_budget_does_not_ret
async def test_stream_response_unrelated_internal_error_does_not_downgrade(
nim_provider,
):
- req = MockRequest()
+ req = make_request()
error = _make_internal_server_error("unrelated internal provider failure")
with patch.object(
@@ -935,7 +915,7 @@ async def test_stream_response_unrelated_internal_error_does_not_downgrade(
async def test_stream_response_internal_reasoning_content_error_does_not_downgrade(
nim_provider,
):
- req = MockRequest()
+ req = make_request()
error = _make_internal_server_error(
"reasoning_content could not be processed by the upstream model"
)
diff --git a/tests/providers/test_nvidia_nim_request.py b/tests/providers/test_nvidia_nim_request.py
index b2a014ef..3fed3809 100644
--- a/tests/providers/test_nvidia_nim_request.py
+++ b/tests/providers/test_nvidia_nim_request.py
@@ -1,14 +1,13 @@
"""Tests for NVIDIA NIM request policy helpers."""
from copy import deepcopy
-from types import SimpleNamespace
from typing import Any
-from unittest.mock import MagicMock
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.providers.nvidia_nim.request_options import (
_set_extra,
)
@@ -24,6 +23,7 @@ from free_claude_code.providers.nvidia_nim.tool_schema import (
body_without_nim_tool_argument_aliases,
nim_tool_argument_aliases_from_body,
)
+from tests.providers.request_factory import make_messages_request
GREP_SCHEMA_FROM_SERVER_LOG: dict[str, Any] = {
"type": "object",
@@ -48,20 +48,20 @@ GREP_SCHEMA_FROM_SERVER_LOG: dict[str, Any] = {
@pytest.fixture
-def req():
- r = MagicMock()
- r.model = "test"
- r.messages = [MagicMock(role="user", content="hi")]
- r.max_tokens = 100
- r.system = None
- r.temperature = None
- r.top_p = None
- r.stop_sequences = None
- r.tools = None
- r.tool_choice = None
- r.extra_body = None
- r.top_k = None
- return r
+def req() -> MessagesRequest:
+ 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,
+ )
class TestSetIfNotNone:
@@ -134,7 +134,7 @@ class TestBuildRequestBody:
"required": ["query"],
}
req.tools = [
- SimpleNamespace(
+ Tool(
name="search",
description="search",
input_schema=tool_schema,
@@ -162,7 +162,7 @@ class TestBuildRequestBody:
tool_schema["required"] = ["pattern", "-A", "_fcc_arg_type"]
original_schema = deepcopy(tool_schema)
req.tools = [
- SimpleNamespace(
+ Tool(
name="Grep",
description="Search file contents",
input_schema=tool_schema,
@@ -208,7 +208,7 @@ class TestBuildRequestBody:
"required": ["pattern"],
}
req.tools = [
- SimpleNamespace(
+ Tool(
name="Glob",
description="Find files",
input_schema=tool_schema,
@@ -241,7 +241,7 @@ class TestBuildRequestBody:
}
original_schema = deepcopy(tool_schema)
req.tools = [
- SimpleNamespace(
+ Tool(
name="NotionLike",
description="Nested type schema",
input_schema=tool_schema,
@@ -277,18 +277,20 @@ class TestBuildRequestBody:
}
def test_reasoning_params_in_extra_body(self):
- req = MagicMock()
- req.model = "test"
- req.messages = [MagicMock(role="user", content="hi")]
- req.max_tokens = 100
- req.system = None
- req.temperature = None
- req.top_p = None
- req.stop_sequences = None
- req.tools = None
- req.tool_choice = None
- req.extra_body = None
- req.top_k = None
+ req = 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,
+ tool_choice=None,
+ extra_body=None,
+ top_k=None,
+ thinking=None,
+ )
nim = NimSettings()
body = build_request_body(req, nim, thinking_enabled=True)
@@ -353,18 +355,20 @@ class TestBuildRequestBody:
assert clone_body_without_chat_template(body) is None
def test_no_chat_template_kwargs_when_thinking_disabled(self):
- req = MagicMock()
- req.model = "test"
- req.messages = [MagicMock(role="user", content="hi")]
- req.max_tokens = 100
- req.system = None
- req.temperature = None
- req.top_p = None
- req.stop_sequences = None
- req.tools = None
- req.tool_choice = None
- req.extra_body = None
- req.top_k = None
+ req = 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,
+ tool_choice=None,
+ extra_body=None,
+ top_k=None,
+ thinking=None,
+ )
nim = NimSettings()
body = build_request_body(req, nim, thinking_enabled=False)
@@ -373,20 +377,25 @@ class TestBuildRequestBody:
assert "reasoning_budget" not in extra
def test_reasoning_budget_respects_existing_chat_template_kwargs(self):
- req = MagicMock()
- req.model = "test"
- req.messages = [MagicMock(role="user", content="hi")]
- req.max_tokens = 100
- req.system = None
- req.temperature = None
- req.top_p = None
- req.stop_sequences = None
- req.tools = None
- req.tool_choice = None
- req.top_k = None
- req.extra_body = {
- "chat_template_kwargs": {"enable_thinking": False, "custom": "value"}
- }
+ req = 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,
+ tool_choice=None,
+ top_k=None,
+ extra_body={
+ "chat_template_kwargs": {
+ "enable_thinking": False,
+ "custom": "value",
+ }
+ },
+ thinking=None,
+ )
body = build_request_body(req, NimSettings(), thinking_enabled=True)
assert body["extra_body"]["chat_template_kwargs"] == {
@@ -396,18 +405,20 @@ class TestBuildRequestBody:
}
def test_chat_template_fields_present_for_mistral_model(self):
- req = MagicMock()
- req.model = "mistralai/mixtral-8x7b-instruct-v0.1"
- req.messages = [MagicMock(role="user", content="hi")]
- req.max_tokens = 100
- req.system = None
- req.temperature = None
- req.top_p = None
- req.stop_sequences = None
- req.tools = None
- req.tool_choice = None
- req.extra_body = None
- req.top_k = None
+ req = make_messages_request(
+ model="mistralai/mixtral-8x7b-instruct-v0.1",
+ messages=[{"role": "user", "content": "hi"}],
+ max_tokens=100,
+ system=None,
+ temperature=None,
+ top_p=None,
+ stop_sequences=None,
+ tools=None,
+ tool_choice=None,
+ extra_body=None,
+ top_k=None,
+ thinking=None,
+ )
nim = NimSettings(chat_template="custom_template")
body = build_request_body(req, nim, thinking_enabled=True)
@@ -420,18 +431,20 @@ class TestBuildRequestBody:
assert extra["chat_template"] == "custom_template"
def test_no_reasoning_params_in_extra_body(self):
- req = MagicMock()
- req.model = "test"
- req.messages = [MagicMock(role="user", content="hi")]
- req.max_tokens = 100
- req.system = None
- req.temperature = None
- req.top_p = None
- req.stop_sequences = None
- req.tools = None
- req.tool_choice = None
- req.extra_body = None
- req.top_k = None
+ req = 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,
+ tool_choice=None,
+ extra_body=None,
+ top_k=None,
+ thinking=None,
+ )
nim = NimSettings()
body = build_request_body(req, nim, thinking_enabled=False)
@@ -446,53 +459,56 @@ class TestBuildRequestBody:
assert param not in extra
def test_assistant_thinking_blocks_removed_when_disabled(self):
- req = MagicMock()
- req.model = "test"
- req.messages = [
- MagicMock(
- role="assistant",
- content=[
- MagicMock(type="thinking", thinking="secret"),
- MagicMock(type="text", text="answer"),
- ],
- )
- ]
- req.max_tokens = 100
- req.system = None
- req.temperature = None
- req.top_p = None
- req.stop_sequences = None
- req.tools = None
- req.tool_choice = None
- req.extra_body = None
- req.top_k = None
+ req = make_messages_request(
+ model="test",
+ messages=[
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "secret"},
+ {"type": "text", "text": "answer"},
+ ],
+ }
+ ],
+ max_tokens=100,
+ system=None,
+ temperature=None,
+ top_p=None,
+ stop_sequences=None,
+ tools=None,
+ tool_choice=None,
+ extra_body=None,
+ top_k=None,
+ thinking=None,
+ )
body = build_request_body(req, NimSettings(), thinking_enabled=False)
assert "<think>" not in body["messages"][0]["content"]
assert "answer" in body["messages"][0]["content"]
def test_assistant_thinking_replayed_as_reasoning_content_when_enabled(self):
- req = MagicMock()
- req.model = "test"
- req.messages = [
- MagicMock(
- role="assistant",
- content=[
- MagicMock(type="thinking", thinking="secret"),
- MagicMock(type="text", text="answer"),
- ],
- reasoning_content=None,
- )
- ]
- req.max_tokens = 100
- req.system = None
- req.temperature = None
- req.top_p = None
- req.stop_sequences = None
- req.tools = None
- req.tool_choice = None
- req.extra_body = None
- req.top_k = None
+ req = make_messages_request(
+ model="test",
+ messages=[
+ {
+ "role": "assistant",
+ "content": [
+ {"type": "thinking", "thinking": "secret"},
+ {"type": "text", "text": "answer"},
+ ],
+ }
+ ],
+ max_tokens=100,
+ system=None,
+ temperature=None,
+ top_p=None,
+ stop_sequences=None,
+ tools=None,
+ tool_choice=None,
+ extra_body=None,
+ top_k=None,
+ thinking=None,
+ )
body = build_request_body(req, NimSettings(), thinking_enabled=True)
assistant = body["messages"][0]
diff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.py
index fe515cda..469f36aa 100644
--- a/tests/providers/test_ollama.py
+++ b/tests/providers/test_ollama.py
@@ -9,47 +9,10 @@ from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import ProviderError
from free_claude_code.providers.ollama import OLLAMA_DEFAULT_BASE, OllamaProvider
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "llama3.1:8b"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.stream = True
- self.tools = []
- self.tool_choice = None
- self.extra_body = {}
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
-
- def model_dump(self, exclude_none=True):
- return {
- "model": self.model,
- "messages": [{"role": m.role, "content": m.content} for m in self.messages],
- "max_tokens": self.max_tokens,
- "temperature": self.temperature,
- "top_p": self.top_p,
- "system": self.system,
- "stream": self.stream,
- "tools": self.tools,
- "tool_choice": self.tool_choice,
- "extra_body": self.extra_body,
- "thinking": {"enabled": self.thinking.enabled} if self.thinking else None,
- }
+OLLAMA_MODEL = "llama3.1:8b"
@pytest.fixture
@@ -133,7 +96,7 @@ def test_init_uses_default_api_key():
@pytest.mark.asyncio
async def test_stream_response(ollama_provider):
"""Test streaming native Anthropic response."""
- req = MockRequest()
+ req = make_messages_request(OLLAMA_MODEL)
mock_response = MagicMock()
mock_response.status_code = 200
@@ -187,7 +150,7 @@ async def test_build_request_body_omits_thinking_when_disabled(ollama_config):
ollama_config.model_copy(update={"enable_thinking": False}),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request(OLLAMA_MODEL)
body = provider._build_request_body(req)
@@ -203,17 +166,18 @@ def test_build_request_body_disabled_thinking_strips_assistant_thinking_blocks(
ollama_config.model_copy(update={"enable_thinking": False}),
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest(
+ req = make_messages_request(
+ OLLAMA_MODEL,
system=None,
messages=[
- MockMessage("user", "hi"),
- MockMessage(
- "assistant",
- [
+ {"role": "user", "content": "hi"},
+ {
+ "role": "assistant",
+ "content": [
{"type": "thinking", "thinking": "t"},
{"type": "redacted_thinking", "data": "opaque"},
],
- ),
+ },
],
)
body = provider._build_request_body(req, thinking_enabled=False)
@@ -223,7 +187,7 @@ def test_build_request_body_disabled_thinking_strips_assistant_thinking_blocks(
@pytest.mark.asyncio
async def test_stream_error_status_code(ollama_provider):
"""Pre-start non-200 status code raises for API-level non-200 handling."""
- req = MockRequest()
+ req = make_messages_request(OLLAMA_MODEL)
mock_response = MagicMock()
mock_response.status_code = 500
mock_response.aread = AsyncMock(return_value=b"Internal Server Error")
diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.py
index df4a0429..4f378205 100644
--- a/tests/providers/test_open_router.py
+++ b/tests/providers/test_open_router.py
@@ -5,8 +5,8 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
-from free_claude_code.api.models.anthropic import MessagesRequest
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import (
parse_sse_text,
text_content,
@@ -15,6 +15,7 @@ from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import InvalidRequestError
from free_claude_code.providers.open_router import OpenRouterProvider
from free_claude_code.providers.transports.openai_chat import OpenAIChatTransport
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
@@ -34,28 +35,8 @@ class AsyncStream:
self.closed = True
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "moonshotai/kimi-k2.6:free"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.tool_choice = None
- self.metadata = None
- self.extra_body = {}
- self.thinking = {"type": "enabled"}
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("moonshotai/kimi-k2.6:free", **overrides)
@pytest.fixture
@@ -96,7 +77,7 @@ def test_init_uses_openai_chat_transport(open_router_provider):
def test_build_request_body_uses_openai_chat_shape(open_router_provider):
- body = open_router_provider._build_request_body(MockRequest())
+ body = open_router_provider._build_request_body(make_request())
assert body["model"] == "moonshotai/kimi-k2.6:free"
assert body["temperature"] == 0.5
@@ -109,7 +90,7 @@ 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(MockRequest(max_tokens=None))
+ body = open_router_provider._build_request_body(make_request(max_tokens=None))
assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
@@ -119,13 +100,13 @@ def test_openrouter_extra_body_rejects_overriding_reserved_fields(
):
with pytest.raises(InvalidRequestError, match="model"):
open_router_provider._build_request_body(
- MockRequest(extra_body={"model": "hijack"})
+ make_request(extra_body={"model": "hijack"})
)
def test_openrouter_extra_body_allows_provider_keys(open_router_provider):
body = open_router_provider._build_request_body(
- MockRequest(extra_body={"transforms": ["no-web"], "plugins": []}),
+ make_request(extra_body={"transforms": ["no-web"], "plugins": []}),
thinking_enabled=False,
)
@@ -136,7 +117,7 @@ def test_build_request_body_omits_reasoning_when_thinking_disabled(
open_router_provider,
):
body = open_router_provider._build_request_body(
- MockRequest(thinking={"type": "disabled"})
+ make_request(thinking={"type": "disabled"})
)
assert "extra_body" not in body
@@ -146,7 +127,7 @@ def test_build_request_body_maps_thinking_budget_to_reasoning_max_tokens(
open_router_provider,
):
body = open_router_provider._build_request_body(
- MockRequest(thinking={"type": "enabled", "budget_tokens": 4096})
+ make_request(thinking={"type": "enabled", "budget_tokens": 4096})
)
assert body["extra_body"]["reasoning"] == {"enabled": True, "max_tokens": 4096}
@@ -198,7 +179,8 @@ async def test_stream_maps_reasoning_content_and_details(open_router_provider):
return_value=stream,
):
events = [
- event async for event in open_router_provider.stream_response(MockRequest())
+ event
+ async for event in open_router_provider.stream_response(make_request())
]
event_text = "".join(events)
diff --git a/tests/providers/test_openai_chat_output_cap.py b/tests/providers/test_openai_chat_output_cap.py
index be9b61a3..d034d4c6 100644
--- a/tests/providers/test_openai_chat_output_cap.py
+++ b/tests/providers/test_openai_chat_output_cap.py
@@ -5,7 +5,7 @@ Covers the pure parse/clamp helpers and the transport behavior that clamps
and learns the cap so later requests clamp proactively.
"""
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, patch
import pytest
@@ -15,6 +15,7 @@ from free_claude_code.providers.transports.openai_chat.output_cap import (
clamp_output_tokens,
parse_output_token_cap,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
@@ -109,26 +110,6 @@ def test_clamp_ignores_bool_values():
# --------------------------------------------------------------------------- #
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, max_tokens=64000):
- self.model = "llama-3.3-70b-versatile"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = max_tokens
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = False
-
-
@pytest.fixture
def groq_provider():
return GroqProvider(
@@ -145,7 +126,13 @@ 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(MockRequest(max_tokens=64000))
+ body = groq_provider._build_request_body(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ )
assert body["max_completion_tokens"] == 64000
model = body["model"]
@@ -163,7 +150,13 @@ 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(MockRequest(max_tokens=64000))
+ body = groq_provider._build_request_body(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=64000,
+ thinking={"enabled": False},
+ )
+ )
model = body["model"]
groq_provider._model_output_caps[model] = 40960
@@ -178,7 +171,13 @@ 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(MockRequest(max_tokens=100))
+ body = groq_provider._build_request_body(
+ make_messages_request(
+ "llama-3.3-70b-versatile",
+ max_tokens=100,
+ thinking={"enabled": False},
+ )
+ )
create = AsyncMock(side_effect=_BadRequest("messages: invalid role 'wizard'"))
with (
diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.py
index 9d052a67..37cfa1a8 100644
--- a/tests/providers/test_openai_chat_usage.py
+++ b/tests/providers/test_openai_chat_usage.py
@@ -8,6 +8,7 @@ import openai
import pytest
from httpx import Request, Response
+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.providers.base import ProviderConfig
from free_claude_code.providers.transports.openai_chat import OpenAIChatTransport
@@ -17,6 +18,7 @@ from free_claude_code.providers.transports.openai_chat.usage import (
request_stream_usage,
usage_int,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
@@ -36,7 +38,7 @@ class _UsageTestProvider(OpenAIChatTransport):
)
def _build_request_body(
- self, request: Any, thinking_enabled: bool | None = None
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
) -> dict:
return {"model": request.model, "messages": [{"role": "user", "content": "x"}]}
@@ -150,7 +152,7 @@ def test_stream_usage_rejection_does_not_match_unrelated_400():
@pytest.mark.asyncio
async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokens():
provider = _UsageTestProvider()
- request = SimpleNamespace(model="m")
+ request = make_messages_request(model="m")
usage = SimpleNamespace(prompt_tokens=22, completion_tokens=4)
create = AsyncMock(
return_value=_stream(
diff --git a/tests/providers/test_openai_compat_5xx_retry.py b/tests/providers/test_openai_compat_5xx_retry.py
index 4a5067d3..4053b363 100644
--- a/tests/providers/test_openai_compat_5xx_retry.py
+++ b/tests/providers/test_openai_compat_5xx_retry.py
@@ -11,8 +11,8 @@ from free_claude_code.config.nim import NimSettings
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.exceptions import ProviderError
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import retrying_rate_limiter
-from tests.providers.test_nvidia_nim import MockRequest
def _internal_5xx(code: int) -> openai.InternalServerError:
@@ -48,7 +48,7 @@ async def test_nim_stream_retries_on_openai_5xx_then_streams(status_code):
nim_settings=NimSettings(),
rate_limiter=retrying_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -93,7 +93,7 @@ async def test_nim_stream_retries_on_pre_stream_connection_error_then_streams():
nim_settings=NimSettings(),
rate_limiter=retrying_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
mock_chunk = MagicMock()
mock_chunk.choices = [
@@ -138,7 +138,7 @@ async def test_nim_stream_connection_error_exhausted_emits_cause_chain():
nim_settings=NimSettings(),
rate_limiter=retrying_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
error = _connection_error("upstream disconnected")
with (
@@ -196,7 +196,7 @@ async def test_nim_stream_openai_5xx_exhausted_emits_user_message(
nim_settings=NimSettings(),
rate_limiter=retrying_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
with (
patch.object(
diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.py
index 9b93b9f8..dd7f7f88 100644
--- a/tests/providers/test_opencode.py
+++ b/tests/providers/test_opencode.py
@@ -1,6 +1,6 @@
"""Tests for the OpenCode OpenAI-compatible provider."""
-from free_claude_code.api.models.anthropic import MessagesRequest
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.opencode import OpenCodeProvider
from tests.providers.support import passthrough_rate_limiter
diff --git a/tests/providers/test_provider_transport_logging.py b/tests/providers/test_provider_transport_logging.py
index d97eccb5..1f1f3165 100644
--- a/tests/providers/test_provider_transport_logging.py
+++ b/tests/providers/test_provider_transport_logging.py
@@ -16,11 +16,10 @@ from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.transports.anthropic_messages import (
stream as native_stream,
)
-from tests.provider_request_mocks import make_openai_compat_stream_request
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
from tests.providers.test_anthropic_messages import (
FakeResponse,
- MockRequest,
NativeProvider,
)
@@ -47,7 +46,7 @@ async def test_native_non_200_logs_exclude_body_text_by_default(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
response = FakeResponse(status_code=500, text="SECRET_UPSTREAM_BODY")
with (
@@ -76,7 +75,7 @@ async def test_native_non_200_logs_body_when_verbose(caplog, provider_config):
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
response = FakeResponse(status_code=500, text="SECRET_UPSTREAM_BODY")
with (
@@ -106,7 +105,7 @@ async def test_native_non_200_verbose_logs_only_capped_error_body(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
tail = "SECRET_TAIL_NOT_LOGGED"
huge = f"{'A' * (NATIVE_MESSAGES_ERROR_BODY_LOG_CAP_BYTES + 50)}{tail}"
response = FakeResponse(status_code=500, text=huge)
@@ -138,7 +137,7 @@ async def test_native_non_200_default_does_not_read_oversized_body(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
huge = f"{'Z' * 500_000}LEAK_MARKER"
response = FakeResponse(status_code=500, text=huge)
@@ -169,7 +168,7 @@ async def test_native_stream_failure_logs_exclude_exception_str_by_default(
provider_config,
rate_limiter=passthrough_rate_limiter(),
)
- req = MockRequest()
+ req = make_messages_request()
response = FakeResponse(
lines=[
"event: ping",
@@ -213,7 +212,7 @@ async def test_openai_compat_stream_failure_default_logs_exclude_exception_str(c
provider = NvidiaNimProvider(
config, nim_settings=NimSettings(), rate_limiter=passthrough_rate_limiter()
)
- req = make_openai_compat_stream_request()
+ req = make_messages_request()
@asynccontextmanager
async def _noop_slot():
@@ -251,7 +250,7 @@ async def test_openai_compat_stream_failure_default_logs_cause_types_only(caplog
provider = NvidiaNimProvider(
config, nim_settings=NimSettings(), rate_limiter=passthrough_rate_limiter()
)
- req = make_openai_compat_stream_request()
+ req = make_messages_request()
error = openai.APIConnectionError(
request=httpx.Request("POST", "http://localhost:1/v1/chat/completions")
)
@@ -294,7 +293,7 @@ async def test_openai_compat_stream_failure_respects_verbose_flag(caplog):
provider = NvidiaNimProvider(
config, nim_settings=NimSettings(), rate_limiter=passthrough_rate_limiter()
)
- req = make_openai_compat_stream_request()
+ req = make_messages_request()
@asynccontextmanager
async def _noop_slot():
diff --git a/tests/providers/test_sambanova.py b/tests/providers/test_sambanova.py
index 4ba8dc1e..257ff869 100644
--- a/tests/providers/test_sambanova.py
+++ b/tests/providers/test_sambanova.py
@@ -9,29 +9,12 @@ from free_claude_code.providers.sambanova import (
SAMBANOVA_DEFAULT_BASE,
SambaNovaProvider,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "Meta-Llama-3.3-70B-Instruct"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("Meta-Llama-3.3-70B-Instruct", **overrides)
@pytest.fixture
@@ -82,7 +65,7 @@ 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(MockRequest())
+ body = sambanova_provider._build_request_body(make_request())
assert body["model"] == "Meta-Llama-3.3-70B-Instruct"
assert body["messages"][0]["role"] == "system"
@@ -91,7 +74,7 @@ def test_build_request_body_basic(sambanova_provider):
def test_build_request_body_preserves_caller_extra_body(sambanova_provider):
- req = MockRequest(extra_body={"metadata": {"user": "u1"}})
+ req = make_request(extra_body={"metadata": {"user": "u1"}})
body = sambanova_provider._build_request_body(req)
@@ -125,7 +108,7 @@ async def test_stream_response_text(sambanova_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in sambanova_provider.stream_response(MockRequest())
+ event async for event in sambanova_provider.stream_response(make_request())
]
assert any(
@@ -160,7 +143,7 @@ async def test_stream_response_tool_call(sambanova_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in sambanova_provider.stream_response(MockRequest())
+ event async for event in sambanova_provider.stream_response(make_request())
]
assert any(
@@ -196,7 +179,7 @@ async def test_stream_response_reasoning_content(sambanova_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in sambanova_provider.stream_response(MockRequest())
+ event async for event in sambanova_provider.stream_response(make_request())
]
assert any(
diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.py
index e491ed96..04a88154 100644
--- a/tests/providers/test_streaming_errors.py
+++ b/tests/providers/test_streaming_errors.py
@@ -29,7 +29,7 @@ from free_claude_code.providers.transports.openai_chat.tool_calls import (
has_committed_sse_output,
iter_heuristic_tool_use_sse,
)
-from tests.provider_request_mocks import make_openai_compat_stream_request
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
@@ -98,9 +98,21 @@ def _make_provider_with_thinking_enabled(enabled: bool):
)
-def _make_request(model="test-model", stream=True):
- """Create a mock request with all fields build_request_body needs."""
- return make_openai_compat_stream_request(model=model, stream=stream)
+def _make_request(model: str = "test-model", stream: bool = True, **overrides: object):
+ """Create a concrete request matching the original streaming-test defaults."""
+ request_overrides: dict[str, object] = {
+ "messages": [],
+ "max_tokens": 4096,
+ "temperature": None,
+ "top_p": None,
+ "system": None,
+ "tools": None,
+ "extra_body": None,
+ "thinking": None,
+ "stream": stream,
+ }
+ request_overrides.update(overrides)
+ return make_messages_request(model, **request_overrides)
def _make_chunk(
@@ -987,19 +999,20 @@ class TestStreamingExceptionHandling:
async def test_incomplete_tool_call_repair_appends_schema_valid_suffix(self):
"""A truncated tool JSON prefix is repaired append-only before tool_use tail."""
provider = _make_provider()
- request = _make_request()
- request.tools = [
- SimpleNamespace(
- name="echo_smoke",
- description="Echo",
- input_schema={
- "type": "object",
- "properties": {"message": {"type": "string"}},
- "required": ["message"],
- "additionalProperties": False,
- },
- )
- ]
+ request = _make_request(
+ tools=[
+ {
+ "name": "echo_smoke",
+ "description": "Echo",
+ "input_schema": {
+ "type": "object",
+ "properties": {"message": {"type": "string"}},
+ "required": ["message"],
+ "additionalProperties": False,
+ },
+ }
+ ]
+ )
tool_chunk = _make_tool_calls_chunk(
name="echo_smoke", arguments='{"message":', tool_id="call_repair"
)
diff --git a/tests/providers/test_vercel.py b/tests/providers/test_vercel.py
index 0eb131af..8c03348b 100644
--- a/tests/providers/test_vercel.py
+++ b/tests/providers/test_vercel.py
@@ -9,29 +9,12 @@ from free_claude_code.providers.vercel import (
VERCEL_AI_GATEWAY_DEFAULT_BASE,
VercelProvider,
)
+from tests.providers.request_factory import make_messages_request
from tests.providers.support import passthrough_rate_limiter
-class MockMessage:
- def __init__(self, role, content):
- self.role = role
- self.content = content
-
-
-class MockRequest:
- def __init__(self, **kwargs):
- self.model = "openai/gpt-5.5"
- self.messages = [MockMessage("user", "Hello")]
- self.max_tokens = 100
- self.temperature = 0.5
- self.top_p = 0.9
- self.system = "System prompt"
- self.stop_sequences = None
- self.tools = []
- self.thinking = MagicMock()
- self.thinking.enabled = True
- for key, value in kwargs.items():
- setattr(self, key, value)
+def make_request(**overrides):
+ return make_messages_request("openai/gpt-5.5", **overrides)
@pytest.fixture
@@ -97,7 +80,7 @@ def test_build_request_body_keeps_max_tokens(vercel_provider):
"max_tokens": 42,
}
- body = vercel_provider._build_request_body(MockRequest())
+ body = vercel_provider._build_request_body(make_request())
assert body["messages"][0].get("name") == "alice"
assert body["max_tokens"] == 42
@@ -105,7 +88,7 @@ def test_build_request_body_keeps_max_tokens(vercel_provider):
def test_build_request_body_preserves_caller_extra_body(vercel_provider):
- req = MockRequest(extra_body={"providerOptions": {"openai": {"reasoning": "low"}}})
+ req = make_request(extra_body={"providerOptions": {"openai": {"reasoning": "low"}}})
body = vercel_provider._build_request_body(req)
@@ -136,7 +119,7 @@ async def test_stream_response_text(vercel_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in vercel_provider.stream_response(MockRequest())
+ event async for event in vercel_provider.stream_response(make_request())
]
assert any(
@@ -168,7 +151,7 @@ async def test_stream_response_reasoning_content(vercel_provider):
mock_create.return_value = mock_stream()
events = [
- event async for event in vercel_provider.stream_response(MockRequest())
+ event async for event in vercel_provider.stream_response(make_request())
]
assert any(
diff --git a/tests/providers/test_wafer.py b/tests/providers/test_wafer.py
index 50a24375..64c85d8f 100644
--- a/tests/providers/test_wafer.py
+++ b/tests/providers/test_wafer.py
@@ -5,8 +5,8 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
-from free_claude_code.api.models.anthropic import Message, MessagesRequest, Tool
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import Message, MessagesRequest, Tool
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.rate_limit import ProviderRateLimiter
from free_claude_code.providers.transports.openai_chat import OpenAIChatTransport
diff --git a/tests/providers/test_zai.py b/tests/providers/test_zai.py
index 14872c55..b5df3722 100644
--- a/tests/providers/test_zai.py
+++ b/tests/providers/test_zai.py
@@ -4,8 +4,8 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
-from free_claude_code.api.models.anthropic import Message, MessagesRequest
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.defaults import ZAI_DEFAULT_BASE
from free_claude_code.providers.exceptions import InvalidRequestError
diff --git a/uv.lock b/uv.lock
index cf3be302..0a5b157e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -561,7 +561,7 @@ wheels = [
[[package]]
name = "free-claude-code"
-version = "3.4.18"
+version = "3.4.19"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },