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

Remove the native Anthropic provider transport (#1067)

Ali Khokhar3a7e0ccf7a3b
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 7139f519..306f573c 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -190,10 +190,9 @@ new places to add unrelated behavior:
[application/execution.py](src/free_claude_code/application/execution.py) only for shared
provider resolution, preflight, tracing, token counting, and streaming.
- [providers/transports/](src/free_claude_code/providers/transports/) owns provider transport
- families. The OpenAI-chat and native Anthropic transport packages split thin
- transport bases from per-request stream runners, recovery event construction,
- request policy, and transport-specific parsing. Shared protocol rules should
- continue moving toward [src/free_claude_code/core/](src/free_claude_code/core/) when they are not provider-specific.
+ behavior. The OpenAI-chat package splits its transport base from per-request
+ stream execution, recovery, request policy, and tool-call assembly. Shared
+ protocol rules belong in [src/free_claude_code/core/](src/free_claude_code/core/).
- [messaging/workflow.py](src/free_claude_code/messaging/workflow.py) coordinates messaging runtime
dependencies. Inbound turn intake, queued node execution, slash command
dependencies, and tree queue internals live in separate modules so new
@@ -462,9 +461,8 @@ otherwise they fall back to `MODEL`.
The router also resolves thinking. Gateway model IDs can force thinking on or
off; otherwise `ModelRouter` applies tier-specific thinking overrides or the
-global setting. `ResolvedModel` carries the selected provider's immutable
-`ProviderCapabilities`, so product policy reads explicit semantic capabilities
-instead of inferring behavior from a provider ID or transport family.
+global setting. `ResolvedModel` carries only the selected route and thinking
+decision; provider catalog metadata does not cross the application boundary.
`GET /v1/models` advertises:
@@ -490,10 +488,9 @@ passes it as `model_catalog_json`. Codex users open the native picker with
Provider metadata is neutral and centralized in
[config/provider_catalog.py](src/free_claude_code/config/provider_catalog.py). Each
-`ProviderDescriptor` declares provider ID, immutable semantic capabilities,
-credential env var, default base URL, settings attribute names, and proxy support.
-Capabilities describe product behavior such as locality and Anthropic server-tool
-passthrough; they do not select a concrete adapter.
+`ProviderDescriptor` declares provider ID, display name, locality, credential env
+var, default base URL, settings attribute names, and proxy support. It does not
+select a concrete adapter.
[providers/runtime/](src/free_claude_code/providers/runtime/) owns construction details for one
closable provider generation: factory wiring, provider configuration, lazy
@@ -537,37 +534,30 @@ compatibility layer.
- `BaseProvider`: the abstract implementation base for cleanup, model listing,
explicit preflight, and `stream_response()`.
-There are two transport families under [providers/transports/](src/free_claude_code/providers/transports/):
+There is one transport family under [providers/transports/](src/free_claude_code/providers/transports/):
- [providers/transports/openai_chat/](src/free_claude_code/providers/transports/openai_chat/)
implements `OpenAIChatTransport` for providers with OpenAI-compatible
`/chat/completions` APIs. Its `transport.py` co-locates the transport base with
the exactly typed private per-request runner and its recovery operations; no
cross-module object reaches through an untyped transport backchannel. The
- package also owns OpenAI request policy and tool-call assembly.
-- [providers/transports/anthropic_messages/](src/free_claude_code/providers/transports/anthropic_messages/)
- implements `AnthropicMessagesTransport` for providers with
- Anthropic-compatible `/messages` APIs. In FCC this transport is intentionally
- local-only for llama.cpp and Ollama. Its `transport.py` likewise owns the
- transport and exactly typed private stream/recovery lifecycle together. The
- package also owns native request policy and HTTP response helpers.
-
-Both transport families explicitly implement preflight by constructing the same
+ package also owns OpenAI request policy, tool-call assembly, and the explicit
+ server-root-to-`/v1` normalization selected by local providers that accept both
+ URL forms.
+
+The transport explicitly implements preflight by constructing the same
upstream request body they will later stream. `BaseProvider` makes that operation
abstract, so a new provider cannot silently omit the commit-boundary validation.
LM Studio composes the OpenAI-chat conversion first and its context-budget probe
second; conversion failure therefore cannot open a stream or run the probe.
-Provider request construction mirrors the transport family split. OpenAI-chat
-providers call the OpenAI request policy for Anthropic-to-OpenAI conversion,
+Providers call the OpenAI request policy for Anthropic-to-OpenAI conversion,
thinking replay selection, `extra_body`, and chat-completion field normalization.
-Native Anthropic providers call the native request policy for raw request
-dumping, default tokens, stream flags, thinking payloads, and `extra_body`
-handling. Concrete provider packages keep only true upstream quirks such as
+Concrete provider packages keep only true upstream quirks such as
Gemini thought signatures, NIM tool-schema aliases, retry downgrades, and NVCF
deployment-failure classification, or DeepSeek attachment/tool/thinking
-compatibility. Cloud providers use OpenAI-chat unless they are local native
-runtimes. DeepSeek intentionally uses its
+compatibility. Ollama, llama.cpp, and LM Studio use their OpenAI-compatible Chat
+Completions endpoints like the remote providers. DeepSeek intentionally uses its
OpenAI-compatible Chat Completions endpoint because that is the endpoint that
reports prompt-cache hit/miss counters; the provider maps those counters back
into Anthropic usage fields for Claude-compatible clients. Cloudflare uses its
@@ -591,7 +581,7 @@ SDK/HTTP failure classification, safe diagnostic construction, transport
cleanup, thinking/tool handling, retry or recovery where supported, and
returning successful Anthropic SSE strings to the service layer. Final failures
cross that boundary as `ExecutionFailure`, not as provider-authored wire events.
-Every provider and both transport families receive the same concrete
+Every provider receives 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.
@@ -619,8 +609,8 @@ usage quirks such as DeepSeek prompt-cache counters.
catalog. Add admin-only help text or provider-specific fields under
[config/admin/](src/free_claude_code/config/admin/) only when the generated manifest is
insufficient.
-4. Implement the provider under [src/free_claude_code/providers/](src/free_claude_code/providers/) using the appropriate
- shared transport family.
+4. Implement the provider under [src/free_claude_code/providers/](src/free_claude_code/providers/) using the shared
+ OpenAI-chat transport.
5. Add a factory in [providers/runtime/factory.py](src/free_claude_code/providers/runtime/factory.py).
6. Add deterministic tests under [tests/providers/](tests/providers/) and any
relevant contract tests.
@@ -642,9 +632,7 @@ usage quirks such as DeepSeek prompt-cache counters.
- tool schema and tool-result handling;
- thinking block handling;
- stream lifecycle through `src/free_claude_code/core/anthropic/streaming`, including the neutral
- stream ledger, Anthropic SSE emitter, native event normalization,
- continuation-body construction, and tool repair;
-- native Anthropic stream policy;
+ stream ledger, Anthropic SSE emitter, continuation-body construction, and tool repair;
- token counting and Anthropic-owned failure-kind-to-wire mapping.
Shared stream behavior lives under
@@ -665,9 +653,7 @@ map the canonical kind and status to their wire error types.
[providers/failure_policy.py](src/free_claude_code/providers/failure_policy.py)
owns generic raw OpenAI SDK and `httpx` exception classification,
transient status/body inference, stable provider wording, and final diagnostic
-construction for those failures. Native Anthropic wire errors are instead
-mapped to canonical failures by the Anthropic protocol package, then consumed
-by provider retry/recovery policy.
+construction for those failures.
Concrete adapters may supply one narrow semantic override for an upstream quirk
that the shared SDK cannot express correctly. The concrete adapter owns the
exact upstream marker, while the shared failure policy owns its canonical
@@ -685,12 +671,11 @@ its existing five-attempt exponential-backoff budget. `ExecutionFailure.retryabl
records provider-policy eligibility; it never tells the client to retry after FCC
has finalized the failure.
-Provider transport packages remain upstream adapters: OpenAI-chat providers
-convert chat chunks into ledger operations, and native Anthropic providers parse
-upstream SSE and canonicalize upstream error events. After retry, continuation,
-and tool salvage are exhausted, a transport discards uncommitted output or
-flushes committed output, closes any open content blocks, and raises
-`ExecutionFailure`. It never synthesizes a terminal Anthropic error event.
+The provider transport remains an upstream adapter: it converts OpenAI chat
+chunks into ledger operations. After retry, continuation, and tool salvage are
+exhausted, it discards uncommitted output or flushes committed output, closes
+open content blocks, and raises `ExecutionFailure`. It never synthesizes a
+terminal Anthropic error event.
The public HTTP commit boundary solely decides whether a final failure can use
non-2xx JSON or must use a terminal protocol event; the protocol packages own
@@ -786,13 +771,10 @@ Messages handler can stream local Anthropic server-tool responses without sendin
request upstream. [api/web_tools/egress.py](src/free_claude_code/api/web_tools/egress.py) enforces URL
scheme and private-network restrictions for `web_fetch`.
-The Messages handler reads the routed model's
-`ProviderCapabilities.server_tool_passthrough` value. Providers without this
-capability reject unsupported server-tool requests before execution instead of
-performing a lossy conversion. Forced `web_search` or `web_fetch` requests are
-handled locally when `ENABLE_WEB_SERVER_TOOLS` is true; when local handling is
-disabled, only providers declaring passthrough may receive those blocks. This
-keeps product policy independent of provider IDs and transport implementation.
+Anthropic server-tool definitions are never passed to upstream OpenAI Chat
+providers because that conversion would be lossy. Forced `web_search` or
+`web_fetch` requests are handled locally when `ENABLE_WEB_SERVER_TOOLS` is true;
+otherwise the Messages handler rejects them before provider execution.
## CLI Launchers And Managed Claude
diff --git a/README.md b/README.md
index 01d98b59..1ea3e792 100644
--- a/README.md
+++ b/README.md
@@ -183,7 +183,7 @@ Start LM Studio's local server, load a tool-capable model, and use the model ide
### llama.cpp
-Start `llama-server` with an Anthropic-compatible `/v1/messages` endpoint and enough context for the model. Use the local model ID with the `llamacpp/` prefix. The default URL is `http://localhost:8080/v1`.
+Start `llama-server` with its OpenAI-compatible Chat Completions API and enough context for the model. Use the local model ID with the `llamacpp/` prefix. `LLAMACPP_BASE_URL` defaults to `http://localhost:8080/v1`; FCC accepts either the server root or an explicit `/v1` suffix.
### Ollama
@@ -192,7 +192,7 @@ ollama pull llama3.1
ollama serve
```
-Use the tag shown by `ollama list` with the `ollama/` prefix. `OLLAMA_BASE_URL` defaults to `http://localhost:11434`; do not append `/v1`.
+Use the tag shown by `ollama list` with the `ollama/` prefix. `OLLAMA_BASE_URL` defaults to `http://localhost:11434`; FCC accepts either the root URL or an explicit `/v1` suffix.
</details>
diff --git a/pyproject.toml b/pyproject.toml
index f31819ae..9cef116c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "free-claude-code"
-version = "3.5.10"
+version = "3.5.12"
description = "Middleware between Claude Code CLI (Anthropic API) and NVIDIA NIM"
readme = "README.md"
requires-python = ">=3.14.0"
diff --git a/smoke/README.md b/smoke/README.md
index 17db8917..c9129677 100644
--- a/smoke/README.md
+++ b/smoke/README.md
@@ -64,8 +64,8 @@ Default targets do not send real bot messages or load voice backends:
| `tools` | forced tool_use and tool_result continuation | tool-capable configured provider |
| `rate_limit` | disconnect cleanup and follow-up request | configured provider |
| `lmstudio` | local `/models` plus OpenAI-chat-backed Messages through proxy | running LM Studio server |
-| `llamacpp` | local `/models` plus native `/messages` through proxy | running llama-server |
-| `ollama` | local `/api/tags` plus native Anthropic messages through proxy | running Ollama server |
+| `llamacpp` | local `/models` plus OpenAI-chat-backed Messages through proxy | running llama-server |
+| `ollama` | local `/v1/models` plus OpenAI-chat-backed Messages through proxy | running Ollama server |
Heavy/side-effectful targets are opt-in:
diff --git a/smoke/capabilities.py b/smoke/capabilities.py
index c74c54a1..51e37dd0 100644
--- a/smoke/capabilities.py
+++ b/smoke/capabilities.py
@@ -316,26 +316,23 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = (
),
CapabilityContract(
"local_providers",
- "llamacpp_native_messages",
+ "llamacpp_openai_chat",
"llamacpp_endpoint",
- "free_claude_code.providers.transports.anthropic_messages.AnthropicMessagesTransport",
- "Anthropic request body and llama.cpp URL",
- "native /messages stream pass-through",
- "SSE error event for local upstream failure",
- (
- "tests/providers/test_llamacpp.py",
- "tests/providers/test_anthropic_messages.py",
- ),
+ "free_claude_code.providers.llamacpp.LlamaCppProvider",
+ "OpenAI Chat request and llama.cpp URL",
+ "Anthropic SSE converted from OpenAI Chat chunks",
+ "typed provider failure for local upstream errors",
+ ("tests/providers/test_llamacpp.py",),
("test_llamacpp_models_endpoint_when_available",),
),
CapabilityContract(
"local_providers",
- "ollama_native_messages",
+ "ollama_openai_chat",
"ollama_endpoint",
"free_claude_code.providers.ollama.OllamaProvider",
- "Anthropic request body and local Ollama root URL",
- "Anthropic SSE stream through the proxy",
- "SSE error event for local upstream failure",
+ "OpenAI Chat request and local Ollama root URL",
+ "Anthropic SSE converted from OpenAI Chat chunks",
+ "typed provider failure for local upstream errors",
("tests/providers/test_ollama.py",),
("test_ollama_models_endpoint_when_available",),
),
diff --git a/smoke/features.py b/smoke/features.py
index 4517988e..0c665b60 100644
--- a/smoke/features.py
+++ b/smoke/features.py
@@ -377,25 +377,22 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = (
),
FeatureCoverage(
"llamacpp_endpoint",
- "llama.cpp native messages and local no-key operation work when running",
+ "llama.cpp OpenAI Chat and local no-key operation work when running",
"public_surface",
- (
- "tests/providers/test_llamacpp.py",
- "tests/providers/test_anthropic_messages.py",
- ),
+ ("tests/providers/test_llamacpp.py",),
("test_llamacpp_models_endpoint_when_available",),
- ("test_llamacpp_native_messages_e2e",),
+ ("test_llamacpp_openai_chat_e2e",),
("llamacpp",),
("LLAMACPP_BASE_URL with running llama-server",),
"skip when local upstream is unavailable",
),
FeatureCoverage(
"ollama_endpoint",
- "Ollama native Anthropic messages and local no-key operation work when running",
+ "Ollama OpenAI Chat and local no-key operation work when running",
"public_surface",
("tests/providers/test_ollama.py",),
("test_ollama_models_endpoint_when_available",),
- ("test_ollama_native_messages_e2e",),
+ ("test_ollama_openai_chat_e2e",),
("ollama",),
("OLLAMA_BASE_URL with running Ollama server",),
"skip when local upstream is unavailable",
diff --git a/smoke/lib/config.py b/smoke/lib/config.py
index 2a4bc490..41653402 100644
--- a/smoke/lib/config.py
+++ b/smoke/lib/config.py
@@ -239,7 +239,7 @@ class SmokeConfig:
self, provider: str, mapped_providers: set[str]
) -> bool:
descriptor = PROVIDER_CATALOG[provider]
- if not descriptor.capabilities.local:
+ if not descriptor.local:
return True
if provider in mapped_providers:
return True
diff --git a/smoke/lib/local_providers.py b/smoke/lib/local_providers.py
index a0136b23..570d77d2 100644
--- a/smoke/lib/local_providers.py
+++ b/smoke/lib/local_providers.py
@@ -5,7 +5,10 @@ from urllib.parse import urljoin
import httpx
import pytest
+from free_claude_code.providers.transports.openai_chat import openai_v1_base_url
+
LOCAL_PROVIDER_PROBE_TIMEOUT_S = 1.5
+_ROOT_OR_V1_PROVIDERS = frozenset({"llamacpp", "ollama"})
def first_local_provider_model_id(
@@ -20,8 +23,8 @@ def first_local_provider_model_id(
pytest.skip(f"missing_env: {provider} base URL is not configured")
timeout = min(timeout_s, LOCAL_PROVIDER_PROBE_TIMEOUT_S)
- if provider == "ollama":
- return _first_ollama_model_id(base_url, timeout_s=timeout)
+ if provider in _ROOT_OR_V1_PROVIDERS:
+ base_url = openai_v1_base_url(base_url)
return _first_openai_compatible_model_id(
provider,
base_url,
@@ -48,20 +51,6 @@ def _first_openai_compatible_model_id(
pytest.fail("product_failure: local /models did not expose a model id")
-def _first_ollama_model_id(base_url: str, *, timeout_s: float) -> str:
- tags_url = f"{base_url.rstrip('/')}/api/tags"
- response = _get_local_provider_response("ollama", tags_url, timeout_s=timeout_s)
- assert response.status_code == 200, response.text
- payload = response.json()
- models = payload.get("models") if isinstance(payload, dict) else None
- if isinstance(models, list):
- for item in models:
- if isinstance(item, dict) and isinstance(item.get("name"), str):
- return item["name"]
- pytest.skip("missing_env: ollama local server has no pulled models")
- pytest.fail("product_failure: ollama /api/tags did not expose models")
-
-
def _get_local_provider_response(
provider: str,
url: str,
diff --git a/smoke/product/test_local_provider_product_live.py b/smoke/product/test_local_provider_product_live.py
index a1e9e27b..c572a673 100644
--- a/smoke/product/test_local_provider_product_live.py
+++ b/smoke/product/test_local_provider_product_live.py
@@ -17,7 +17,7 @@ def test_lmstudio_messages_e2e(smoke_config: SmokeConfig) -> None:
@pytest.mark.smoke_target("llamacpp")
-def test_llamacpp_native_messages_e2e(smoke_config: SmokeConfig) -> None:
+def test_llamacpp_openai_chat_e2e(smoke_config: SmokeConfig) -> None:
_local_provider_messages_e2e(
smoke_config,
provider="llamacpp",
@@ -26,7 +26,7 @@ def test_llamacpp_native_messages_e2e(smoke_config: SmokeConfig) -> None:
@pytest.mark.smoke_target("ollama")
-def test_ollama_native_messages_e2e(smoke_config: SmokeConfig) -> None:
+def test_ollama_openai_chat_e2e(smoke_config: SmokeConfig) -> None:
_local_provider_messages_e2e(
smoke_config,
provider="ollama",
diff --git a/src/free_claude_code/api/handlers/messages.py b/src/free_claude_code/api/handlers/messages.py
index d6e9846a..36ea7e62 100644
--- a/src/free_claude_code/api/handlers/messages.py
+++ b/src/free_claude_code/api/handlers/messages.py
@@ -259,8 +259,6 @@ class MessagesHandler:
)
def _reject_unsupported_server_tools(self, routed: RoutedMessagesRequest) -> None:
- if routed.resolved.capabilities.server_tool_passthrough:
- return
tool_err = unsupported_server_tool_error(
routed.request,
web_tools_enabled=self._settings.enable_web_server_tools,
diff --git a/src/free_claude_code/api/web_server_tools.py b/src/free_claude_code/api/web_server_tools.py
deleted file mode 100644
index 380b29d2..00000000
--- a/src/free_claude_code/api/web_server_tools.py
+++ /dev/null
@@ -1,20 +0,0 @@
-"""Compatibility re-exports for :mod:`api.web_tools` (web_search / web_fetch)."""
-
-import httpx
-
-from free_claude_code.api.web_tools.egress import (
- WebFetchEgressPolicy,
- WebFetchEgressViolation,
- enforce_web_fetch_egress,
-)
-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
-
-__all__ = [
- "WebFetchEgressPolicy",
- "WebFetchEgressViolation",
- "enforce_web_fetch_egress",
- "httpx",
- "is_web_server_tool_request",
- "stream_web_server_tool_response",
-]
diff --git a/src/free_claude_code/api/web_tools/request.py b/src/free_claude_code/api/web_tools/request.py
index 2d3ba484..7db4ad60 100644
--- a/src/free_claude_code/api/web_tools/request.py
+++ b/src/free_claude_code/api/web_tools/request.py
@@ -5,11 +5,6 @@ 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."""
- return "\n".join(content_text(message.content) for message in request.messages)
-
-
def forced_tool_turn_text(request: MessagesRequest) -> str:
"""Text for parsing forced server-tool inputs: latest user turn only (avoids stale history)."""
if not request.messages:
@@ -70,14 +65,12 @@ def unsupported_server_tool_error(
if forced and not web_tools_enabled:
return (
f"tool_choice forces Anthropic server tool {forced!r}, but local web server tools are "
- "disabled (ENABLE_WEB_SERVER_TOOLS=false). Enable them or use a native Anthropic "
- "Messages transport such as ollama or llama.cpp."
+ "disabled (ENABLE_WEB_SERVER_TOOLS=false). Enable them or remove the forced server tool."
)
if not forced and has_listed_anthropic_server_tools(request):
return (
- "OpenAI Chat upstreams cannot use listed Anthropic server tools "
- "(web_search / web_fetch) without the local web server tool handler. Use a native "
- "Anthropic transport such as ollama or llama.cpp, set ENABLE_WEB_SERVER_TOOLS=true and force the tool with "
- "tool_choice, or remove these tools from the request."
+ "FCC cannot pass listed Anthropic server tools (web_search / web_fetch) "
+ "to OpenAI Chat upstreams. Set ENABLE_WEB_SERVER_TOOLS=true and force the "
+ "tool with tool_choice, or remove these tools from the request."
)
return None
diff --git a/src/free_claude_code/application/routing.py b/src/free_claude_code/application/routing.py
index be59c984..e1267f52 100644
--- a/src/free_claude_code/application/routing.py
+++ b/src/free_claude_code/application/routing.py
@@ -9,7 +9,6 @@ from free_claude_code.config.model_refs import parse_model_name, parse_provider_
from free_claude_code.config.provider_catalog import (
PROVIDER_CATALOG,
SUPPORTED_PROVIDER_IDS,
- ProviderCapabilities,
)
from free_claude_code.config.settings import Settings
from free_claude_code.core.anthropic import MessagesRequest, TokenCountRequest
@@ -23,7 +22,6 @@ class ResolvedModel:
provider_model: str
provider_model_ref: str
thinking_enabled: bool
- capabilities: ProviderCapabilities
@dataclass(frozen=True, slots=True)
@@ -69,12 +67,12 @@ class ModelRouter:
provider_model=direct_provider_model,
provider_model_ref=claude_model_name,
thinking_enabled=thinking_enabled,
- capabilities=self._provider_capabilities(direct_provider_id),
)
provider_model_ref = self._resolve_model_ref(claude_model_name)
thinking_enabled = self._resolve_thinking(claude_model_name)
provider_id = parse_provider_type(provider_model_ref)
+ self._validate_provider_id(provider_id)
provider_model = parse_model_name(provider_model_ref)
if provider_model != claude_model_name:
logger.debug(
@@ -86,15 +84,12 @@ class ModelRouter:
provider_model=provider_model,
provider_model_ref=provider_model_ref,
thinking_enabled=thinking_enabled,
- capabilities=self._provider_capabilities(provider_id),
)
@staticmethod
- def _provider_capabilities(provider_id: str) -> ProviderCapabilities:
- descriptor = PROVIDER_CATALOG.get(provider_id)
- if descriptor is None:
+ def _validate_provider_id(provider_id: str) -> None:
+ if provider_id not in PROVIDER_CATALOG:
raise UnknownProviderError.for_provider(provider_id, PROVIDER_CATALOG)
- return descriptor.capabilities
def _direct_provider_model(
self, model_name: str
diff --git a/src/free_claude_code/config/admin/status.py b/src/free_claude_code/config/admin/status.py
index bb5bd616..dbb0fd6d 100644
--- a/src/free_claude_code/config/admin/status.py
+++ b/src/free_claude_code/config/admin/status.py
@@ -14,7 +14,7 @@ def provider_config_status(
"""Return provider configuration status without making network calls."""
statuses: list[dict[str, Any]] = []
for provider_id, descriptor in PROVIDER_CATALOG.items():
- if descriptor.capabilities.local:
+ if descriptor.local:
base_url = ""
if descriptor.base_url_attr is not None:
base_url = _value_for_settings_attr(state, descriptor.base_url_attr)
diff --git a/src/free_claude_code/config/constants.py b/src/free_claude_code/config/constants.py
index 987027ae..c4ea854a 100644
--- a/src/free_claude_code/config/constants.py
+++ b/src/free_claude_code/config/constants.py
@@ -5,6 +5,3 @@ HTTP_CONNECT_TIMEOUT_DEFAULT = 10.0
# Anthropic Messages API default when the client omits max_tokens.
ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS = 81920
-
-# Max bytes read from a non-200 native messages response when verbose error logging is on.
-NATIVE_MESSAGES_ERROR_BODY_LOG_CAP_BYTES = 4096
diff --git a/src/free_claude_code/config/provider_catalog.py b/src/free_claude_code/config/provider_catalog.py
index 9c662626..b39fb69a 100644
--- a/src/free_claude_code/config/provider_catalog.py
+++ b/src/free_claude_code/config/provider_catalog.py
@@ -39,21 +39,13 @@ CEREBRAS_DEFAULT_BASE = "https://api.cerebras.ai/v1"
SAMBANOVA_DEFAULT_BASE = "https://api.sambanova.ai/v1"
-@dataclass(frozen=True, slots=True)
-class ProviderCapabilities:
- """Static provider semantics used by application policy."""
-
- local: bool = False
- server_tool_passthrough: bool = False
-
-
@dataclass(frozen=True, slots=True)
class ProviderDescriptor:
"""Metadata for building :class:`~providers.base.ProviderConfig` and factory wiring."""
provider_id: str
display_name: str
- capabilities: ProviderCapabilities = ProviderCapabilities()
+ local: bool = False
credential_env: str | None = None
credential_url: str | None = None
credential_attr: str | None = None
@@ -258,7 +250,7 @@ PROVIDER_CATALOG: dict[str, ProviderDescriptor] = {
default_base_url=LMSTUDIO_DEFAULT_BASE,
base_url_attr="lm_studio_base_url",
proxy_attr="lmstudio_proxy",
- capabilities=ProviderCapabilities(local=True),
+ local=True,
),
"llamacpp": ProviderDescriptor(
provider_id="llamacpp",
@@ -267,10 +259,7 @@ PROVIDER_CATALOG: dict[str, ProviderDescriptor] = {
default_base_url=LLAMACPP_DEFAULT_BASE,
base_url_attr="llamacpp_base_url",
proxy_attr="llamacpp_proxy",
- capabilities=ProviderCapabilities(
- local=True,
- server_tool_passthrough=True,
- ),
+ local=True,
),
"ollama": ProviderDescriptor(
provider_id="ollama",
@@ -278,10 +267,7 @@ PROVIDER_CATALOG: dict[str, ProviderDescriptor] = {
static_credential="ollama",
default_base_url=OLLAMA_DEFAULT_BASE,
base_url_attr="ollama_base_url",
- capabilities=ProviderCapabilities(
- local=True,
- server_tool_passthrough=True,
- ),
+ local=True,
),
}
diff --git a/src/free_claude_code/config/settings.py b/src/free_claude_code/config/settings.py
index 33b84725..c951ea79 100644
--- a/src/free_claude_code/config/settings.py
+++ b/src/free_claude_code/config/settings.py
@@ -352,16 +352,6 @@ class Settings(BaseSettings):
)
return ",".join(schemes)
- @field_validator("ollama_base_url")
- @classmethod
- def validate_ollama_base_url(cls, v: str) -> str:
- if v.rstrip("/").endswith("/v1"):
- raise ValueError(
- "OLLAMA_BASE_URL must be the Ollama root URL for native Anthropic "
- "messages, e.g. http://localhost:11434 (without /v1)."
- )
- return v
-
@field_validator("model", "model_opus", "model_sonnet", "model_haiku")
@classmethod
def validate_model_format(cls, v: str | None) -> str | None:
diff --git a/src/free_claude_code/core/anthropic/__init__.py b/src/free_claude_code/core/anthropic/__init__.py
index ac17f878..699254a2 100644
--- a/src/free_claude_code/core/anthropic/__init__.py
+++ b/src/free_claude_code/core/anthropic/__init__.py
@@ -12,7 +12,6 @@ from .errors import (
anthropic_error_type_for_failure,
anthropic_failure_payload,
anthropic_status_for_error_type,
- execution_failure_from_anthropic_error,
)
from .models import (
ContentBlockDocument,
@@ -36,8 +35,7 @@ from .models import (
Tool,
Usage,
)
-from .native_messages_request import sanitize_native_messages_thinking_policy
-from .request_serialization import serialize_tool_result_content
+from .request_serialization import dump_messages_request, serialize_tool_result_content
from .request_snapshot import anthropic_request_snapshot
from .sse_aggregation import aggregate_anthropic_sse_to_message
from .streaming import (
@@ -90,14 +88,13 @@ __all__ = [
"anthropic_request_snapshot",
"anthropic_status_for_error_type",
"build_base_request_body",
- "execution_failure_from_anthropic_error",
+ "dump_messages_request",
"extract_text_from_content",
"format_sse_event",
"get_block_attr",
"get_block_type",
"get_token_count",
"map_stop_reason",
- "sanitize_native_messages_thinking_policy",
"serialize_tool_result_content",
"set_if_not_none",
]
diff --git a/src/free_claude_code/core/anthropic/conversion.py b/src/free_claude_code/core/anthropic/conversion.py
index 5a825a0d..53ad699f 100644
--- a/src/free_claude_code/core/anthropic/conversion.py
+++ b/src/free_claude_code/core/anthropic/conversion.py
@@ -38,14 +38,10 @@ def _openai_reject_native_only_top_level_fields(
return
raise OpenAIConversionError(
"OpenAI chat conversion does not support these top-level request fields: "
- f"{sorted(str(k) for k in extra)}. Use a native Anthropic transport provider."
+ f"{sorted(str(k) for k in extra)}. Remove the unsupported fields."
)
-def _tool_name(tool: Any) -> str:
- return str(getattr(tool, "name", "") or "")
-
-
def _tool_input_schema(tool: Any) -> dict[str, Any]:
schema = getattr(tool, "input_schema", None)
if isinstance(schema, dict):
@@ -146,7 +142,7 @@ def _assert_no_forbidden_assistant_block(block: Any) -> None:
):
raise OpenAIConversionError(
"OpenAI chat conversion does not support Anthropic server tool blocks "
- f"({block_type!r} in an assistant message). Use a native Anthropic transport provider."
+ f"({block_type!r} in an assistant message). Remove the unsupported block."
)
@@ -501,8 +497,7 @@ class AnthropicToOpenAIConverter:
elif block_type == "image":
raise OpenAIConversionError(
"User message image blocks are not supported for OpenAI chat "
- "conversion; use a vision-capable native Anthropic provider or "
- "extend the converter."
+ "conversion; remove the image blocks or extend the converter."
)
elif block_type == "tool_result":
flush_text()
diff --git a/src/free_claude_code/core/anthropic/errors.py b/src/free_claude_code/core/anthropic/errors.py
index e19d980b..200b1116 100644
--- a/src/free_claude_code/core/anthropic/errors.py
+++ b/src/free_claude_code/core/anthropic/errors.py
@@ -1,6 +1,5 @@
"""Anthropic error types and envelopes."""
-from collections.abc import Mapping
from typing import Any
from free_claude_code.core.diagnostics import redact_sensitive_error_text
@@ -30,19 +29,6 @@ _FAILURE_ERROR_TYPES = {
FailureKind.UNAVAILABLE: "api_error",
}
-_ERROR_TYPE_FAILURE_KINDS = {
- "invalid_request_error": FailureKind.INVALID_REQUEST,
- "request_too_large": FailureKind.INVALID_REQUEST,
- "authentication_error": FailureKind.AUTHENTICATION,
- "billing_error": FailureKind.PERMISSION,
- "permission_error": FailureKind.PERMISSION,
- "not_found_error": FailureKind.INVALID_REQUEST,
- "rate_limit_error": FailureKind.RATE_LIMIT,
- "overloaded_error": FailureKind.OVERLOADED,
- "timeout_error": FailureKind.TIMEOUT,
- "api_error": FailureKind.UPSTREAM,
-}
-
def anthropic_error_type_for_failure(
failure: FailureKind | ExecutionFailure,
@@ -99,38 +85,3 @@ def anthropic_failure_payload(
def anthropic_status_for_error_type(error_type: str) -> int:
"""Return the standard HTTP status for an Anthropic error type."""
return _ANTHROPIC_ERROR_STATUS_CODES.get(error_type, 500)
-
-
-def execution_failure_from_anthropic_error(
- data: Mapping[str, Any],
-) -> ExecutionFailure:
- """Canonicalize one native upstream Anthropic error event."""
- error = data.get("error")
- if not isinstance(error, Mapping):
- error = data
- raw_type = error.get("type")
- error_type = (
- raw_type.strip()
- if isinstance(raw_type, str) and raw_type.strip()
- else "api_error"
- )
- raw_message = error.get("message")
- message = (
- redact_sensitive_error_text(raw_message.strip())
- if isinstance(raw_message, str) and raw_message.strip()
- else "Provider request failed unexpectedly."
- )
- kind = _ERROR_TYPE_FAILURE_KINDS.get(error_type, FailureKind.UPSTREAM)
- return ExecutionFailure(
- kind=kind,
- status_code=anthropic_status_for_error_type(error_type),
- message=message,
- retryable=kind
- in {
- FailureKind.RATE_LIMIT,
- FailureKind.OVERLOADED,
- FailureKind.TIMEOUT,
- FailureKind.UPSTREAM,
- FailureKind.UNAVAILABLE,
- },
- )
diff --git a/src/free_claude_code/core/anthropic/native_messages_request.py b/src/free_claude_code/core/anthropic/native_messages_request.py
deleted file mode 100644
index 77b45ade..00000000
--- a/src/free_claude_code/core/anthropic/native_messages_request.py
+++ /dev/null
@@ -1,128 +0,0 @@
-"""Native Anthropic Messages request body construction (JSON-ready dicts)."""
-
-from typing import Any
-
-from .models import MessagesRequest
-
-_REQUEST_FIELDS = (
- "model",
- "messages",
- "system",
- "max_tokens",
- "stop_sequences",
- "stream",
- "temperature",
- "top_p",
- "top_k",
- "metadata",
- "tools",
- "tool_choice",
- "thinking",
- "context_management",
- "output_config",
- "mcp_servers",
- "extra_body",
-)
-
-
-def _dump_request_fields(request_data: MessagesRequest) -> dict[str, Any]:
- """Extract the public Anthropic request fields."""
- 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)
-
-
-def sanitize_native_messages_thinking_policy(
- messages: Any, *, thinking_enabled: bool
-) -> Any:
- """Filter assistant message thinking blocks for upstream native Anthropic JSON.
-
- When ``thinking_enabled`` is false, remove ``thinking`` and ``redacted_thinking``
- history so disabled policy is not undermined by prior turns.
-
- When true, keep ``redacted_thinking`` and signed ``thinking``; remove only
- unsigned plain ``thinking`` blocks (not replayable).
- """
- if not isinstance(messages, list):
- return messages
-
- sanitized_messages: list[Any] = []
- for message in messages:
- if not isinstance(message, dict):
- sanitized_messages.append(message)
- continue
-
- if message.get("role") != "assistant":
- sanitized_messages.append(message)
- continue
-
- content = message.get("content")
- if not isinstance(content, list):
- sanitized_messages.append(message)
- continue
-
- if not thinking_enabled:
- sanitized_content = [
- block
- for block in content
- if not (
- isinstance(block, dict)
- and block.get("type") in ("thinking", "redacted_thinking")
- )
- ]
- else:
- sanitized_content = [
- block
- for block in content
- if not (
- isinstance(block, dict)
- and block.get("type") == "thinking"
- and not isinstance(block.get("signature"), str)
- )
- ]
-
- sanitized_message = dict(message)
- sanitized_message["content"] = sanitized_content or ""
- sanitized_messages.append(sanitized_message)
-
- return sanitized_messages
-
-
-def build_base_native_anthropic_request_body(
- request: MessagesRequest,
- *,
- default_max_tokens: int,
- thinking_enabled: bool,
-) -> dict[str, Any]:
- """Serialize a Pydantic messages request to a generic native Anthropic body."""
- body = dump_raw_messages_request(request)
-
- body.pop("extra_body", None)
-
- if "thinking" in body:
- thinking_cfg = body.pop("thinking")
- if thinking_enabled and isinstance(thinking_cfg, dict):
- thinking_payload: dict[str, Any] = {"type": "enabled"}
- budget_tokens = thinking_cfg.get("budget_tokens")
- if isinstance(budget_tokens, int):
- thinking_payload["budget_tokens"] = budget_tokens
- body["thinking"] = thinking_payload
-
- if "max_tokens" not in body:
- body["max_tokens"] = default_max_tokens
-
- if "messages" in body:
- body["messages"] = sanitize_native_messages_thinking_policy(
- body["messages"],
- thinking_enabled=thinking_enabled,
- )
-
- return body
diff --git a/src/free_claude_code/core/anthropic/native_sse_block_policy.py b/src/free_claude_code/core/anthropic/native_sse_block_policy.py
deleted file mode 100644
index ec0aad1f..00000000
--- a/src/free_claude_code/core/anthropic/native_sse_block_policy.py
+++ /dev/null
@@ -1,303 +0,0 @@
-"""Shared native Anthropic SSE thinking policy, block remapping, and overlap repair.
-
-Used by line-mode :class:`providers.transports.anthropic_messages.AnthropicMessagesTransport`
-providers.
-"""
-
-import copy
-import json
-from dataclasses import dataclass, field
-from typing import Any
-
-__all__ = [
- "NativeSseBlockPolicyState",
- "format_native_sse_event",
- "parse_native_sse_event",
- "transform_native_sse_block_event",
-]
-
-
-@dataclass
-class _UpstreamBlockState:
- """Per-upstream content block: segment index and liveness in the model stream."""
-
- block_type: str
- down_index: int
- open: bool
- last_start_block: dict[str, Any] | None = None
-
-
-@dataclass
-class NativeSseBlockPolicyState:
- """Track per-upstream content blocks and remapped Anthropic ``index`` field."""
-
- next_index: int = 0
- by_upstream: dict[int, _UpstreamBlockState] = field(default_factory=dict)
- dropped_indexes: set[int] = field(default_factory=set)
- pending_suppressed_stops: set[int] = field(default_factory=set)
- message_stopped: bool = False
-
-
-def format_native_sse_event(event_name: str | None, data_text: str) -> str:
- """Format an SSE event from its event name and data payload."""
- lines: list[str] = []
- if event_name:
- lines.append(f"event: {event_name}")
- lines.extend(f"data: {line}" for line in data_text.splitlines())
- return "\n".join(lines) + "\n\n"
-
-
-def parse_native_sse_event(event: str) -> tuple[str | None, str]:
- """Extract the event name and raw data payload from an SSE event."""
- event_name = None
- data_lines: list[str] = []
- for line in event.strip().splitlines():
- if line.startswith("event:"):
- event_name = line[6:].strip()
- elif line.startswith("data:"):
- data_lines.append(line[5:].lstrip())
- return event_name, "\n".join(data_lines)
-
-
-def _delta_type_to_block_kind(delta_type: Any) -> str | None:
- """Map a content_block_delta type to a content block kind (text/thinking/tool_use)."""
- if not isinstance(delta_type, str):
- return None
- if delta_type in {"thinking_delta", "signature_delta"}:
- return "thinking"
- if delta_type == "text_delta":
- return "text"
- if delta_type == "input_json_delta":
- return "tool_use"
- return None
-
-
-def _synthetic_start_content_block(
- block_kind: str,
- *,
- upstream_index: int,
- stored_tool_block: dict[str, Any] | None = None,
-) -> dict[str, Any]:
- """Build a `content_block` for a `content_block_start` with empty streaming fields."""
- if block_kind == "tool_use":
- if (
- isinstance(stored_tool_block, dict)
- and stored_tool_block.get("type") == "tool_use"
- ):
- tool_id = stored_tool_block.get("id")
- name = stored_tool_block.get("name")
- inp = stored_tool_block.get("input")
- return {
- "type": "tool_use",
- "id": tool_id
- if isinstance(tool_id, str) and tool_id
- else f"toolu_or_{upstream_index}",
- "name": name if isinstance(name, str) else "",
- "input": inp if isinstance(inp, dict) else {},
- }
- return {
- "type": "tool_use",
- "id": f"toolu_or_{upstream_index}",
- "name": "",
- "input": {},
- }
- if block_kind == "thinking":
- return {"type": "thinking", "thinking": ""}
- if block_kind == "text":
- return {"type": "text", "text": ""}
- return {"type": "text", "text": ""}
-
-
-def _should_drop_block_type(block_type: Any, *, thinking_enabled: bool) -> bool:
- if not isinstance(block_type, str):
- return False
- if block_type.startswith("redacted_thinking"):
- return not thinking_enabled
- return not thinking_enabled and "thinking" in block_type
-
-
-def _synthetic_close_other_open_blocks(
- state: NativeSseBlockPolicyState, current_upstream: int
-) -> str:
- """Close every open block except `current_upstream` and track duplicate upstream stops."""
- out: list[str] = []
- for upstream, seg in list(state.by_upstream.items()):
- if upstream == current_upstream or not seg.open:
- continue
- out.append(
- format_native_sse_event(
- "content_block_stop",
- json.dumps(
- {
- "type": "content_block_stop",
- "index": seg.down_index,
- }
- ),
- )
- )
- seg.open = False
- state.pending_suppressed_stops.add(upstream)
- return "".join(out)
-
-
-def _allocate_new_segment(
- state: NativeSseBlockPolicyState,
- upstream_index: int,
- block_type: str,
- *,
- last_start_block: dict[str, Any] | None = None,
-) -> int:
- """Assign a new downstream `index` for a segment and record upstream state."""
- new_idx = state.next_index
- state.next_index += 1
- state.by_upstream[upstream_index] = _UpstreamBlockState(
- block_type=block_type,
- down_index=new_idx,
- open=True,
- last_start_block=last_start_block,
- )
- return new_idx
-
-
-def transform_native_sse_block_event(
- event: str,
- state: NativeSseBlockPolicyState,
- *,
- thinking_enabled: bool,
-) -> str | None:
- """Normalize native Anthropic SSE events and enforce local thinking policy."""
- event_name, data_text = parse_native_sse_event(event)
- if not event_name or not data_text:
- return event
-
- try:
- payload = json.loads(data_text)
- except json.JSONDecodeError:
- return event
-
- if event_name == "content_block_start":
- block = payload.get("content_block")
- if not isinstance(block, dict):
- return event
- block_type = block.get("type")
- upstream_index = payload.get("index")
- if not isinstance(upstream_index, int):
- return event
- if _should_drop_block_type(block_type, thinking_enabled=thinking_enabled):
- state.dropped_indexes.add(upstream_index)
- return None
-
- if not isinstance(block_type, str):
- return event
- prefix = _synthetic_close_other_open_blocks(state, upstream_index)
- stored = copy.deepcopy(block)
- new_idx = _allocate_new_segment(
- state,
- upstream_index,
- block_type=block_type,
- last_start_block=stored,
- )
- payload["index"] = new_idx
- return prefix + format_native_sse_event(event_name, json.dumps(payload))
-
- if event_name == "content_block_delta":
- delta = payload.get("delta")
- if not isinstance(delta, dict):
- return event
- delta_type = delta.get("type")
- upstream_index = payload.get("index")
- if not isinstance(upstream_index, int):
- return event
- if upstream_index in state.dropped_indexes:
- return None
- if _should_drop_block_type(delta_type, thinking_enabled=thinking_enabled):
- return None
-
- block_kind = _delta_type_to_block_kind(delta_type)
- if block_kind is None:
- return event
-
- seg = state.by_upstream.get(upstream_index)
- if seg and seg.open:
- payload["index"] = seg.down_index
- return format_native_sse_event(event_name, json.dumps(payload))
-
- if seg is not None and not seg.open:
- # More deltas for an upstream block after a synthetic (or other) close:
- # reopen with a new downstream `index` and emit a synthetic `content_block_start` first.
- state.pending_suppressed_stops.discard(upstream_index)
- carry = seg.last_start_block
- new_idx = _allocate_new_segment(
- state,
- upstream_index,
- block_type=block_kind,
- last_start_block=carry,
- )
- stored_tool = (
- carry
- if isinstance(carry, dict) and carry.get("type") == "tool_use"
- else None
- )
- start_payload = {
- "type": "content_block_start",
- "index": new_idx,
- "content_block": _synthetic_start_content_block(
- block_kind,
- upstream_index=upstream_index,
- stored_tool_block=stored_tool,
- ),
- }
- prefix = format_native_sse_event(
- "content_block_start", json.dumps(start_payload)
- )
- payload["index"] = new_idx
- return prefix + format_native_sse_event(event_name, json.dumps(payload))
-
- # Delta with no prior `content_block_start` in this stream
- if block_kind in ("text", "tool_use"):
- synthetic_block = _synthetic_start_content_block(
- block_kind,
- upstream_index=upstream_index,
- )
- new_idx = _allocate_new_segment(
- state,
- upstream_index,
- block_type=block_kind,
- last_start_block=copy.deepcopy(synthetic_block),
- )
- start_payload = {
- "type": "content_block_start",
- "index": new_idx,
- "content_block": synthetic_block,
- }
- prefix = format_native_sse_event(
- "content_block_start", json.dumps(start_payload)
- )
- payload["index"] = new_idx
- return prefix + format_native_sse_event(event_name, json.dumps(payload))
- # thinking: pass through raw (unusual upstream shape)
- return event
-
- if event_name == "content_block_stop":
- upstream_index = payload.get("index")
- if not isinstance(upstream_index, int):
- return event
- if upstream_index in state.dropped_indexes:
- return None
- if upstream_index in state.pending_suppressed_stops:
- state.pending_suppressed_stops.discard(upstream_index)
- return None
-
- seg = state.by_upstream.get(upstream_index)
- if seg is not None and seg.open:
- payload["index"] = seg.down_index
- seg.open = False
- return format_native_sse_event(event_name, json.dumps(payload))
- if seg is not None:
- # Spurious or duplicate `content_block_stop` for a closed block.
- return None
- if not thinking_enabled:
- return None
- return event
-
- return event
diff --git a/src/free_claude_code/core/anthropic/request_serialization.py b/src/free_claude_code/core/anthropic/request_serialization.py
index 0603446a..7b3aba68 100644
--- a/src/free_claude_code/core/anthropic/request_serialization.py
+++ b/src/free_claude_code/core/anthropic/request_serialization.py
@@ -3,6 +3,38 @@
import json
from typing import Any
+from .models import MessagesRequest
+
+_MESSAGES_REQUEST_FIELDS = (
+ "model",
+ "messages",
+ "system",
+ "max_tokens",
+ "stop_sequences",
+ "stream",
+ "temperature",
+ "top_p",
+ "top_k",
+ "metadata",
+ "tools",
+ "tool_choice",
+ "thinking",
+ "context_management",
+ "output_config",
+ "mcp_servers",
+ "extra_body",
+)
+
+
+def dump_messages_request(request: MessagesRequest) -> dict[str, Any]:
+ """Return JSON-ready public Messages fields without FCC routing state."""
+ raw = request.model_dump(exclude_none=True)
+ return {
+ field: raw[field]
+ for field in _MESSAGES_REQUEST_FIELDS
+ if field in raw and raw[field] is not None
+ }
+
def serialize_tool_result_content(content: Any) -> str:
"""Serialize Anthropic ``tool_result.content`` into provider-safe text."""
diff --git a/src/free_claude_code/core/anthropic/sse_aggregation.py b/src/free_claude_code/core/anthropic/sse_aggregation.py
index 49391dd9..9160bb44 100644
--- a/src/free_claude_code/core/anthropic/sse_aggregation.py
+++ b/src/free_claude_code/core/anthropic/sse_aggregation.py
@@ -12,7 +12,7 @@ import uuid
from collections.abc import AsyncIterator
from typing import Any
-from .native_sse_block_policy import parse_native_sse_event
+from .stream_contracts import parse_sse_text
__all__ = ["aggregate_anthropic_sse_to_message"]
@@ -91,15 +91,8 @@ async def aggregate_anthropic_sse_to_message(
buffer += chunk
while "\n\n" in buffer:
raw_event, buffer = buffer.split("\n\n", 1)
- _event_name, data_text = parse_native_sse_event(raw_event + "\n\n")
- if not data_text:
- continue
- try:
- payload = json.loads(data_text)
- except json.JSONDecodeError:
- continue
- if isinstance(payload, dict):
- handle_payload(payload)
+ for event in parse_sse_text(raw_event + "\n\n"):
+ handle_payload(event.data)
content: list[dict[str, Any]] = []
for idx in sorted(blocks):
diff --git a/src/free_claude_code/core/anthropic/streaming/ledger.py b/src/free_claude_code/core/anthropic/streaming/ledger.py
index d20370b4..5625945a 100644
--- a/src/free_claude_code/core/anthropic/streaming/ledger.py
+++ b/src/free_claude_code/core/anthropic/streaming/ledger.py
@@ -10,13 +10,9 @@ from typing import Any
from loguru import logger
-from free_claude_code.core.anthropic.stream_contracts import SSEEvent
-
from .emitter import AnthropicSseEmitter
from .recovery import (
ToolSchema,
- accept_tool_json_repair,
- continuation_suffix,
parse_complete_tool_input,
)
@@ -388,57 +384,6 @@ class AnthropicStreamLedger:
if state.started:
yield self.stop_tool_block(tool_index)
- def ingest_native_event(self, event: SSEEvent) -> str | None:
- """Record a native Anthropic SSE event and re-emit its normalized shape."""
- if event.event == "message_start":
- message = event.data.get("message")
- if isinstance(message, dict):
- mid = message.get("id")
- if isinstance(mid, str) and mid:
- self.message_id = mid
- model = message.get("model")
- if isinstance(model, str) and model:
- self.model = model
- self.message_started = True
- return self._emitter.event(event.event, event.data)
-
- if event.event == "content_block_start":
- raw_index = event.data.get("index")
- block = event.data.get("content_block")
- if isinstance(raw_index, int) and isinstance(block, dict):
- self._record_block_start(raw_index, block)
- return self._emitter.event(event.event, event.data)
-
- if event.event == "content_block_delta":
- raw_index = event.data.get("index")
- delta = event.data.get("delta")
- if isinstance(raw_index, int) and isinstance(delta, dict):
- self._record_block_delta(raw_index, delta)
- return self._emitter.event(event.event, event.data)
-
- if event.event == "content_block_stop":
- raw_index = event.data.get("index")
- if isinstance(raw_index, int):
- self._record_block_stop(raw_index)
- return self._emitter.event(event.event, event.data)
-
- if event.event == "message_delta":
- delta = event.data.get("delta")
- if isinstance(delta, dict):
- stop_reason = delta.get("stop_reason")
- if isinstance(stop_reason, str):
- self.stop_reason = stop_reason
- return self._emitter.event(event.event, event.data)
-
- if event.event == "message_stop":
- self.message_stopped = True
- return self._emitter.event(event.event, event.data)
-
- if event.event == "error":
- return self._emitter.event(event.event, event.data)
-
- return self._emitter.event(event.event, event.data)
-
def close_unclosed_blocks(self) -> Iterator[str]:
while self._open_stack:
idx = self._open_stack.pop()
@@ -451,44 +396,6 @@ class AnthropicStreamLedger:
{"type": "content_block_stop", "index": idx},
)
- def append_text_suffix(self, suffix: str) -> Iterator[str]:
- if not suffix or not self.can_append_content():
- return
- yield from self.ensure_text_block()
- active = self._last_open_block("text")
- if active is None:
- return
- yield self.content_block_delta(active.index, "text_delta", suffix)
-
- def append_thinking_suffix(self, suffix: str) -> Iterator[str]:
- if not suffix or not self.can_append_content():
- return
- yield from self.ensure_thinking_block()
- active = self._last_open_block("thinking")
- if active is None:
- return
- yield self.content_block_delta(active.index, "thinking_delta", suffix)
-
- def append_tool_repair_suffix(self, tool_index: int, suffix: str) -> Iterator[str]:
- tool_blocks = self.tool_blocks()
- if (
- tool_index >= len(tool_blocks)
- or not suffix
- or not self.can_append_content()
- ):
- return
- block = tool_blocks[tool_index]
- yield self.content_block_delta(block.index, "input_json_delta", suffix)
-
- def success_tail(self, stop_reason: str) -> Iterator[str]:
- yield from self.close_unclosed_blocks()
- if self.stop_reason is None:
- yield self.message_delta(
- self.final_stop_reason(stop_reason), self.estimate_output_tokens()
- )
- if not self.message_stopped:
- yield self.message_stop()
-
def can_salvage_tool_use(self, schemas: dict[str, ToolSchema]) -> bool:
tool_blocks = self.tool_blocks()
if not tool_blocks:
@@ -500,27 +407,6 @@ class AnthropicStreamLedger:
return False
return True
- def accept_tool_repair(
- self, tool_index: int, candidate: str, schemas: dict[str, ToolSchema]
- ) -> str | None:
- tool_blocks = self.tool_blocks()
- if tool_index >= len(tool_blocks):
- return None
- block = tool_blocks[tool_index]
- repair = accept_tool_json_repair(
- block.content,
- candidate,
- tool_name=block.name,
- schemas=schemas,
- )
- return repair.suffix if repair is not None else None
-
- def continuation_text_suffix(self, candidate: str) -> str | None:
- return continuation_suffix(self.accumulated_text, candidate)
-
- def continuation_thinking_suffix(self, candidate: str) -> str | None:
- return continuation_suffix(self.accumulated_reasoning, candidate)
-
def tool_blocks(self) -> list[StreamBlockState]:
return [
block
@@ -543,9 +429,6 @@ class AnthropicStreamLedger:
def has_content_block(self) -> bool:
return bool(self._content_blocks)
- def can_append_content(self) -> bool:
- return self.stop_reason is None and not self.message_stopped
-
def final_stop_reason(self, fallback: str) -> str:
if self.has_emitted_tool_block():
return "tool_use"
diff --git a/src/free_claude_code/core/trace.py b/src/free_claude_code/core/trace.py
index 121928d1..713e6337 100644
--- a/src/free_claude_code/core/trace.py
+++ b/src/free_claude_code/core/trace.py
@@ -194,23 +194,3 @@ def provider_chat_body_snapshot(body: Mapping[str, Any]) -> dict[str, Any]:
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)
-
-
-def provider_native_messages_body_snapshot(body: Mapping[str, Any]) -> dict[str, Any]:
- """Sanitized Anthropic Messages API body subset for traces."""
- keys = (
- "model",
- "messages",
- "system",
- "tools",
- "tool_choice",
- "max_tokens",
- "thinking",
- "metadata",
- "temperature",
- "top_p",
- "top_k",
- "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)
diff --git a/src/free_claude_code/providers/deepseek/compat.py b/src/free_claude_code/providers/deepseek/compat.py
index ed2c7b3e..3eba82c4 100644
--- a/src/free_claude_code/providers/deepseek/compat.py
+++ b/src/free_claude_code/providers/deepseek/compat.py
@@ -7,11 +7,11 @@ from loguru import logger
from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from free_claude_code.core.anthropic import 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,
+from free_claude_code.core.anthropic import (
+ dump_messages_request,
+ serialize_tool_result_content,
)
+from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.providers.transports.openai_chat import (
OpenAIChatRequestPolicy,
build_openai_chat_request_body,
@@ -48,7 +48,7 @@ def build_deepseek_request_body(
len(request_data.messages),
)
- data = dump_raw_messages_request(request_data)
+ data = dump_messages_request(request_data)
if "messages" in data:
data["messages"] = _strip_unsupported_attachment_blocks(data["messages"])
_validate_deepseek_request_dict(data)
diff --git a/src/free_claude_code/providers/llamacpp/client.py b/src/free_claude_code/providers/llamacpp/client.py
index cc8202af..7ab715f8 100644
--- a/src/free_claude_code/providers/llamacpp/client.py
+++ b/src/free_claude_code/providers/llamacpp/client.py
@@ -1,20 +1,40 @@
-"""Llama.cpp provider implementation."""
+"""llama.cpp provider implementation."""
+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 LLAMACPP_DEFAULT_BASE
from free_claude_code.providers.rate_limit import ProviderRateLimiter
-from free_claude_code.providers.transports.anthropic_messages import (
- AnthropicMessagesTransport,
+from free_claude_code.providers.transports.openai_chat import (
+ OpenAIChatRequestPolicy,
+ OpenAIChatTransport,
+ build_openai_chat_request_body,
+ openai_v1_base_url,
+)
+
+_REQUEST_POLICY = OpenAIChatRequestPolicy(
+ provider_name="LLAMACPP",
+ default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
)
-class LlamaCppProvider(AnthropicMessagesTransport):
- """Llama.cpp provider using native Anthropic Messages endpoint."""
+class LlamaCppProvider(OpenAIChatTransport):
+ """llama.cpp provider using OpenAI-compatible Chat Completions."""
def __init__(self, config: ProviderConfig, *, rate_limiter: ProviderRateLimiter):
super().__init__(
config,
provider_name="LLAMACPP",
- default_base_url=LLAMACPP_DEFAULT_BASE,
+ base_url=openai_v1_base_url(config.base_url or LLAMACPP_DEFAULT_BASE),
+ api_key=config.api_key or "llamacpp",
rate_limiter=rate_limiter,
)
+
+ def _build_request_body(
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
+ ) -> dict:
+ return build_openai_chat_request_body(
+ request,
+ thinking_enabled=self._is_thinking_enabled(request, thinking_enabled),
+ policy=_REQUEST_POLICY,
+ )
diff --git a/src/free_claude_code/providers/model_listing.py b/src/free_claude_code/providers/model_listing.py
index d1cafef3..3d0f6f17 100644
--- a/src/free_claude_code/providers/model_listing.py
+++ b/src/free_claude_code/providers/model_listing.py
@@ -89,31 +89,6 @@ def extract_openrouter_tool_model_infos(
return frozenset(model_infos)
-def extract_ollama_model_ids(payload: Any, *, provider_name: str) -> frozenset[str]:
- """Extract model ids from Ollama's native ``/api/tags`` response."""
- models = _field(payload, "models")
- if not _is_sequence(models):
- raise _malformed(provider_name, "expected top-level models array")
-
- model_ids: set[str] = set()
- for item in models:
- item_ids: list[str] = []
- for key in ("model", "name"):
- value = _field(item, key)
- if isinstance(value, str) and value.strip():
- item_ids.append(value)
- if not item_ids:
- raise _malformed(
- provider_name,
- "expected every models item to include model or name",
- )
- model_ids.update(item_ids)
-
- if not model_ids:
- raise _malformed(provider_name, "response did not include any model ids")
- return frozenset(model_ids)
-
-
def _field(item: Any, name: str) -> Any:
if isinstance(item, Mapping):
return item.get(name)
diff --git a/src/free_claude_code/providers/ollama/client.py b/src/free_claude_code/providers/ollama/client.py
index 8f9dc7bd..2c309b68 100644
--- a/src/free_claude_code/providers/ollama/client.py
+++ b/src/free_claude_code/providers/ollama/client.py
@@ -1,43 +1,40 @@
"""Ollama provider implementation."""
-import httpx
-
+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 OLLAMA_DEFAULT_BASE
-from free_claude_code.providers.model_listing import extract_ollama_model_ids
from free_claude_code.providers.rate_limit import ProviderRateLimiter
-from free_claude_code.providers.transports.anthropic_messages import (
- AnthropicMessagesTransport,
+from free_claude_code.providers.transports.openai_chat import (
+ OpenAIChatRequestPolicy,
+ OpenAIChatTransport,
+ build_openai_chat_request_body,
+ openai_v1_base_url,
+)
+
+_REQUEST_POLICY = OpenAIChatRequestPolicy(
+ provider_name="OLLAMA",
+ default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
)
-class OllamaProvider(AnthropicMessagesTransport):
- """Ollama provider using native Anthropic Messages API."""
+class OllamaProvider(OpenAIChatTransport):
+ """Ollama provider using OpenAI-compatible Chat Completions."""
def __init__(self, config: ProviderConfig, *, rate_limiter: ProviderRateLimiter):
super().__init__(
config,
provider_name="OLLAMA",
- default_base_url=OLLAMA_DEFAULT_BASE,
+ base_url=openai_v1_base_url(config.base_url or OLLAMA_DEFAULT_BASE),
+ api_key=config.api_key or "ollama",
rate_limiter=rate_limiter,
)
- self._api_key = config.api_key or "ollama"
- async def _send_stream_request(self, body: dict) -> httpx.Response:
- """Create a streaming native Anthropic messages response."""
- request = self._client.build_request(
- "POST",
- "/v1/messages",
- json=body,
- headers=self._request_headers(),
+ def _build_request_body(
+ self, request: MessagesRequest, thinking_enabled: bool | None = None
+ ) -> dict:
+ return build_openai_chat_request_body(
+ request,
+ thinking_enabled=self._is_thinking_enabled(request, thinking_enabled),
+ policy=_REQUEST_POLICY,
)
- return await self._client.send(request, stream=True)
-
- async def _send_model_list_request(self) -> httpx.Response:
- """Query Ollama's native local model-list endpoint."""
- return await self._client.get(f"{self._base_url}/api/tags")
-
- def _extract_model_ids_from_model_list_payload(
- self, payload: object
- ) -> frozenset[str]:
- return extract_ollama_model_ids(payload, provider_name=self._provider_name)
diff --git a/src/free_claude_code/providers/runtime/discovery.py b/src/free_claude_code/providers/runtime/discovery.py
index d9f6c95f..d9bea0ee 100644
--- a/src/free_claude_code/providers/runtime/discovery.py
+++ b/src/free_claude_code/providers/runtime/discovery.py
@@ -28,7 +28,7 @@ def model_list_provider_ids_for_settings(settings: Settings) -> tuple[str, ...]:
referenced_ids = referenced_provider_ids(settings)
provider_ids: list[str] = []
for provider_id, descriptor in PROVIDER_CATALOG.items():
- if descriptor.capabilities.local:
+ if descriptor.local:
if provider_id in referenced_ids:
provider_ids.append(provider_id)
continue
diff --git a/src/free_claude_code/providers/transports/__init__.py b/src/free_claude_code/providers/transports/__init__.py
index a76e892a..fc485a45 100644
--- a/src/free_claude_code/providers/transports/__init__.py
+++ b/src/free_claude_code/providers/transports/__init__.py
@@ -1 +1 @@
-"""Provider transport families."""
+"""Shared provider transport."""
diff --git a/src/free_claude_code/providers/transports/anthropic_messages/__init__.py b/src/free_claude_code/providers/transports/anthropic_messages/__init__.py
deleted file mode 100644
index 90c9be18..00000000
--- a/src/free_claude_code/providers/transports/anthropic_messages/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""Native Anthropic Messages transport family."""
-
-from .request_policy import (
- NativeMessagesRequestPolicy,
- build_native_messages_request_body,
-)
-from .transport import AnthropicMessagesTransport
-
-__all__ = [
- "AnthropicMessagesTransport",
- "NativeMessagesRequestPolicy",
- "build_native_messages_request_body",
-]
diff --git a/src/free_claude_code/providers/transports/anthropic_messages/http.py b/src/free_claude_code/providers/transports/anthropic_messages/http.py
deleted file mode 100644
index 4df2ac0e..00000000
--- a/src/free_claude_code/providers/transports/anthropic_messages/http.py
+++ /dev/null
@@ -1,108 +0,0 @@
-"""HTTP helpers for native Anthropic Messages transports."""
-
-from typing import Any
-
-import httpx
-from loguru import logger
-
-from free_claude_code.config.constants import NATIVE_MESSAGES_ERROR_BODY_LOG_CAP_BYTES
-from free_claude_code.core.diagnostics import (
- ERROR_DETAIL_DISPLAY_CAP_BYTES,
- attach_upstream_error_body,
- redact_sensitive_error_text,
-)
-from free_claude_code.providers.model_listing import ModelListResponseError
-
-
-def model_list_json(response: httpx.Response, *, provider_name: str) -> Any:
- """Parse model-list JSON with a provider-specific malformed-body error."""
- response.raise_for_status()
- try:
- return response.json()
- except ValueError as exc:
- raise ModelListResponseError(
- f"{provider_name} model-list response is malformed: invalid JSON"
- ) from exc
-
-
-async def read_error_body_preview(
- response: httpx.Response, max_bytes: int
-) -> tuple[bytes, bool]:
- """Read at most ``max_bytes`` from an error response body."""
- if max_bytes <= 0:
- return b"", False
- received = 0
- parts: list[bytes] = []
- truncated = False
- async for chunk in response.aiter_bytes(chunk_size=65_536):
- if received >= max_bytes:
- truncated = True
- break
- remaining = max_bytes - received
- take = chunk if len(chunk) <= remaining else chunk[:remaining]
- if take:
- parts.append(take)
- received += len(take)
- if len(chunk) > len(take):
- truncated = True
- break
- if received >= max_bytes:
- break
- return (b"".join(parts), truncated)
-
-
-async def raise_for_status_with_body(
- response: httpx.Response,
- *,
- provider_name: str,
- req_tag: str,
- log_api_error_tracebacks: bool,
-) -> None:
- """Raise for non-200 responses after attaching a safe body preview."""
- try:
- response.raise_for_status()
- except httpx.HTTPStatusError as error:
- preview, truncated = await read_error_body_preview(
- response, ERROR_DETAIL_DISPLAY_CAP_BYTES
- )
- attach_upstream_error_body(error, preview, truncated=truncated)
- if log_api_error_tracebacks:
- log_preview = preview[:NATIVE_MESSAGES_ERROR_BODY_LOG_CAP_BYTES]
- log_truncated = truncated or len(preview) > len(log_preview)
- if log_preview:
- text = redact_sensitive_error_text(
- log_preview.decode("utf-8", errors="replace")
- )
- logger.error(
- "{}_ERROR:{} HTTP {} body_preview_bytes={} truncated={}: {}",
- provider_name,
- req_tag,
- response.status_code,
- len(log_preview),
- log_truncated,
- text,
- )
- else:
- logger.error(
- "{}_ERROR:{} HTTP {} (empty error body)",
- provider_name,
- req_tag,
- response.status_code,
- )
- else:
- cl = response.headers.get("content-length", "").strip()
- extra = f" content_length_declared={cl}" if cl.isdigit() else ""
- body_extra = (
- " empty_error_body"
- if not preview
- else f" error_body_bytes_read={len(preview)}"
- )
- logger.error(
- "{}_ERROR:{} HTTP {}{}{}",
- provider_name,
- req_tag,
- response.status_code,
- extra,
- body_extra,
- )
- raise error
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
deleted file mode 100644
index 1b3369a0..00000000
--- a/src/free_claude_code/providers/transports/anthropic_messages/request_policy.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""Request-body policy for native Anthropic-compatible providers."""
-
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
-from typing import Any, Literal
-
-from loguru import logger
-
-from free_claude_code.application.errors import InvalidRequestError
-from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.native_messages_request import (
- build_base_native_anthropic_request_body,
-)
-
-NativeExtraBodyPolicy = Literal["drop", "reject"]
-NativeMessagesPostprocessor = Callable[[dict[str, Any], MessagesRequest, bool], None]
-
-
-@dataclass(frozen=True, slots=True)
-class NativeMessagesRequestPolicy:
- """Provider policy for native Anthropic Messages request construction."""
-
- provider_name: str
- extra_body: NativeExtraBodyPolicy = "drop"
- default_max_tokens: int = ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
- force_stream: bool = True
- reject_extra_body_message: str | None = None
-
-
-def build_native_messages_request_body(
- request_data: MessagesRequest,
- *,
- thinking_enabled: bool,
- policy: NativeMessagesRequestPolicy,
- postprocessors: Iterable[NativeMessagesPostprocessor] = (),
-) -> dict[str, Any]:
- """Build a native Anthropic-compatible Messages request body."""
- logger.debug(
- "{}_REQUEST: native build model={} msgs={}",
- policy.provider_name,
- request_data.model,
- len(request_data.messages),
- )
-
- body = build_base_native_anthropic_request_body(
- request_data,
- default_max_tokens=policy.default_max_tokens,
- thinking_enabled=thinking_enabled,
- )
- _apply_extra_body_policy(body, request_data, policy)
- if policy.force_stream:
- body["stream"] = True
-
- for postprocess in postprocessors:
- postprocess(body, request_data, thinking_enabled)
-
- logger.debug(
- "{}_REQUEST: build done model={} msgs={} tools={}",
- policy.provider_name,
- body.get("model"),
- len(body.get("messages", [])),
- len(body.get("tools", [])),
- )
- return body
-
-
-def _apply_extra_body_policy(
- body: dict[str, Any],
- request_data: MessagesRequest,
- policy: NativeMessagesRequestPolicy,
-) -> None:
- extra = request_data.extra_body
- if not extra:
- return
-
- if policy.extra_body == "drop":
- return
- if policy.extra_body == "reject":
- message = (
- policy.reject_extra_body_message
- or f"{policy.provider_name} native Messages API does not support extra_body on requests."
- )
- raise InvalidRequestError(message)
- raise AssertionError(f"Unhandled native extra_body policy: {policy.extra_body}")
diff --git a/src/free_claude_code/providers/transports/anthropic_messages/transport.py b/src/free_claude_code/providers/transports/anthropic_messages/transport.py
deleted file mode 100644
index ce8c81a8..00000000
--- a/src/free_claude_code/providers/transports/anthropic_messages/transport.py
+++ /dev/null
@@ -1,696 +0,0 @@
-"""Shared transport for providers with native Anthropic Messages endpoints."""
-
-import sys
-from collections.abc import AsyncIterator
-from typing import Any
-
-import httpx
-
-from free_claude_code.application.model_metadata import ProviderModelInfo
-from free_claude_code.core.anthropic import execution_failure_from_anthropic_error
-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,
-)
-from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
-from free_claude_code.core.anthropic.streaming import (
- AnthropicStreamLedger,
- accept_tool_json_repair,
- continuation_suffix,
- make_text_recovery_body,
- make_tool_repair_body,
- parse_complete_tool_input,
- tool_schemas_by_name,
-)
-from free_claude_code.core.trace import (
- close_stream_input,
- provider_native_messages_body_snapshot,
- trace_event,
-)
-from free_claude_code.providers.base import BaseProvider, ProviderConfig
-from free_claude_code.providers.failure_policy import classify_provider_failure
-from free_claude_code.providers.model_listing import (
- extract_openai_model_ids,
- model_infos_from_ids,
-)
-from free_claude_code.providers.rate_limit import ProviderRateLimiter
-from free_claude_code.providers.stream_recovery import (
- MIDSTREAM_RECOVERY_ATTEMPTS,
- RecoveryController,
- RecoveryFailureAction,
- TruncatedProviderStreamError,
- is_retryable_stream_error,
-)
-from free_claude_code.providers.transports.http import (
- close_provider_stream,
- maybe_await_aclose,
-)
-
-from .http import model_list_json, raise_for_status_with_body
-from .request_policy import (
- NativeMessagesRequestPolicy,
- build_native_messages_request_body,
-)
-
-
-class AnthropicMessagesTransport(BaseProvider):
- """Base class for providers that stream from an Anthropic-compatible endpoint."""
-
- def __init__(
- self,
- config: ProviderConfig,
- *,
- provider_name: str,
- default_base_url: str,
- rate_limiter: ProviderRateLimiter,
- ):
- super().__init__(config)
- self._provider_name = provider_name
- self._api_key = config.api_key
- self._base_url = (config.base_url or default_base_url).rstrip("/")
- self._request_policy = NativeMessagesRequestPolicy(provider_name=provider_name)
- self._rate_limiter = rate_limiter
- self._client = httpx.AsyncClient(
- base_url=self._base_url,
- proxy=config.proxy or None,
- timeout=httpx.Timeout(
- config.http_read_timeout,
- connect=config.http_connect_timeout,
- read=config.http_read_timeout,
- write=config.http_write_timeout,
- ),
- )
-
- async def cleanup(self) -> None:
- """Release HTTP client resources."""
- await self._client.aclose()
-
- async def list_model_ids(self) -> frozenset[str]:
- """Return model ids from an OpenAI-compatible ``/models`` endpoint."""
- return frozenset(info.model_id for info in await self.list_model_infos())
-
- async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
- """Return model ids plus optional metadata from a ``/models`` endpoint."""
- response = await self._send_model_list_request()
- try:
- payload = model_list_json(response, provider_name=self._provider_name)
- return self._extract_model_infos_from_model_list_payload(payload)
- finally:
- await maybe_await_aclose(response)
-
- async def _send_model_list_request(self) -> httpx.Response:
- """Query the provider endpoint that advertises available model ids."""
- return await self._client.get(
- "/models",
- headers=self._model_list_headers(),
- )
-
- def _model_list_headers(self) -> dict[str, str]:
- """Return headers for model-list requests."""
- return {}
-
- def _extract_model_ids_from_model_list_payload(
- self, payload: Any
- ) -> frozenset[str]:
- """Parse the provider model-list response body."""
- return extract_openai_model_ids(payload, provider_name=self._provider_name)
-
- def _extract_model_infos_from_model_list_payload(
- self, payload: Any
- ) -> frozenset[ProviderModelInfo]:
- """Parse provider model metadata; default to unknown capabilities."""
- return model_infos_from_ids(
- self._extract_model_ids_from_model_list_payload(payload)
- )
-
- def _request_headers(self) -> dict[str, str]:
- """Return headers for the native messages request."""
- return {"Content-Type": "application/json"}
-
- def _build_request_body(
- self, request: MessagesRequest, thinking_enabled: bool | None = None
- ) -> dict:
- """Build a native Anthropic request body."""
- thinking_enabled = self._is_thinking_enabled(request, thinking_enabled)
- return self._build_request_body_with_resolved_thinking(
- request,
- thinking_enabled=thinking_enabled,
- )
-
- def preflight_stream(
- self, request: MessagesRequest, *, thinking_enabled: bool | None = None
- ) -> None:
- """Validate native Messages request construction before streaming."""
- self._build_request_body(request, thinking_enabled=thinking_enabled)
-
- def _build_request_body_with_resolved_thinking(
- self, request: MessagesRequest, *, thinking_enabled: bool
- ) -> dict:
- """Build a native Anthropic request body after thinking is resolved."""
- return build_native_messages_request_body(
- request,
- thinking_enabled=thinking_enabled,
- policy=self._request_policy,
- )
-
- async def _send_stream_request(self, body: dict) -> httpx.Response:
- """Create a streaming messages response."""
- # This transport always parses the upstream response as SSE, so the
- # upstream request must always be streaming — forwarding a client's
- # stream=false makes native providers return plain JSON that the SSE
- # reader misreads as a truncated stream.
- request = self._client.build_request(
- "POST",
- "/messages",
- json={**body, "stream": True},
- headers=self._request_headers(),
- )
- return await self._client.send(request, stream=True)
-
- async def _raise_for_status(
- self, response: httpx.Response, *, req_tag: str
- ) -> None:
- """Raise for non-200 responses after attaching safe error metadata."""
- await raise_for_status_with_body(
- response,
- provider_name=self._provider_name,
- req_tag=req_tag,
- log_api_error_tracebacks=self._config.log_api_error_tracebacks,
- )
-
- async def _validated_stream_send(
- self,
- body: dict,
- *,
- req_tag: str,
- request_id: str | None = None,
- ) -> httpx.Response:
- """Send request and raise mapped HTTP errors before yielding body chunks."""
- send_response = await self._send_stream_request(body)
- if send_response.status_code != 200:
- try:
- await self._raise_for_status(send_response, req_tag=req_tag)
- finally:
- if not send_response.is_closed:
- await close_provider_stream(
- send_response,
- active_error=sys.exception(),
- provider_name=self._provider_name,
- request_id=request_id,
- )
- return send_response
-
- def stream_response(
- self,
- request: MessagesRequest,
- input_tokens: int = 0,
- *,
- request_id: str | None = None,
- thinking_enabled: bool | None = None,
- ) -> AsyncIterator[str]:
- """Stream response via a native Anthropic-compatible messages endpoint."""
- runner = _AnthropicMessagesStreamRunner(
- self,
- request=request,
- input_tokens=input_tokens,
- request_id=request_id,
- thinking_enabled=thinking_enabled,
- )
- return runner.run()
-
-
-async def _iter_sse_events(response: httpx.Response) -> AsyncIterator[str]:
- """Group line-delimited upstream data into complete SSE events."""
- event_lines: list[str] = []
- lines = response.aiter_lines()
- try:
- async for line in lines:
- if line:
- event_lines.append(line)
- continue
- if event_lines:
- yield "\n".join(event_lines) + "\n\n"
- event_lines.clear()
- if event_lines:
- yield "\n".join(event_lines) + "\n\n"
- finally:
- await close_stream_input(
- lines,
- owner="anthropic_messages.sse_lines",
- source="provider",
- preserved_error=sys.exception(),
- )
-
-
-class _AnthropicMessagesStreamRunner:
- """Own one native Anthropic Messages request and all of its recovery work."""
-
- def __init__(
- self,
- transport: AnthropicMessagesTransport,
- *,
- request: MessagesRequest,
- input_tokens: int,
- request_id: str | None,
- thinking_enabled: bool | None,
- ) -> None:
- self._transport = transport
- self._request = request
- self._input_tokens = input_tokens
- self._request_id = request_id
- self._thinking_enabled = thinking_enabled
-
- async def run(self) -> AsyncIterator[str]:
- """Stream and recover one native Anthropic-compatible request."""
- tag = self._transport._provider_name
- req_tag = f" request_id={self._request_id}" if self._request_id else ""
- body = self._transport._build_request_body(
- self._request, thinking_enabled=self._thinking_enabled
- )
- thinking_enabled = self._transport._is_thinking_enabled(
- self._request, self._thinking_enabled
- )
-
- trace_event(
- stage="provider",
- event="provider.request.sent",
- source="provider",
- provider=tag,
- request_id=self._request_id,
- gateway_model=self._request.model,
- downstream_model=body.get("model"),
- message_count=len(body.get("messages", [])),
- tool_count=len(body.get("tools", [])),
- body=provider_native_messages_body_snapshot(body),
- )
-
- response: httpx.Response | None = None
- sent_any_event = False
- state = NativeSseBlockPolicyState()
- ledger = self._new_ledger()
- recovery = RecoveryController(provider_name=tag, request_id=self._request_id)
-
- async with self._transport._rate_limiter.concurrency_slot():
- while True:
- stream_opened = False
- chunks: AsyncIterator[str] | None = None
- try:
- response = await self._transport._rate_limiter.execute_with_retry(
- self._transport._validated_stream_send,
- body,
- req_tag=req_tag,
- request_id=self._request_id,
- )
- stream_opened = True
- chunk_count = 0
- chunk_bytes = 0
-
- chunks = self._iter_stream_chunks(
- response,
- state=state,
- thinking_enabled=thinking_enabled,
- )
- async for chunk in chunks:
- chunk_count += 1
- chunk_bytes += len(chunk.encode("utf-8", errors="replace"))
- for parsed in parse_sse_text(chunk):
- if parsed.event == "error":
- raise execution_failure_from_anthropic_error(
- parsed.data
- )
- emitted = ledger.ingest_native_event(parsed)
- if emitted is None:
- continue
- for event in recovery.push(emitted):
- sent_any_event = True
- yield event
-
- if not ledger.has_terminal_message():
- raise TruncatedProviderStreamError(
- "Provider stream ended without message_stop."
- )
-
- trace_event(
- stage="provider",
- event="provider.response.completed",
- source="provider",
- provider=tag,
- request_id=self._request_id,
- gateway_model=self._request.model,
- sse_chunks_out=chunk_count,
- sse_bytes_out=chunk_bytes,
- )
- for event in recovery.flush():
- sent_any_event = True
- yield event
- return
-
- except Exception as error:
- if ledger.has_terminal_message():
- trace_event(
- stage="provider",
- event="provider.response.completed",
- source="provider",
- provider=tag,
- request_id=self._request_id,
- gateway_model=self._request.model,
- sse_chunks_out=chunk_count,
- sse_bytes_out=chunk_bytes,
- late_exc_type=type(error).__name__,
- )
- for event in recovery.flush():
- sent_any_event = True
- yield event
- return
-
- generated_output = ledger.has_content_block()
- complete_tool_salvageable = generated_output and (
- ledger.can_salvage_tool_use(tool_schemas_by_name(self._request))
- )
- decision = recovery.advance_failure(
- error,
- stream_opened=stream_opened,
- generated_output=generated_output,
- complete_tool_salvageable=complete_tool_salvageable,
- )
- if decision.action == RecoveryFailureAction.EARLY_RETRY:
- if response is not None and not response.is_closed:
- await close_provider_stream(
- response,
- active_error=error,
- provider_name=tag,
- request_id=self._request_id,
- )
- response = None
- state = NativeSseBlockPolicyState()
- ledger = self._new_ledger()
- sent_any_event = False
- continue
-
- if decision.action == RecoveryFailureAction.MIDSTREAM_RECOVERY:
- try:
- recovery_events = await self._recovery_events(
- body=body,
- ledger=ledger,
- error=error,
- req_tag=req_tag,
- thinking_enabled=thinking_enabled,
- )
- except Exception as recovery_error:
- trace_event(
- stage="provider",
- event="provider.recovery.failed",
- source="provider",
- provider=tag,
- request_id=self._request_id,
- exc_type=type(recovery_error).__name__,
- )
- recovery_events = None
- if recovery_events is not None:
- for event in recovery.flush_uncommitted(decision):
- sent_any_event = True
- yield event
- for event in recovery_events:
- yield event
- return
-
- if not isinstance(error, httpx.HTTPStatusError):
- self._transport._log_stream_transport_error(
- tag, req_tag, error, request_id=self._request_id
- )
- failure = classify_provider_failure(
- error,
- provider_name=tag,
- read_timeout_s=self._transport._config.http_read_timeout,
- request_id=self._request_id,
- mark_rate_limited=(
- self._transport._rate_limiter.extend_reactive_block
- ),
- )
-
- error_trace: dict[str, Any] = {
- "stage": "provider",
- "event": "provider.response.error",
- "source": "provider",
- "provider": tag,
- "request_id": self._request_id,
- "exc_type": type(error).__name__,
- "failure_kind": failure.kind.value,
- "status_code": failure.status_code,
- "provider_retryable": failure.retryable,
- "mid_stream": sent_any_event or decision.committed,
- }
- if self._transport._config.log_api_error_tracebacks:
- error_trace["error_message"] = failure.message
- trace_event(**error_trace)
- if decision.committed:
- for event in ledger.close_unclosed_blocks():
- yield event
- elif decision.has_buffered and complete_tool_salvageable:
- for event in recovery.flush():
- sent_any_event = True
- yield event
- for event in ledger.close_unclosed_blocks():
- yield event
- else:
- recovery.discard()
- raise failure from error
- finally:
- if chunks is not None:
- await close_stream_input(
- chunks,
- owner="anthropic_messages.runner",
- source="provider",
- preserved_error=sys.exception(),
- )
- if response is not None and not response.is_closed:
- await close_provider_stream(
- response,
- active_error=sys.exception(),
- provider_name=tag,
- request_id=self._request_id,
- )
-
- async def _iter_stream_chunks(
- self,
- response: httpx.Response,
- *,
- state: NativeSseBlockPolicyState,
- thinking_enabled: bool,
- ) -> AsyncIterator[str]:
- """Yield normalized grouped SSE events from the provider stream."""
- events = _iter_sse_events(response)
- try:
- async for event in events:
- output_event = transform_native_sse_block_event(
- event,
- state,
- thinking_enabled=thinking_enabled,
- )
- if output_event is not None:
- yield output_event
- finally:
- await close_stream_input(
- events,
- owner="anthropic_messages.block_policy",
- source="provider",
- preserved_error=sys.exception(),
- )
-
- def _new_ledger(self) -> AnthropicStreamLedger:
- return AnthropicStreamLedger(
- None,
- self._request.model,
- self._input_tokens,
- log_raw_events=self._transport._config.log_raw_sse_events,
- )
-
- async def _collect_recovery_text(
- self,
- body: dict[str, Any],
- *,
- req_tag: str,
- thinking_enabled: bool,
- ) -> tuple[str, str]:
- """Collect text and thinking from an internal continuation request."""
- last_error: Exception | None = None
- for attempt in range(MIDSTREAM_RECOVERY_ATTEMPTS):
- response: httpx.Response | None = None
- try:
- response = await self._transport._rate_limiter.execute_with_retry(
- self._transport._validated_stream_send,
- body,
- req_tag=req_tag,
- request_id=self._request_id,
- )
- state = NativeSseBlockPolicyState()
- chunks = [
- chunk
- async for chunk in self._iter_stream_chunks(
- response,
- state=state,
- thinking_enabled=thinking_enabled,
- )
- ]
- text_parts: list[str] = []
- thinking_parts: list[str] = []
- terminal_seen = False
- for event in parse_sse_text("".join(chunks)):
- if event.event == "message_stop":
- terminal_seen = True
- content_block = event.data.get("content_block")
- if isinstance(content_block, dict):
- text = content_block.get("text")
- if isinstance(text, str):
- text_parts.append(text)
- thinking = content_block.get("thinking")
- if isinstance(thinking, str):
- thinking_parts.append(thinking)
- delta = event.data.get("delta")
- if not isinstance(delta, dict):
- continue
- text = delta.get("text")
- if isinstance(text, str):
- text_parts.append(text)
- thinking = delta.get("thinking")
- if isinstance(thinking, str):
- thinking_parts.append(thinking)
- if not terminal_seen:
- raise TruncatedProviderStreamError(
- "Recovery stream ended without message_stop."
- )
- return "".join(text_parts), "".join(thinking_parts)
- except Exception as error:
- last_error = error
- if not is_retryable_stream_error(error):
- raise
- trace_event(
- stage="provider",
- event="provider.recovery.retry",
- source="provider",
- provider=self._transport._provider_name,
- recovery_kind="native_text",
- attempt=attempt + 1,
- max_attempts=MIDSTREAM_RECOVERY_ATTEMPTS,
- exc_type=type(error).__name__,
- )
- finally:
- if response is not None and not response.is_closed:
- await maybe_await_aclose(response)
- if last_error is not None:
- raise last_error
- return "", ""
-
- async def _recovery_events(
- self,
- *,
- body: dict[str, Any],
- ledger: AnthropicStreamLedger,
- error: Exception,
- req_tag: str,
- thinking_enabled: bool,
- ) -> list[str] | None:
- """Build recovery events, or return None when recovery is impossible."""
- if not is_retryable_stream_error(error):
- return None
-
- schemas = tool_schemas_by_name(self._request)
- if ledger.tool_blocks():
- repair_events: list[str] = []
- for index, block in enumerate(ledger.tool_blocks()):
- if (
- block.tool_id
- and block.name
- and parse_complete_tool_input(
- block.content,
- block.name,
- schemas,
- )
- is not None
- ):
- continue
- schema = schemas.get(block.name)
- recovery_body = make_tool_repair_body(
- body,
- tool_name=block.name,
- prefix=block.content,
- input_schema=(schema.input_schema if schema is not None else None),
- )
- accepted_suffix: str | None = None
- for attempt in range(MIDSTREAM_RECOVERY_ATTEMPTS):
- text, _ = await self._collect_recovery_text(
- recovery_body,
- req_tag=req_tag,
- thinking_enabled=thinking_enabled,
- )
- repair = accept_tool_json_repair(
- block.content,
- text,
- tool_name=block.name,
- schemas=schemas,
- )
- if repair is not None:
- accepted_suffix = repair.suffix
- trace_event(
- stage="provider",
- event="provider.recovery.tool_repaired",
- source="provider",
- provider=self._transport._provider_name,
- tool_name=block.name,
- attempt=attempt + 1,
- )
- break
- if accepted_suffix is None:
- return None
- repair_events.extend(
- ledger.append_tool_repair_suffix(index, accepted_suffix)
- )
-
- if not ledger.can_salvage_tool_use(schemas):
- return None
- events = list(repair_events)
- events.extend(ledger.success_tail("end_turn"))
- trace_event(
- stage="provider",
- event="provider.recovery.tool_salvaged",
- source="provider",
- provider=self._transport._provider_name,
- request_id=self._request_id,
- )
- return events
-
- partial_text = ledger.accumulated_text
- partial_thinking = ledger.accumulated_reasoning
- if not partial_text and not partial_thinking:
- return None
- if not ledger.can_append_content():
- return None
- recovery_body = make_text_recovery_body(
- body,
- partial_text,
- partial_thinking,
- )
- text, thinking = await self._collect_recovery_text(
- recovery_body,
- req_tag=req_tag,
- thinking_enabled=thinking_enabled,
- )
- text_suffix = continuation_suffix(partial_text, text)
- thinking_suffix = continuation_suffix(partial_thinking, thinking)
- events: list[str] = []
- if thinking_suffix:
- events.extend(ledger.append_thinking_suffix(thinking_suffix))
- if text_suffix:
- events.extend(ledger.append_text_suffix(text_suffix))
- if not events:
- return None
- events.extend(ledger.success_tail("end_turn"))
- trace_event(
- stage="provider",
- event="provider.recovery.continued",
- source="provider",
- provider=self._transport._provider_name,
- request_id=self._request_id,
- )
- return events
diff --git a/src/free_claude_code/providers/transports/openai_chat/__init__.py b/src/free_claude_code/providers/transports/openai_chat/__init__.py
index 8e5891bb..c822cbaa 100644
--- a/src/free_claude_code/providers/transports/openai_chat/__init__.py
+++ b/src/free_claude_code/providers/transports/openai_chat/__init__.py
@@ -1,5 +1,6 @@
"""OpenAI-compatible chat transport family."""
+from .base_url import openai_v1_base_url
from .request_policy import OpenAIChatRequestPolicy, build_openai_chat_request_body
from .transport import OpenAIChatTransport
@@ -7,4 +8,5 @@ __all__ = [
"OpenAIChatRequestPolicy",
"OpenAIChatTransport",
"build_openai_chat_request_body",
+ "openai_v1_base_url",
]
diff --git a/src/free_claude_code/providers/transports/openai_chat/base_url.py b/src/free_claude_code/providers/transports/openai_chat/base_url.py
new file mode 100644
index 00000000..4cda6e83
--- /dev/null
+++ b/src/free_claude_code/providers/transports/openai_chat/base_url.py
@@ -0,0 +1,7 @@
+"""OpenAI-compatible API base URL policy."""
+
+
+def openai_v1_base_url(base_url: str) -> str:
+ """Return the canonical ``/v1`` API base for a server root or API base."""
+ normalized = base_url.rstrip("/")
+ return normalized if normalized.endswith("/v1") else f"{normalized}/v1"
diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.py
index 46d22eab..d6604400 100644
--- a/tests/api/test_web_server_tools.py
+++ b/tests/api/test_web_server_tools.py
@@ -27,10 +27,7 @@ from free_claude_code.application.routing import (
ResolvedModel,
RoutedMessagesRequest,
)
-from free_claude_code.config.provider_catalog import (
- PROVIDER_CATALOG,
- ProviderCapabilities,
-)
+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 (
@@ -45,16 +42,7 @@ _STRICT_EGRESS = WebFetchEgressPolicy(
allow_private_network_targets=False,
allowed_schemes=frozenset({"http", "https"}),
)
-_NO_SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS = tuple(
- provider_id
- for provider_id, descriptor in PROVIDER_CATALOG.items()
- if not descriptor.capabilities.server_tool_passthrough
-)
-_SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS = tuple(
- provider_id
- for provider_id, descriptor in PROVIDER_CATALOG.items()
- if descriptor.capabilities.server_tool_passthrough
-)
+_PROVIDER_IDS = tuple(PROVIDER_CATALOG)
def test_web_tool_user_agent_reports_installed_package_version() -> None:
@@ -64,22 +52,11 @@ def test_web_tool_user_agent_reports_installed_package_version() -> None:
class FixedProviderModelRouter(ModelRouter):
- """Test double: pin provider identity and semantic capabilities."""
-
- def __init__(
- self,
- settings: Settings,
- provider_id: str,
- *,
- capabilities: ProviderCapabilities | None = None,
- ) -> None:
+ """Test double that pins provider identity."""
+
+ def __init__(self, settings: Settings, provider_id: str) -> None:
super().__init__(settings)
self._fixed_provider_id = provider_id
- self._fixed_capabilities = (
- PROVIDER_CATALOG[provider_id].capabilities
- if capabilities is None
- else capabilities
- )
def resolve_messages_request(
self, request: MessagesRequest
@@ -90,7 +67,6 @@ class FixedProviderModelRouter(ModelRouter):
provider_model=request.model,
provider_model_ref=f"{self._fixed_provider_id}/{request.model}",
thinking_enabled=False,
- capabilities=self._fixed_capabilities,
)
routed = request.model_copy(deep=True)
routed.model = resolved.provider_model
@@ -134,11 +110,11 @@ def test_web_server_tool_not_detected_when_forced_name_missing_from_tools():
@pytest.mark.asyncio
[email protected]("provider_id", _NO_SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS)
-async def test_service_rejects_forced_server_tool_without_passthrough_when_disabled(
[email protected]("provider_id", _PROVIDER_IDS)
+async def test_service_rejects_forced_server_tool_when_local_handler_is_disabled(
provider_id: str,
):
- """Non-passthrough providers need the local handler for forced server tools."""
+ """Every provider needs FCC's local handler for forced server tools."""
settings = Settings()
assert settings.enable_web_server_tools is False
service = MessagesHandler(
@@ -443,9 +419,7 @@ async def test_service_streams_forced_web_search_by_default(monkeypatch):
service = MessagesHandler(
settings,
provider_resolver=provider_resolver,
- model_router=FixedProviderModelRouter(
- settings, _NO_SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS[0]
- ),
+ model_router=FixedProviderModelRouter(settings, _PROVIDER_IDS[0]),
)
request = MessagesRequest(
model="claude-haiku-4-5-20251001",
@@ -478,9 +452,7 @@ async def test_service_aggregates_forced_web_search_when_stream_false(monkeypatc
service = MessagesHandler(
settings,
provider_resolver=provider_resolver,
- model_router=FixedProviderModelRouter(
- settings, _NO_SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS[0]
- ),
+ model_router=FixedProviderModelRouter(settings, _PROVIDER_IDS[0]),
)
request = MessagesRequest(
model="claude-haiku-4-5-20251001",
@@ -571,9 +543,7 @@ async def test_service_aggregates_forced_web_fetch_when_stream_false(monkeypatch
service = MessagesHandler(
settings,
provider_resolver=provider_resolver,
- model_router=FixedProviderModelRouter(
- settings, _NO_SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS[0]
- ),
+ model_router=FixedProviderModelRouter(settings, _PROVIDER_IDS[0]),
)
request = MessagesRequest(
model="claude-haiku-4-5-20251001",
@@ -780,8 +750,8 @@ async def test_drain_response_body_capped_stops_after_first_chunk_when_oversized
@pytest.mark.asyncio
[email protected]("provider_id", _NO_SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS)
-async def test_service_rejects_listed_server_tools_without_passthrough(
[email protected]("provider_id", _PROVIDER_IDS)
+async def test_service_rejects_listed_server_tools_for_every_provider(
provider_id: str,
) -> None:
settings = Settings()
@@ -796,128 +766,5 @@ async def test_service_rejects_listed_server_tools_without_passthrough(
messages=[Message(role="user", content="q")],
tools=[Tool(name="web_search", type="web_search_20250305")],
)
- with pytest.raises(InvalidRequestError, match="OpenAI Chat upstreams"):
+ with pytest.raises(InvalidRequestError, match="cannot pass listed Anthropic"):
await service.create(request)
-
-
[email protected]("provider_id", _SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS)
-async def test_listed_server_tools_routed_on_passthrough_providers(
- provider_id: str,
-) -> None:
- """Passthrough providers may receive listed server tool definitions."""
- settings = Settings()
-
- async def fake_stream(*_a, **_k):
- yield 'event: message_start\ndata: {"type":"message_start"}\n\n'
- yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'
-
- mock_provider = MagicMock()
- mock_provider.stream_response = fake_stream
- service = MessagesHandler(
- settings,
- provider_resolver=lambda _: mock_provider,
- model_router=FixedProviderModelRouter(settings, provider_id),
- )
- request = MessagesRequest(
- model="m",
- max_tokens=20,
- messages=[Message(role="user", content="q")],
- tools=[Tool(name="web_search", type="web_search_20250305")],
- )
- await service.create(request)
- mock_provider.preflight_stream.assert_called()
-
-
[email protected]("provider_id", _SERVER_TOOL_PASSTHROUGH_PROVIDER_IDS)
-async def test_forced_server_tools_routed_on_passthrough_providers_when_local_disabled(
- provider_id: str,
-) -> None:
- """Passthrough providers may receive forced server tools when local tools are off."""
- settings = Settings()
-
- async def fake_stream(*_a, **_k):
- yield 'event: message_start\ndata: {"type":"message_start"}\n\n'
- yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'
-
- mock_provider = MagicMock()
- mock_provider.stream_response = fake_stream
- service = MessagesHandler(
- settings,
- provider_resolver=lambda _: mock_provider,
- model_router=FixedProviderModelRouter(settings, provider_id),
- )
- request = MessagesRequest(
- model="m",
- max_tokens=20,
- messages=[Message(role="user", content="q")],
- tools=[Tool(name="web_search", type="web_search_20250305")],
- tool_choice={"type": "tool", "name": "web_search"},
- )
- await service.create(request)
- mock_provider.preflight_stream.assert_called()
-
-
-async def test_server_tool_policy_accepts_capability_not_identity() -> None:
- provider_id = "nvidia_nim"
- assert not PROVIDER_CATALOG[provider_id].capabilities.server_tool_passthrough
-
- async def fake_stream(*_a, **_k):
- yield 'event: message_start\ndata: {"type":"message_start"}\n\n'
- yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'
-
- mock_provider = MagicMock()
- mock_provider.stream_response = fake_stream
- provider_resolver = MagicMock(return_value=mock_provider)
- settings = Settings()
- service = MessagesHandler(
- settings,
- provider_resolver=provider_resolver,
- model_router=FixedProviderModelRouter(
- settings,
- provider_id,
- capabilities=ProviderCapabilities(server_tool_passthrough=True),
- ),
- )
- request = MessagesRequest(
- model="m",
- max_tokens=20,
- messages=[Message(role="user", content="q")],
- tools=[Tool(name="web_search", type="web_search_20250305")],
- )
-
- await service.create(request)
-
- provider_resolver.assert_called_once_with(provider_id)
- mock_provider.preflight_stream.assert_called_once()
-
-
-async def test_server_tool_policy_rejects_capability_not_identity() -> None:
- provider_id = "ollama"
- assert PROVIDER_CATALOG[provider_id].capabilities.server_tool_passthrough
-
- provider_resolver = MagicMock()
- settings = Settings()
- service = MessagesHandler(
- settings,
- provider_resolver=provider_resolver,
- model_router=FixedProviderModelRouter(
- settings,
- provider_id,
- capabilities=ProviderCapabilities(server_tool_passthrough=False),
- ),
- )
- request = MessagesRequest(
- model="m",
- max_tokens=20,
- messages=[Message(role="user", content="q")],
- tools=[Tool(name="web_search", type="web_search_20250305")],
- )
-
- with pytest.raises(InvalidRequestError, match="OpenAI Chat upstreams"):
- await service.create(request)
-
- provider_resolver.assert_not_called()
diff --git a/tests/application/test_execution.py b/tests/application/test_execution.py
index aa77e5d4..7e879277 100644
--- a/tests/application/test_execution.py
+++ b/tests/application/test_execution.py
@@ -7,7 +7,6 @@ import pytest
from free_claude_code.application.execution import ProviderExecutor
from free_claude_code.application.routing import ResolvedModel, RoutedMessagesRequest
-from free_claude_code.config.provider_catalog import ProviderCapabilities
from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.core.async_iterators import AsyncCloseable
@@ -83,7 +82,6 @@ def _routed_request() -> RoutedMessagesRequest:
provider_model="provider-model",
provider_model_ref="provider/provider-model",
thinking_enabled=True,
- capabilities=ProviderCapabilities(),
),
)
diff --git a/tests/application/test_routing.py b/tests/application/test_routing.py
index b961e36b..a3435252 100644
--- a/tests/application/test_routing.py
+++ b/tests/application/test_routing.py
@@ -3,7 +3,7 @@ from unittest.mock import patch
import pytest
from free_claude_code.application.errors import UnknownProviderError
-from free_claude_code.application.routing import ModelRouter, ResolvedModel
+from free_claude_code.application.routing import ModelRouter
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 (
@@ -27,10 +27,6 @@ def settings():
return settings
-def assert_exact_catalog_capabilities(resolved: ResolvedModel) -> None:
- assert resolved.capabilities is PROVIDER_CATALOG[resolved.provider_id].capabilities
-
-
def test_model_router_resolves_default_model(settings):
resolved = ModelRouter(settings).resolve("claude-3-opus")
@@ -39,7 +35,6 @@ def test_model_router_resolves_default_model(settings):
assert resolved.provider_model == "fallback-model"
assert resolved.provider_model_ref == "nvidia_nim/fallback-model"
assert resolved.thinking_enabled is True
- assert_exact_catalog_capabilities(resolved)
def test_model_router_applies_opus_override(settings):
@@ -85,7 +80,6 @@ def test_model_router_applies_haiku_override(settings):
assert routed.request.model == "qwen2.5-7b"
assert routed.resolved.provider_model_ref == "lmstudio/qwen2.5-7b"
- assert_exact_catalog_capabilities(routed.resolved)
def test_model_router_applies_sonnet_override(settings):
@@ -119,7 +113,6 @@ def test_model_router_routes_prefixed_provider_model_directly(settings):
assert routed.resolved.provider_id == "deepseek"
assert routed.resolved.provider_model == "deepseek-chat"
assert routed.resolved.provider_model_ref == "deepseek/deepseek-chat"
- assert_exact_catalog_capabilities(routed.resolved)
def test_model_router_routes_wafer_provider_model_directly(settings):
@@ -172,7 +165,6 @@ def test_model_router_routes_gateway_encoded_provider_model_directly(settings):
routed.resolved.provider_model_ref
== "anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"
)
- assert_exact_catalog_capabilities(routed.resolved)
def test_model_router_routes_no_thinking_gateway_model_directly(settings):
@@ -194,7 +186,6 @@ def test_model_router_routes_no_thinking_gateway_model_directly(settings):
assert routed.resolved.provider_id == "nvidia_nim"
assert routed.resolved.provider_model == "deepseek-ai/deepseek-v4-pro"
assert routed.resolved.thinking_enabled is False
- assert_exact_catalog_capabilities(routed.resolved)
def test_model_router_direct_prefixed_model_uses_provider_model_for_thinking(settings):
@@ -206,7 +197,6 @@ def test_model_router_direct_prefixed_model_uses_provider_model_for_thinking(set
assert resolved.provider_id == "open_router"
assert resolved.provider_model == "anthropic/claude-opus-4"
assert resolved.thinking_enabled is True
- assert_exact_catalog_capabilities(resolved)
def test_model_router_routes_token_count_request(settings):
@@ -220,7 +210,6 @@ def test_model_router_routes_token_count_request(settings):
assert routed.request.model == "qwen2.5-7b"
assert request.model == "claude-3-haiku-20240307"
- assert_exact_catalog_capabilities(routed.resolved)
def test_model_router_logs_mapping(settings):
diff --git a/tests/config/test_config.py b/tests/config/test_config.py
index 26bc97c9..2ee266f4 100644
--- a/tests/config/test_config.py
+++ b/tests/config/test_config.py
@@ -203,7 +203,7 @@ class TestSettings:
assert settings.lm_studio_base_url == "http://custom:5678/v1"
def test_ollama_base_url_defaults_to_root(self, monkeypatch):
- """OLLAMA_BASE_URL defaults to the Anthropic-compatible Ollama root URL."""
+ """OLLAMA_BASE_URL keeps the customer-facing Ollama root default."""
from free_claude_code.config.settings import Settings
monkeypatch.delenv("OLLAMA_BASE_URL", raising=False)
@@ -211,13 +211,12 @@ class TestSettings:
settings = Settings()
assert settings.ollama_base_url == "http://localhost:11434"
- def test_ollama_base_url_rejects_v1_suffix(self, monkeypatch):
- """OLLAMA_BASE_URL must not include /v1 for native Anthropic messages."""
+ def test_ollama_base_url_accepts_v1_suffix(self, monkeypatch):
+ """The adapter accepts either the root URL or the explicit OpenAI path."""
from free_claude_code.config.settings import Settings
monkeypatch.setenv("OLLAMA_BASE_URL", "http://localhost:11434/v1")
- with pytest.raises(ValidationError, match="without /v1"):
- Settings()
+ assert Settings().ollama_base_url == "http://localhost:11434/v1"
def test_provider_rate_limit_from_env(self, monkeypatch):
"""PROVIDER_RATE_LIMIT env var is loaded into settings."""
diff --git a/tests/config/test_provider_catalog.py b/tests/config/test_provider_catalog.py
index 024b5d89..fe4ca71c 100644
--- a/tests/config/test_provider_catalog.py
+++ b/tests/config/test_provider_catalog.py
@@ -1,58 +1,34 @@
-from dataclasses import FrozenInstanceError, fields
+from dataclasses import FrozenInstanceError
import pytest
from free_claude_code.config.provider_catalog import (
PROVIDER_CATALOG,
- ProviderCapabilities,
ProviderDescriptor,
)
-def test_provider_capabilities_are_an_exact_immutable_value_shape() -> None:
- capabilities = ProviderCapabilities(local=True, server_tool_passthrough=True)
-
- assert tuple(field.name for field in fields(ProviderCapabilities)) == (
- "local",
- "server_tool_passthrough",
- )
- assert ProviderCapabilities.__slots__ == (
- "local",
- "server_tool_passthrough",
- )
- assert not hasattr(capabilities, "__dict__")
- assert capabilities == ProviderCapabilities(
+def test_provider_descriptors_are_immutable_values() -> None:
+ descriptor = ProviderDescriptor(
+ provider_id="local",
+ display_name="Local",
local=True,
- server_tool_passthrough=True,
- )
- assert ProviderCapabilities() == ProviderCapabilities(
- local=False,
- server_tool_passthrough=False,
)
+
+ assert descriptor.local is True
+ assert not hasattr(descriptor, "__dict__")
with pytest.raises(FrozenInstanceError):
- capabilities.__setattr__("local", False)
+ descriptor.__setattr__("local", False)
-def test_catalog_has_no_transport_or_string_capability_metadata() -> None:
+def test_catalog_has_no_transport_metadata() -> None:
assert "transport_type" not in ProviderDescriptor.__slots__
- assert all(
- not hasattr(descriptor, "transport_type")
- for descriptor in PROVIDER_CATALOG.values()
- )
- assert all(
- type(descriptor.capabilities) is ProviderCapabilities
- for descriptor in PROVIDER_CATALOG.values()
- )
+ assert "capabilities" not in ProviderDescriptor.__slots__
-def test_catalog_capability_assignments_are_exact() -> None:
+def test_catalog_local_assignments_are_exact() -> None:
assert {
provider_id
for provider_id, descriptor in PROVIDER_CATALOG.items()
- if descriptor.capabilities.local
+ if descriptor.local
} == {"lmstudio", "llamacpp", "ollama"}
- assert {
- provider_id
- for provider_id, descriptor in PROVIDER_CATALOG.items()
- if descriptor.capabilities.server_tool_passthrough
- } == {"llamacpp", "ollama"}
diff --git a/tests/contracts/test_admin_provider_manifest.py b/tests/contracts/test_admin_provider_manifest.py
index fab0ddaf..36ba118a 100644
--- a/tests/contracts/test_admin_provider_manifest.py
+++ b/tests/contracts/test_admin_provider_manifest.py
@@ -107,7 +107,7 @@ def test_provider_catalog_display_names_are_admin_status_source() -> None:
assert set(status_by_provider) == set(PROVIDER_CATALOG)
for provider_id, desc in PROVIDER_CATALOG.items():
assert status_by_provider[provider_id]["display_name"] == desc.display_name
- expected_kind = "local" if desc.capabilities.local else "remote"
+ expected_kind = "local" if desc.local else "remote"
assert status_by_provider[provider_id]["kind"] == expected_kind
diff --git a/tests/contracts/test_local_provider_smoke.py b/tests/contracts/test_local_provider_smoke.py
index 78c67b75..d126b19f 100644
--- a/tests/contracts/test_local_provider_smoke.py
+++ b/tests/contracts/test_local_provider_smoke.py
@@ -35,21 +35,30 @@ def test_local_provider_openai_models_returns_first_id(monkeypatch) -> None:
assert calls == [("http://127.0.0.1:1234/v1/models", 1.5)]
-def test_local_provider_ollama_tags_returns_first_name(monkeypatch) -> None:
+ ("provider", "port", "model_id"),
+ [
+ ("llamacpp", 8080, "local-model"),
+ ("ollama", 11434, "llama3.1"),
+ ],
+)
+def test_local_provider_root_url_targets_openai_v1_models(
+ monkeypatch, provider: str, port: int, model_id: str
+) -> None:
def fake_get(url: str, *, timeout: float) -> FakeResponse:
- assert url == "http://127.0.0.1:11434/api/tags"
+ assert url == f"http://127.0.0.1:{port}/v1/models"
assert timeout == 1.5
- return FakeResponse(200, {"models": [{"name": "llama3.1"}]})
+ return FakeResponse(200, {"data": [{"id": model_id}]})
monkeypatch.setattr("smoke.lib.local_providers.httpx.get", fake_get)
assert (
first_local_provider_model_id(
- "ollama",
- "http://127.0.0.1:11434",
+ provider,
+ f"http://127.0.0.1:{port}",
timeout_s=45,
)
- == "llama3.1"
+ == model_id
)
diff --git a/tests/core/anthropic/test_native_sse_block_policy.py b/tests/core/anthropic/test_native_sse_block_policy.py
deleted file mode 100644
index cb8d69ce..00000000
--- a/tests/core/anthropic/test_native_sse_block_policy.py
+++ /dev/null
@@ -1,131 +0,0 @@
-"""Unit tests for shared native Anthropic SSE thinking policy / block remapping."""
-
-import json
-
-from free_claude_code.core.anthropic.native_sse_block_policy import (
- NativeSseBlockPolicyState,
- format_native_sse_event,
- transform_native_sse_block_event,
-)
-
-
-def test_thinking_start_dropped_when_disabled() -> None:
- st = NativeSseBlockPolicyState()
- payload = {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "thinking", "thinking": ""},
- }
- ev = format_native_sse_event(
- "content_block_start",
- json.dumps(payload),
- )
- assert transform_native_sse_block_event(ev, st, thinking_enabled=False) is None
-
-
-def test_thinking_delta_dropped_when_disabled() -> None:
- st = NativeSseBlockPolicyState()
- # No prior start in stream (OpenRouter-style: returns None when thinking off)
- payload = {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "thinking_delta", "thinking": "secret"},
- }
- ev = format_native_sse_event("content_block_delta", json.dumps(payload))
- assert transform_native_sse_block_event(ev, st, thinking_enabled=False) is None
-
-
-def test_text_block_passthrough_when_thinking_disabled() -> None:
- st = NativeSseBlockPolicyState()
- payload = {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- }
- ev = format_native_sse_event("content_block_start", json.dumps(payload))
- out = transform_native_sse_block_event(ev, st, thinking_enabled=False)
- assert out is not None
- assert '"index": 0' in (out or "")
-
-
-def test_interleaved_thinking_signature_delta_remaps_to_reopened_block_index() -> None:
- """After text interrupts thinking, signature_delta must follow the reopened segment index."""
- st = NativeSseBlockPolicyState()
-
- def run(ev: str) -> str | None:
- return transform_native_sse_block_event(ev, st, thinking_enabled=True)
-
- out1 = run(
- format_native_sse_event(
- "content_block_start",
- json.dumps(
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "thinking", "thinking": ""},
- }
- ),
- )
- )
- assert out1 is not None and '"index": 0' in out1
-
- out2 = run(
- format_native_sse_event(
- "content_block_start",
- json.dumps(
- {
- "type": "content_block_start",
- "index": 1,
- "content_block": {"type": "text", "text": ""},
- }
- ),
- )
- )
- assert out2 is not None
-
- out3 = run(
- format_native_sse_event(
- "content_block_delta",
- json.dumps(
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "thinking_delta", "thinking": "plan"},
- }
- ),
- )
- )
- assert out3 is not None
- assert "content_block_start" in out3
-
- out4 = run(
- format_native_sse_event(
- "content_block_delta",
- json.dumps(
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "signature_delta", "signature": "sig"},
- }
- ),
- )
- )
- assert out4 is not None
- assert '"index": 2' in out4
- assert "signature_delta" in out4
-
-
-def test_startless_text_delta_synthesizes_start_when_thinking_disabled() -> None:
- """Startless text deltas must not be dropped when thinking is disabled (OpenRouter)."""
- st = NativeSseBlockPolicyState()
- payload = {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "Hello"},
- }
- ev = format_native_sse_event("content_block_delta", json.dumps(payload))
- out = transform_native_sse_block_event(ev, st, thinking_enabled=False)
- assert out is not None
- assert "content_block_start" in (out or "")
- assert "Hello" in (out or "")
- assert "text_delta" in (out or "")
diff --git a/tests/core/anthropic/test_request_serialization.py b/tests/core/anthropic/test_request_serialization.py
index 3eab7f99..3a9ffbba 100644
--- a/tests/core/anthropic/test_request_serialization.py
+++ b/tests/core/anthropic/test_request_serialization.py
@@ -1,200 +1,104 @@
-"""Pydantic passthrough of Anthropic protocol fields (e.g. ``cache_control``)."""
+"""Anthropic request parsing and public-field serialization."""
-from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from free_claude_code.core.anthropic import dump_messages_request
from free_claude_code.core.anthropic.models import (
ContentBlockServerToolUse,
ContentBlockText,
ContentBlockWebSearchToolResult,
Message,
MessagesRequest,
- SystemContent,
- Tool,
-)
-from free_claude_code.core.anthropic.native_messages_request import (
- build_base_native_anthropic_request_body,
)
-def test_cache_control_preserved_on_parsed_user_text_system_and_tool() -> None:
- raw = {
- "model": "m",
- "max_tokens": 20,
- "messages": [
- {
- "role": "user",
- "content": [
- {
- "type": "text",
- "text": "hi",
- "cache_control": {"type": "ephemeral"},
- }
- ],
- }
- ],
- "system": [
- {
- "type": "text",
- "text": "be brief",
- "cache_control": {"type": "ephemeral"},
- }
- ],
- "tools": [
- {
- "name": "alpha",
- "input_schema": {"type": "object"},
- "cache_control": {"type": "ephemeral"},
- }
- ],
- }
- req = MessagesRequest.model_validate(raw)
- block = req.messages[0].content[0]
- assert isinstance(block, ContentBlockText)
- assert block.model_dump()["cache_control"] == {"type": "ephemeral"}
- s0 = req.system[0] if isinstance(req.system, list) else None
- assert isinstance(s0, SystemContent)
- assert s0.model_dump()["cache_control"] == {"type": "ephemeral"}
- t0 = req.tools[0] if req.tools else None
- assert isinstance(t0, Tool)
- assert t0.model_dump()["cache_control"] == {"type": "ephemeral"}
-
-
-def test_build_base_native_body_includes_cache_control() -> None:
- req = MessagesRequest(
- model="m",
- max_tokens=20,
- messages=[
- Message(
- role="user",
- content=[
- ContentBlockText.model_validate(
+def test_dump_preserves_public_fields_and_nested_extensions() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "m",
+ "max_tokens": 20,
+ "messages": [
+ {
+ "role": "user",
+ "content": [
{
"type": "text",
- "text": "x",
+ "text": "hi",
"cache_control": {"type": "ephemeral"},
}
- )
- ],
- )
- ],
- system=[
- SystemContent.model_validate(
- {
- "type": "text",
- "text": "s",
- "cache_control": {"type": "ephemeral"},
- }
- )
- ],
- tools=[
- Tool.model_validate(
- {
- "name": "n",
- "input_schema": {"type": "object"},
- "cache_control": {"type": "ephemeral"},
+ ],
}
- )
- ],
- )
- body = build_base_native_anthropic_request_body(
- req,
- default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
- thinking_enabled=False,
+ ],
+ "context_management": {"edits": [{"type": "clear"}]},
+ "output_config": {"some": "hint"},
+ }
)
+
+ body = dump_messages_request(request)
+
assert body["messages"][0]["content"][0]["cache_control"] == {"type": "ephemeral"}
- assert body["system"][0]["cache_control"] == {"type": "ephemeral"}
- assert body["tools"][0]["cache_control"] == {"type": "ephemeral"}
-
-
-def test_build_base_native_body_drops_unknown_top_level_client_hints() -> None:
- raw = {
- "model": "m",
- "max_tokens": 20,
- "messages": [{"role": "user", "content": "x"}],
- "reasoning_effort": "none",
- "unknown_client_hint": {"mode": "local"},
- }
- req = MessagesRequest.model_validate(raw)
- body = build_base_native_anthropic_request_body(
- req,
- default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
- thinking_enabled=False,
+ assert body["context_management"] == {"edits": [{"type": "clear"}]}
+ assert body["output_config"] == {"some": "hint"}
+
+
+def test_dump_excludes_unknown_client_hints_and_fcc_routing_state() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "m",
+ "messages": [{"role": "user", "content": "x"}],
+ "reasoning_effort": "none",
+ "unknown_client_hint": {"mode": "local"},
+ }
)
+ request.original_model = "claude"
+ request.resolved_provider_model = "upstream"
+
+ body = dump_messages_request(request)
+
assert "reasoning_effort" not in body
assert "unknown_client_hint" not in body
+ assert "original_model" not in body
+ assert "resolved_provider_model" not in body
def test_pydantic_discriminator_still_distinguishes_blocks() -> None:
- m = Message.model_validate(
+ message = Message.model_validate(
{
"role": "user",
"content": [{"type": "text", "text": "a", "z": 1}],
}
)
- b = m.content[0]
- assert isinstance(b, ContentBlockText)
- assert b.model_dump()["z"] == 1
-
-
-def test_server_tool_assistant_blocks_round_trip_in_native_body() -> None:
- """Local server-tool responses must parse as valid history for a follow-up request."""
- raw = {
- "model": "m",
- "max_tokens": 20,
- "messages": [
- {
- "role": "assistant",
- "content": [
- {
- "type": "server_tool_use",
- "id": "srvtoolu_1",
- "name": "web_search",
- "input": {"query": "q"},
- },
- {
- "type": "web_search_tool_result",
- "tool_use_id": "srvtoolu_1",
- "content": [
- {
- "type": "web_search_result",
- "title": "T",
- "url": "https://example.com",
- }
- ],
- },
- ],
- }
- ],
- "mcp_servers": [{"type": "url", "url": "https://example.com/mcp"}],
- }
- req = MessagesRequest.model_validate(raw)
- assert len(req.messages) == 1
- blocks = req.messages[0].content
+
+ block = message.content[0]
+
+ assert isinstance(block, ContentBlockText)
+ assert block.model_dump()["z"] == 1
+
+
+def test_server_tool_history_remains_valid_anthropic_input() -> None:
+ request = MessagesRequest.model_validate(
+ {
+ "model": "m",
+ "messages": [
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "server_tool_use",
+ "id": "srvtoolu_1",
+ "name": "web_search",
+ "input": {"query": "q"},
+ },
+ {
+ "type": "web_search_tool_result",
+ "tool_use_id": "srvtoolu_1",
+ "content": [],
+ },
+ ],
+ }
+ ],
+ }
+ )
+
+ blocks = request.messages[0].content
assert isinstance(blocks, list)
assert isinstance(blocks[0], ContentBlockServerToolUse)
assert isinstance(blocks[1], ContentBlockWebSearchToolResult)
- body = build_base_native_anthropic_request_body(
- req,
- default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
- thinking_enabled=False,
- )
- assert body["mcp_servers"][0]["type"] == "url"
- assert body["messages"][0]["content"][0]["type"] == "server_tool_use"
- assert body["messages"][0]["content"][1]["type"] == "web_search_tool_result"
-
-
-def test_native_body_preserves_context_and_output_config() -> None:
- raw = {
- "model": "m",
- "max_tokens": 20,
- "messages": [{"role": "user", "content": "x"}],
- "context_management": {"edits": [{"type": "clear"}]},
- "output_config": {"some": "hint"},
- }
- req = MessagesRequest.model_validate(raw)
- body = build_base_native_anthropic_request_body(
- req,
- default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
- thinking_enabled=False,
- )
- assert body["context_management"] == raw["context_management"]
- assert body["output_config"] == raw["output_config"]
diff --git a/tests/core/anthropic/test_stream_ledger.py b/tests/core/anthropic/test_stream_ledger.py
index e1c05f2a..2ebdb9b2 100644
--- a/tests/core/anthropic/test_stream_ledger.py
+++ b/tests/core/anthropic/test_stream_ledger.py
@@ -1,768 +1,126 @@
-"""Tests for core.anthropic.streaming.ledger."""
+"""Tests for the provider-neutral Anthropic stream ledger."""
-from typing import Any, cast
+import json
from unittest.mock import patch
import pytest
-from free_claude_code.core.anthropic import (
+from free_claude_code.core.anthropic.streaming import (
AnthropicStreamLedger,
StreamBlockLedger,
+ ToolSchema,
map_stop_reason,
)
-from free_claude_code.core.anthropic.stream_contracts import SSEEvent, parse_sse_text
-from free_claude_code.core.anthropic.streaming import ToolBlockState
-
-
-def _parse_sse(sse_str: str) -> dict:
- """Parse an SSE event string into its data payload."""
- events = parse_sse_text(sse_str)
- if len(events) != 1:
- raise ValueError(f"expected 1 SSE event, got {len(events)} in {sse_str!r}")
- return events[0].data
-
-
-class _CharEncoder:
- def encode(self, text: str) -> list[int]:
- return [0] * len(text)
-
-
-class TestMapStopReason:
- """Tests for map_stop_reason function."""
-
- @pytest.mark.parametrize(
- "openai_reason,expected",
- [
- ("stop", "end_turn"),
- ("length", "max_tokens"),
- ("tool_calls", "tool_use"),
- ("content_filter", "end_turn"),
- (None, "end_turn"),
- ("unknown_value", "end_turn"),
- ("", "end_turn"),
- ],
- ids=[
- "stop",
- "length",
- "tool_calls",
- "content_filter",
- "none",
- "unknown",
- "empty_string",
- ],
+
+
+def _payload(event: str) -> dict:
+ return json.loads(
+ next(line[6:] for line in event.splitlines() if line.startswith("data:"))
)
- def test_map_stop_reason(self, openai_reason, expected):
- assert map_stop_reason(openai_reason) == expected
-
-
-class TestStreamBlockLedger:
- """Tests for StreamBlockLedger."""
-
- def test_allocate_index_increments(self):
- mgr = StreamBlockLedger()
- assert mgr.allocate_index() == 0
- assert mgr.allocate_index() == 1
- assert mgr.allocate_index() == 2
-
- def test_initial_state(self):
- mgr = StreamBlockLedger()
- assert mgr.thinking_index == -1
- assert mgr.text_index == -1
- assert mgr.thinking_started is False
- assert mgr.text_started is False
- assert mgr.tool_states == {}
-
- def test_flush_task_arg_buffers_logs_digest_not_secret(self, caplog):
- """Invalid Task JSON warnings must not echo argument prefixes (secrets)."""
- mgr = StreamBlockLedger()
- mgr.tool_states[0] = ToolBlockState(
- block_index=0, tool_id="call_x", name="Task", started=True
- )
- mgr.tool_states[
- 0
- ].task_arg_buffer = (
- '{"api_key": "sk-live-super-secret-do-not-log"}not_valid_json'
- )
- with caplog.at_level("WARNING"):
- out = mgr.flush_task_arg_buffers()
- assert out == [(0, "{}")]
- text = " | ".join(r.message for r in caplog.records)
- assert "sk-live-super-secret" not in text
- assert "buffer_sha256_prefix=" in text
-
-
-class TestAnthropicStreamLedgerMessageLifecycle:
- """Tests for message_start, message_delta, message_stop."""
-
- def test_message_start(self):
- builder = AnthropicStreamLedger("msg_123", "test-model", input_tokens=50)
- sse = builder.message_start()
-
- assert "event: message_start" in sse
- data = _parse_sse(sse)
- assert data["type"] == "message_start"
- msg = data["message"]
- assert msg["id"] == "msg_123"
- assert msg["model"] == "test-model"
- assert msg["role"] == "assistant"
- assert msg["content"] == []
- assert msg["usage"]["input_tokens"] == 50
- assert msg["usage"]["output_tokens"] == 1
-
- def test_message_delta(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.message_delta("end_turn", 42)
-
- assert "event: message_delta" in sse
- data = _parse_sse(sse)
- assert data["type"] == "message_delta"
- assert data["delta"]["stop_reason"] == "end_turn"
- assert data["usage"]["output_tokens"] == 42
-
- def test_message_start_coerces_non_int_input_tokens(self):
- builder = AnthropicStreamLedger("msg_1", "model", input_tokens=0)
- builder.input_tokens = cast(Any, "not_an_int")
- sse = builder.message_start()
- data = _parse_sse(sse)
- assert data["message"]["usage"]["input_tokens"] == 0
- assert data["message"]["usage"]["output_tokens"] == 1
-
- def test_message_delta_coerces_none_output_tokens(self):
- builder = AnthropicStreamLedger("msg_1", "model", input_tokens=3)
- sse = builder.message_delta("end_turn", None)
- data = _parse_sse(sse)
- assert data["usage"]["input_tokens"] == 3
- assert data["usage"]["output_tokens"] == 0
-
- def test_message_delta_preserves_zero_output_tokens(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.message_delta("end_turn", 0)
- data = _parse_sse(sse)
- assert data["usage"]["output_tokens"] == 0
-
- def test_message_stop(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.message_stop()
-
- assert "event: message_stop" in sse
- data = _parse_sse(sse)
- assert data["type"] == "message_stop"
-
-
-class TestAnthropicStreamLedgerContentBlocks:
- """Tests for content block start/delta/stop events."""
-
- def test_content_block_start_text(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_start(0, "text", text="hello")
-
- data = _parse_sse(sse)
- assert data["type"] == "content_block_start"
- assert data["index"] == 0
- assert data["content_block"]["type"] == "text"
- assert data["content_block"]["text"] == "hello"
-
- def test_content_block_start_thinking(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_start(1, "thinking")
-
- data = _parse_sse(sse)
- assert data["content_block"]["type"] == "thinking"
- assert data["content_block"]["thinking"] == ""
-
- def test_content_block_start_tool_use(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_start(
- 2, "tool_use", id="tool_123", name="Read", input={}
- )
-
- data = _parse_sse(sse)
- assert data["content_block"]["type"] == "tool_use"
- assert data["content_block"]["id"] == "tool_123"
- assert data["content_block"]["name"] == "Read"
- assert data["content_block"]["input"] == {}
- assert builder.has_emitted_tool_block()
-
- def test_content_block_start_tool_use_extra_content(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_start(
- 2,
- "tool_use",
- id="tool_123",
- name="Read",
- input={},
- extra_content={"google": {"thought_signature": "sig"}},
- )
-
- data = _parse_sse(sse)
- assert data["content_block"]["extra_content"] == {
- "google": {"thought_signature": "sig"}
- }
- def test_content_block_delta_text(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_delta(0, "text_delta", "hello world")
- data = _parse_sse(sse)
- assert data["type"] == "content_block_delta"
- assert data["index"] == 0
- assert data["delta"]["type"] == "text_delta"
- assert data["delta"]["text"] == "hello world"
+ ("upstream", "anthropic"),
+ [
+ ("stop", "end_turn"),
+ ("length", "max_tokens"),
+ ("tool_calls", "tool_use"),
+ ("content_filter", "end_turn"),
+ (None, "end_turn"),
+ ],
+)
+def test_map_stop_reason(upstream: str | None, anthropic: str) -> None:
+ assert map_stop_reason(upstream) == anthropic
- def test_content_block_delta_thinking(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_delta(1, "thinking_delta", "reasoning...")
- data = _parse_sse(sse)
- assert data["delta"]["type"] == "thinking_delta"
- assert data["delta"]["thinking"] == "reasoning..."
+def test_stream_block_ledger_allocates_monotonic_indexes() -> None:
+ blocks = StreamBlockLedger()
- def test_content_block_delta_input_json(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_delta(2, "input_json_delta", '{"key": "val"}')
-
- data = _parse_sse(sse)
- assert data["delta"]["type"] == "input_json_delta"
- assert data["delta"]["partial_json"] == '{"key": "val"}'
-
- def test_content_block_stop(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.content_block_stop(0)
-
- data = _parse_sse(sse)
- assert data["type"] == "content_block_stop"
- assert data["index"] == 0
-
-
-class TestAnthropicStreamLedgerHighLevelHelpers:
- """Tests for high-level thinking/text/tool block helpers."""
-
- def test_start_and_stop_thinking_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
-
- start_sse = builder.start_thinking_block()
- data = _parse_sse(start_sse)
- assert data["content_block"]["type"] == "thinking"
- assert builder.blocks.thinking_started is True
- assert builder.blocks.thinking_index == 0
-
- stop_sse = builder.stop_thinking_block()
- data = _parse_sse(stop_sse)
- assert data["type"] == "content_block_stop"
- assert builder.blocks.thinking_started is False
-
- def test_emit_thinking_delta_accumulates(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_thinking_block()
-
- builder.emit_thinking_delta("part1 ")
- builder.emit_thinking_delta("part2")
-
- assert builder.accumulated_reasoning == "part1 part2"
-
- def test_start_and_stop_text_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
-
- start_sse = builder.start_text_block()
- data = _parse_sse(start_sse)
- assert data["content_block"]["type"] == "text"
- assert builder.blocks.text_started is True
- assert builder.blocks.text_index == 0
-
- builder.stop_text_block()
- assert builder.blocks.text_started is False
-
- def test_emit_text_delta_accumulates(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_text_block()
-
- builder.emit_text_delta("hello ")
- builder.emit_text_delta("world")
-
- assert builder.accumulated_text == "hello world"
-
- def test_start_tool_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- sse = builder.start_tool_block(0, "tool_abc", "Grep")
-
- data = _parse_sse(sse)
- assert data["content_block"]["type"] == "tool_use"
- assert data["content_block"]["id"] == "tool_abc"
- assert data["content_block"]["name"] == "Grep"
- assert 0 in builder.blocks.tool_states
-
- def test_emit_tool_delta(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_tool_block(0, "tool_abc", "Grep")
-
- sse = builder.emit_tool_delta(0, '{"pattern":')
- data = _parse_sse(sse)
- assert data["delta"]["partial_json"] == '{"pattern":'
- block = builder.tool_block_for_tool_index(0)
- assert block is not None
- assert block.content == '{"pattern":'
-
- def test_stop_tool_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_tool_block(0, "tool_abc", "Grep")
-
- sse = builder.stop_tool_block(0)
- data = _parse_sse(sse)
- assert data["type"] == "content_block_stop"
-
- def test_text_suffix_after_closed_native_block_closes_once(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.ingest_native_event(
- SSEEvent(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- "",
- )
- )
- builder.ingest_native_event(
- SSEEvent(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "hello"},
- },
- "",
- )
- )
- builder.ingest_native_event(
- SSEEvent(
- "content_block_stop",
- {"type": "content_block_stop", "index": 0},
- "",
- )
- )
-
- events = list(builder.append_text_suffix(" world"))
- events.extend(builder.success_tail("end_turn"))
- parsed = parse_sse_text("".join(events))
-
- assert [
- event.data["index"]
- for event in parsed
- if event.event == "content_block_start"
- ] == [1]
- assert [
- event.data["index"]
- for event in parsed
- if event.event == "content_block_delta"
- ] == [1]
- assert [
- event.data["index"]
- for event in parsed
- if event.event == "content_block_stop"
- ] == [1]
-
- def test_thinking_suffix_after_closed_native_block_closes_once(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.ingest_native_event(
- SSEEvent(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "thinking", "thinking": ""},
- },
- "",
- )
- )
- builder.ingest_native_event(
- SSEEvent(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "thinking_delta", "thinking": "step one"},
- },
- "",
- )
- )
- builder.ingest_native_event(
- SSEEvent(
- "content_block_stop",
- {"type": "content_block_stop", "index": 0},
- "",
- )
- )
-
- events = list(builder.append_thinking_suffix(" step two"))
- events.extend(builder.success_tail("end_turn"))
- parsed = parse_sse_text("".join(events))
-
- assert [
- event.data["index"]
- for event in parsed
- if event.event == "content_block_start"
- ] == [1]
- assert [
- event.data["index"]
- for event in parsed
- if event.event == "content_block_delta"
- ] == [1]
- assert [
- event.data["index"]
- for event in parsed
- if event.event == "content_block_stop"
- ] == [1]
-
- def test_text_suffix_appends_to_open_native_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.ingest_native_event(
- SSEEvent(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- "",
- )
- )
- builder.ingest_native_event(
- SSEEvent(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "hello wor"},
- },
- "",
- )
- )
-
- events = list(builder.append_text_suffix("ld"))
- events.extend(builder.success_tail("end_turn"))
- parsed = parse_sse_text("".join(events))
-
- assert [event.event for event in parsed] == [
- "content_block_delta",
- "content_block_stop",
- "message_delta",
- "message_stop",
- ]
- assert parsed[0].data["index"] == 0
- assert parsed[0].data["delta"]["text"] == "ld"
- assert parsed[1].data["index"] == 0
-
- def test_thinking_suffix_appends_to_open_native_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.ingest_native_event(
- SSEEvent(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "thinking", "thinking": ""},
- },
- "",
- )
- )
- builder.ingest_native_event(
- SSEEvent(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "thinking_delta", "thinking": "step o"},
- },
- "",
- )
- )
-
- events = list(builder.append_thinking_suffix("ne"))
- events.extend(builder.success_tail("end_turn"))
- parsed = parse_sse_text("".join(events))
-
- assert [event.event for event in parsed] == [
- "content_block_delta",
- "content_block_stop",
- "message_delta",
- "message_stop",
- ]
- assert parsed[0].data["index"] == 0
- assert parsed[0].data["delta"]["thinking"] == "ne"
- assert parsed[1].data["index"] == 0
-
- def test_suffix_helpers_noop_after_message_delta(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_text_block()
- builder.emit_text_delta("hello")
- builder.stop_text_block()
- builder.start_tool_block(0, "toolu_1", "Read")
- builder.emit_tool_delta(0, '{"path":"test.py"}')
- builder.stop_tool_block(0)
- builder.message_delta("tool_use", 10)
-
- assert list(builder.append_text_suffix(" world")) == []
- assert list(builder.append_thinking_suffix(" step")) == []
- assert list(builder.append_tool_repair_suffix(0, " ")) == []
-
- def test_suffix_helpers_noop_after_message_stop(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.message_stop()
-
- assert list(builder.append_text_suffix("late")) == []
- assert list(builder.append_thinking_suffix("late")) == []
-
- def test_final_stop_reason_uses_emitted_tool_content(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- assert builder.final_stop_reason("end_turn") == "end_turn"
-
- builder.content_block_start(0, "tool_use", id="toolu_1", name="Read")
-
- assert builder.final_stop_reason("end_turn") == "tool_use"
-
-
-class TestAnthropicStreamLedgerStateManagement:
- """Tests for ensure_thinking_block, ensure_text_block, close_all_blocks."""
-
- def test_ensure_thinking_block_closes_text_first(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_text_block()
- assert builder.blocks.text_started is True
-
- events = list(builder.ensure_thinking_block())
- # Should close text then start thinking
- assert len(events) == 2
- assert builder.blocks.text_started is False
- assert builder.blocks.thinking_started is True
-
- def test_ensure_thinking_block_noop_if_already_started(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_thinking_block()
-
- events = list(builder.ensure_thinking_block())
- assert events == []
-
- def test_ensure_text_block_closes_thinking_first(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_thinking_block()
- assert builder.blocks.thinking_started is True
-
- events = list(builder.ensure_text_block())
- # Should close thinking then start text
- assert len(events) == 2
- assert builder.blocks.thinking_started is False
- assert builder.blocks.text_started is True
-
- def test_ensure_text_block_noop_if_already_started(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_text_block()
-
- events = list(builder.ensure_text_block())
- assert events == []
-
- def test_append_text_suffix_closes_open_thinking_before_switching(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_thinking_block()
-
- events = list(builder.append_thinking_suffix(" step"))
- events.extend(builder.append_text_suffix(" answer"))
- parsed = parse_sse_text("".join(events))
-
- assert [event.event for event in parsed] == [
- "content_block_delta",
- "content_block_stop",
- "content_block_start",
- "content_block_delta",
- ]
- assert parsed[0].data["index"] == 0
- assert parsed[1].data["index"] == 0
- assert parsed[2].data["index"] == 1
- assert parsed[2].data["content_block"]["type"] == "text"
- assert parsed[3].data["index"] == 1
- assert builder.blocks.thinking_started is False
- assert builder.blocks.text_started is True
-
- def test_append_thinking_suffix_closes_open_text_before_switching(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_text_block()
-
- events = list(builder.append_text_suffix(" answer"))
- events.extend(builder.append_thinking_suffix(" step"))
- parsed = parse_sse_text("".join(events))
-
- assert [event.event for event in parsed] == [
- "content_block_delta",
- "content_block_stop",
- "content_block_start",
- "content_block_delta",
- ]
- assert parsed[0].data["index"] == 0
- assert parsed[1].data["index"] == 0
- assert parsed[2].data["index"] == 1
- assert parsed[2].data["content_block"]["type"] == "thinking"
- assert parsed[3].data["index"] == 1
- assert builder.blocks.text_started is False
- assert builder.blocks.thinking_started is True
-
- def test_close_content_blocks(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_thinking_block()
- builder.stop_thinking_block()
- builder.start_text_block()
-
- events = list(builder.close_content_blocks())
- # Should close text (thinking already stopped)
- assert len(events) == 1
- assert builder.blocks.text_started is False
-
- def test_close_all_blocks(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_thinking_block()
- builder.stop_thinking_block()
- builder.start_text_block()
- builder.start_tool_block(0, "t1", "Read")
- builder.start_tool_block(1, "t2", "Write")
-
- events = list(builder.close_all_blocks())
- # Close text + 2 tool blocks (thinking already stopped)
- assert len(events) == 3
- assert builder.blocks.text_started is False
-
- def test_close_all_blocks_empty(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- events = list(builder.close_all_blocks())
- assert events == []
-
-
-class TestAnthropicStreamLedgerTokenEstimation:
- """Tests for estimate_output_tokens."""
-
- def test_estimate_with_text_only(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_text_block()
- builder.emit_text_delta("hello world")
-
- tokens = builder.estimate_output_tokens()
- assert tokens > 0
-
- def test_estimate_with_reasoning(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_thinking_block()
- builder.emit_thinking_delta("deep thought")
- builder.stop_thinking_block()
- builder.start_text_block()
- builder.emit_text_delta("answer")
-
- tokens = builder.estimate_output_tokens()
- assert tokens > 0
-
- def test_estimate_empty(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- tokens = builder.estimate_output_tokens()
- assert tokens == 0
-
- def test_estimate_without_tiktoken(self):
- """Fallback estimation when tiktoken is not available."""
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_text_block()
- builder.emit_text_delta("a" * 100) # 100 chars -> ~25 tokens
-
- with patch("free_claude_code.core.anthropic.streaming.ledger.ENCODER", None):
- tokens = builder.estimate_output_tokens()
- assert tokens == 25 # 100 // 4
-
- def test_estimate_with_tools_no_tiktoken(self):
- """Fallback tool token estimation."""
- builder = AnthropicStreamLedger("msg_1", "model")
- builder.start_tool_block(0, "t1", "Read")
- builder.emit_tool_delta(0, '{"path":"test.py"}')
-
- with patch("free_claude_code.core.anthropic.streaming.ledger.ENCODER", None):
- tokens = builder.estimate_output_tokens()
- # 1 tool * 50 = 50
- assert tokens == 50
-
- def test_estimate_counts_native_tool_payload(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- tool_name = "Read"
- tool_args = '{"path":"test.py"}'
- builder.ingest_native_event(
- SSEEvent(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {
- "type": "tool_use",
- "id": "toolu_native",
- "name": tool_name,
- "input": {},
- },
- },
- "",
- )
- )
- builder.ingest_native_event(
- SSEEvent(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {
- "type": "input_json_delta",
- "partial_json": tool_args,
- },
+ assert (blocks.allocate_index(), blocks.allocate_index()) == (0, 1)
+
+
+def test_message_lifecycle() -> None:
+ ledger = AnthropicStreamLedger("msg_1", "model", input_tokens=7)
+
+ start = _payload(ledger.message_start())
+ delta = _payload(ledger.message_delta("end_turn", 3))
+ stop = _payload(ledger.message_stop())
+
+ assert start["message"]["id"] == "msg_1"
+ assert start["message"]["usage"]["input_tokens"] == 7
+ assert delta["delta"]["stop_reason"] == "end_turn"
+ assert delta["usage"]["output_tokens"] == 3
+ assert stop == {"type": "message_stop"}
+ assert ledger.has_terminal_message()
+
+
+def test_text_and_thinking_blocks_accumulate_content() -> None:
+ ledger = AnthropicStreamLedger("msg_1", "model")
+
+ ledger.start_thinking_block()
+ ledger.emit_thinking_delta("step")
+ ledger.stop_thinking_block()
+ ledger.start_text_block()
+ ledger.emit_text_delta("answer")
+ ledger.stop_text_block()
+
+ assert ledger.accumulated_reasoning == "step"
+ assert ledger.accumulated_text == "answer"
+
+
+def test_ensure_block_switches_close_the_previous_kind() -> None:
+ ledger = AnthropicStreamLedger("msg_1", "model")
+ ledger.start_thinking_block()
+
+ events = list(ledger.ensure_text_block())
+
+ assert [_payload(event)["type"] for event in events] == [
+ "content_block_stop",
+ "content_block_start",
+ ]
+ assert not ledger.blocks.thinking_started
+ assert ledger.blocks.text_started
+
+
+def test_tool_blocks_drive_stop_reason_and_salvage() -> None:
+ ledger = AnthropicStreamLedger("msg_1", "model")
+ ledger.start_tool_block(0, "toolu_1", "Read")
+ ledger.emit_tool_delta(0, '{"path":"test.py"}')
+
+ assert ledger.final_stop_reason("end_turn") == "tool_use"
+ assert ledger.can_salvage_tool_use(
+ {
+ "Read": ToolSchema(
+ name="Read",
+ input_schema={
+ "type": "object",
+ "properties": {"path": {"type": "string"}},
},
- "",
)
- )
-
- with patch(
- "free_claude_code.core.anthropic.streaming.ledger.ENCODER", _CharEncoder()
- ):
- tokens = builder.estimate_output_tokens()
-
- assert tokens == len(tool_name) + len(tool_args) + 15 + 4
-
- def test_estimate_does_not_double_count_openai_tool_content_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- tool_name = "Read"
- tool_args = '{"path":"test.py"}'
- builder.start_tool_block(0, "toolu_openai", tool_name)
- builder.emit_tool_delta(0, tool_args)
-
- with patch(
- "free_claude_code.core.anthropic.streaming.ledger.ENCODER", _CharEncoder()
- ):
- tokens = builder.estimate_output_tokens()
-
- assert tokens == len(tool_name) + len(tool_args) + 15 + 4
-
- def test_estimate_ignores_unstarted_openai_tool_state(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- state = builder.blocks.ensure_tool_state(0)
- state.name = "Read"
- state.pre_start_args = '{"path":"test.py"}'
-
- with patch(
- "free_claude_code.core.anthropic.streaming.ledger.ENCODER", _CharEncoder()
- ):
- tokens = builder.estimate_output_tokens()
-
- assert tokens == 0
-
- def test_estimate_heuristic_style_tool_content_block(self):
- builder = AnthropicStreamLedger("msg_1", "model")
- tool_name = "Read"
- tool_args = '{"path":"test.py"}'
- builder.content_block_start(0, "tool_use", id="toolu_heuristic", name=tool_name)
- builder.content_block_delta(0, "input_json_delta", tool_args)
- builder.content_block_stop(0)
-
- with patch(
- "free_claude_code.core.anthropic.streaming.ledger.ENCODER", _CharEncoder()
- ):
- tokens = builder.estimate_output_tokens()
-
- assert tokens == len(tool_name) + len(tool_args) + 15 + 4
+ }
+ )
+
+
+def test_close_unclosed_blocks_closes_each_block_once() -> None:
+ ledger = AnthropicStreamLedger("msg_1", "model")
+ ledger.start_text_block()
+ ledger.start_tool_block(0, "toolu_1", "Read")
+
+ events = list(ledger.close_unclosed_blocks())
+
+ assert len(events) == 2
+ assert all(_payload(event)["type"] == "content_block_stop" for event in events)
+ assert list(ledger.close_unclosed_blocks()) == []
+
+
+def test_output_token_estimate_uses_encoder_when_available() -> None:
+ ledger = AnthropicStreamLedger("msg_1", "model")
+ ledger.start_text_block()
+ ledger.emit_text_delta("abcd")
+
+ class Encoder:
+ def encode(self, text: str) -> list[int]:
+ return list(range(len(text)))
+
+ with patch("free_claude_code.core.anthropic.streaming.ledger.ENCODER", Encoder()):
+ assert ledger.estimate_output_tokens() == 8
diff --git a/tests/core/test_failure_protocol_mapping.py b/tests/core/test_failure_protocol_mapping.py
index 029d544c..dbf70324 100644
--- a/tests/core/test_failure_protocol_mapping.py
+++ b/tests/core/test_failure_protocol_mapping.py
@@ -5,7 +5,6 @@ import pytest
from free_claude_code.core.anthropic.errors import (
anthropic_error_type_for_failure,
anthropic_failure_payload,
- execution_failure_from_anthropic_error,
)
from free_claude_code.core.failures import ExecutionFailure, FailureKind
from free_claude_code.core.openai_responses.errors import (
@@ -38,36 +37,6 @@ def test_each_protocol_owns_failure_kind_to_wire_type_mapping(
assert openai_error_type_for_failure(kind) == openai_type
- ("native_type", "kind", "status_code"),
- [
- ("billing_error", FailureKind.PERMISSION, 402),
- ("not_found_error", FailureKind.INVALID_REQUEST, 404),
- ("request_too_large", FailureKind.INVALID_REQUEST, 413),
- ("timeout_error", FailureKind.TIMEOUT, 504),
- ],
-)
-def test_native_error_type_round_trips_through_status_aware_execution_failure(
- native_type: str,
- kind: FailureKind,
- status_code: int,
-) -> None:
- failure = execution_failure_from_anthropic_error(
- {
- "type": "error",
- "error": {
- "type": native_type,
- "message": "Native provider failure.",
- },
- }
- )
-
- assert failure.kind is kind
- assert failure.status_code == status_code
- assert anthropic_failure_payload(failure)["error"]["type"] == native_type
- assert openai_failure_payload(failure)["error"]["type"] == native_type
-
-
def test_finalized_status_502_timeout_keeps_existing_api_error_wire_type() -> None:
failure = ExecutionFailure(
kind=FailureKind.TIMEOUT,
diff --git a/tests/providers/test_anthropic_messages.py b/tests/providers/test_anthropic_messages.py
deleted file mode 100644
index 671f2ed2..00000000
--- a/tests/providers/test_anthropic_messages.py
+++ /dev/null
@@ -1,1239 +0,0 @@
-"""Tests for the shared native Anthropic Messages transport."""
-
-from contextlib import asynccontextmanager
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import httpx
-import pytest
-
-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.core.anthropic.streaming import (
- AnthropicStreamLedger,
- format_sse_event,
-)
-from free_claude_code.core.async_iterators import AsyncCloseable
-from free_claude_code.core.failures import ExecutionFailure, FailureKind
-from free_claude_code.providers.base import ProviderConfig
-from free_claude_code.providers.rate_limit import ProviderRateLimiter
-from free_claude_code.providers.stream_recovery import (
- EARLY_TRANSPARENT_TOTAL_ATTEMPTS,
- MIDSTREAM_RECOVERY_ATTEMPTS,
- TruncatedProviderStreamError,
-)
-from free_claude_code.providers.transports.anthropic_messages import (
- AnthropicMessagesTransport,
-)
-from free_claude_code.providers.transports.anthropic_messages.transport import (
- _AnthropicMessagesStreamRunner,
-)
-from tests.providers.request_factory import make_messages_request
-from tests.providers.support import passthrough_rate_limiter
-
-
-class NativeProvider(AnthropicMessagesTransport):
- def __init__(self, config: ProviderConfig, *, rate_limiter: ProviderRateLimiter):
- super().__init__(
- config,
- provider_name="TEST_NATIVE",
- default_base_url="https://example.test/v1",
- rate_limiter=rate_limiter,
- )
-
- def _request_headers(self) -> dict[str, str]:
- return {"Content-Type": "application/json", "X-Test": "1"}
-
-
-class FakeResponse:
- def __init__(
- self,
- *,
- status_code=200,
- lines=None,
- text="",
- raise_after_line_index: int | None = None,
- raise_error: Exception | None = None,
- close_error: Exception | None = None,
- ):
- self.status_code = status_code
- self._lines = lines or []
- self._text = text
- self._raise_after_line_index = raise_after_line_index
- self._raise_error = raise_error or RuntimeError("mid-stream failure")
- self._close_error = close_error
- self.close_calls = 0
- self.line_iterator_close_calls = 0
- self.is_closed = False
- self.request = httpx.Request("POST", "https://example.test/v1/messages")
- self.headers = httpx.Headers()
-
- async def aiter_lines(self):
- try:
- for i, line in enumerate(self._lines):
- yield line
- if (
- self._raise_after_line_index is not None
- and i >= self._raise_after_line_index
- ):
- raise self._raise_error
- finally:
- self.line_iterator_close_calls += 1
-
- async def aread(self):
- return self._text.encode()
-
- def raise_for_status(self):
- response = httpx.Response(
- self.status_code,
- request=self.request,
- text=self._text,
- )
- response.raise_for_status()
-
- async def aclose(self):
- self.close_calls += 1
- if self._close_error is not None:
- raise self._close_error
- self.is_closed = True
-
- async def aiter_bytes(self, chunk_size: int = 65_536):
- data = self._text.encode("utf-8")
- for offset in range(0, len(data), chunk_size):
- yield data[offset : offset + chunk_size]
-
-
-def _lines_from_events(*events: str) -> list[str]:
- lines: list[str] = []
- for event in events:
- lines.extend(event.splitlines())
- return lines
-
-
-def provider_config():
- return ProviderConfig(
- api_key="test-key",
- base_url="https://custom.test/v1/",
- proxy="socks5://127.0.0.1:9999",
- rate_limit=10,
- rate_window=60,
- http_read_timeout=600.0,
- http_write_timeout=15.0,
- http_connect_timeout=5.0,
- )
-
-
-def mock_rate_limiter():
- @asynccontextmanager
- async def _slot():
- yield
-
- instance = MagicMock(spec=ProviderRateLimiter)
-
- async def _passthrough(fn, *args, **kwargs):
- return await fn(*args, **kwargs)
-
- instance.execute_with_retry = AsyncMock(side_effect=_passthrough)
- instance.concurrency_slot.side_effect = _slot
- yield instance
-
-
-def test_init_configures_httpx_client(provider_config):
- with patch("httpx.AsyncClient") as mock_client:
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
-
- assert provider._provider_name == "TEST_NATIVE"
- assert provider._api_key == "test-key"
- assert provider._base_url == "https://custom.test/v1"
- kwargs = mock_client.call_args.kwargs
- timeout = kwargs["timeout"]
- assert kwargs["base_url"] == "https://custom.test/v1"
- assert kwargs["proxy"] == "socks5://127.0.0.1:9999"
- assert timeout.read == 600.0
- assert timeout.write == 15.0
- assert timeout.connect == 5.0
-
-
-def test_default_request_body_strips_internal_fields(provider_config):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
-
- body = provider._build_request_body(make_messages_request(max_tokens=None))
-
- assert body["model"] == "test-model"
- assert body["thinking"] == {"type": "enabled"}
- assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
- assert "extra_body" not in body
-
-
-def test_default_request_body_preserves_thinking_budget(provider_config):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request(
- max_tokens=None,
- thinking={"type": "enabled", "budget_tokens": 4096},
- )
-
- body = provider._build_request_body(req)
-
- assert body["thinking"] == {"type": "enabled", "budget_tokens": 4096}
-
-
-async def test_send_stream_request_forces_upstream_streaming(provider_config):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
- response = FakeResponse()
- body = {"model": "test-model", "stream": False}
-
- with (
- patch.object(
- provider._client, "build_request", return_value=request_obj
- ) as mock_build,
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- ):
- await provider._send_stream_request(body)
-
- assert body["stream"] is False
- assert mock_build.call_args.kwargs["json"]["stream"] is True
-
-
-async def test_stream_uses_retry_builds_request_and_closes_response(
- provider_config,
- mock_rate_limiter,
-):
- provider = NativeProvider(provider_config, rate_limiter=mock_rate_limiter)
- req = make_messages_request()
- request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
- response = FakeResponse(
- lines=[
- "event: message_start",
- 'data: {"type":"message_start"}',
- "",
- "event: message_stop",
- 'data: {"type":"message_stop"}',
- "",
- ]
- )
-
- with (
- patch.object(
- provider._client, "build_request", return_value=request_obj
- ) as mock_build,
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ) as mock_send,
- ):
- events = [event async for event in provider.stream_response(req)]
-
- assert [event.event for event in parse_sse_text("".join(events))] == [
- "message_start",
- "message_stop",
- ]
- assert response.is_closed
- assert mock_build.call_args.args[:2] == ("POST", "/messages")
- assert mock_build.call_args.kwargs["headers"] == {
- "Content-Type": "application/json",
- "X-Test": "1",
- }
- assert mock_build.call_args.kwargs["json"]["thinking"] == {"type": "enabled"}
- mock_send.assert_awaited_once_with(request_obj, stream=True)
- mock_rate_limiter.execute_with_retry.assert_awaited_once()
-
-
-async def test_closing_public_native_stream_closes_response_once(
- provider_config,
- mock_rate_limiter,
-):
- provider = NativeProvider(provider_config, rate_limiter=mock_rate_limiter)
- request = make_messages_request()
- response = FakeResponse(
- lines=_lines_from_events(
- format_sse_event(
- "message_start",
- {"type": "message_start", "message": {}},
- ),
- format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- ),
- format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "x" * 65_536},
- },
- ),
- )
- )
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- ):
- stream = provider.stream_response(request, request_id="req_native_early_close")
- await anext(stream)
- assert isinstance(stream, AsyncCloseable)
- await stream.aclose()
-
- assert response.close_calls == 1
- assert response.line_iterator_close_calls == 1
-
-
-async def test_late_error_after_native_message_stop_keeps_successful_lifecycle(
- provider_config,
- mock_rate_limiter,
-):
- provider = NativeProvider(provider_config, rate_limiter=mock_rate_limiter)
- req = make_messages_request()
- lines = [
- "event: message_start",
- 'data: {"type":"message_start"}',
- "",
- "event: message_stop",
- 'data: {"type":"message_stop"}',
- "",
- ]
- response = FakeResponse(
- lines=lines,
- raise_after_line_index=len(lines) - 1,
- raise_error=httpx.ReadError(
- "late cleanup failure",
- request=httpx.Request("POST", "https://example.test/v1/messages"),
- ),
- )
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- ):
- events = [event async for event in provider.stream_response(req)]
-
- assert [event.event for event in parse_sse_text("".join(events))] == [
- "message_start",
- "message_stop",
- ]
- assert response.is_closed
- mock_rate_limiter.execute_with_retry.assert_awaited_once()
-
-
-async def test_stream_maps_pre_start_non_200_to_provider_error_and_closes_response(
- provider_config,
-):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- response = FakeResponse(status_code=500, text="Internal Server Error")
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [event async for event in provider.stream_response(req, request_id="REQ_123")]
-
- assert response.is_closed
- assert "Upstream provider TEST_NATIVE returned HTTP 500." in exc_info.value.message
- assert "Internal Server Error" in exc_info.value.message
- assert "REQ_123" in exc_info.value.message
-
-
-async def test_native_http_close_failure_cannot_mask_mapped_status(provider_config):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- response = FakeResponse(
- status_code=400,
- text="original native HTTP body",
- close_error=RuntimeError("cleanup api_key=SECRET"),
- )
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [
- event
- async for event in provider.stream_response(
- req,
- request_id="req_native_http_close_failure",
- )
- ]
-
- assert response.close_calls == 1
- assert exc_info.value.kind is FailureKind.INVALID_REQUEST
- assert exc_info.value.status_code == 400
- assert "original native HTTP body" in exc_info.value.message
- assert "cleanup" not in exc_info.value.message
- assert "SECRET" not in exc_info.value.message
-
-
-async def test_precommit_native_error_raises_without_leaking_open_block(
- provider_config,
-):
- """A native error before holdback commit raises instead of sending HTTP 200 SSE."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- mid = "msg_midstream_err"
- msg_start = format_sse_event(
- "message_start",
- {
- "type": "message_start",
- "message": {
- "id": mid,
- "type": "message",
- "role": "assistant",
- "content": [],
- "model": "test-model",
- "stop_reason": None,
- "stop_sequence": None,
- "usage": {"input_tokens": 1, "output_tokens": 1},
- },
- },
- )
- block_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- )
- lines: list[str] = []
- for blob in (msg_start, block_start):
- lines.extend(blob.splitlines())
- response = FakeResponse(lines=lines, raise_after_line_index=len(lines) - 1)
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [e async for e in provider.stream_response(req)]
-
- assert "mid-stream failure" in exc_info.value.message
-
-
-async def test_native_upstream_error_event_retries_then_raises_canonical_failure(
- provider_config,
-):
- """Native wire errors become one semantic failure instead of leaking or masking."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- upstream_error = format_sse_event(
- "error",
- {
- "type": "error",
- "error": {
- "type": "rate_limit_error",
- "message": "native quota exhausted api_key=SECRET useful detail",
- },
- },
- )
- responses = [
- FakeResponse(lines=_lines_from_events(upstream_error))
- for _ in range(EARLY_TRANSPARENT_TOTAL_ATTEMPTS)
- ]
- events: list[str] = []
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=responses,
- ) as mock_send,
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- async for event in provider.stream_response(
- req,
- request_id="req_native_error",
- ):
- events.extend((event,))
-
- failure = exc_info.value
- assert mock_send.await_count == EARLY_TRANSPARENT_TOTAL_ATTEMPTS
- assert all(response.is_closed for response in responses)
- assert events == []
- assert failure.kind is FailureKind.RATE_LIMIT
- assert failure.status_code == 429
- assert failure.retryable
- assert "native quota exhausted" in failure.message
- assert "useful detail" in failure.message
- assert "api_key=<redacted>" in failure.message
- assert "SECRET" not in failure.message
- assert "Request ID: req_native_error" in failure.message
-
-
-async def test_native_stream_close_failure_cannot_mask_execution_failure(
- provider_config,
-):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- upstream_error = format_sse_event(
- "error",
- {
- "type": "error",
- "error": {
- "type": "invalid_request_error",
- "message": "original native provider failure",
- },
- },
- )
- response = FakeResponse(
- lines=_lines_from_events(upstream_error),
- close_error=RuntimeError("cleanup api_key=SECRET"),
- )
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [
- event
- async for event in provider.stream_response(
- req,
- request_id="req_native_close_failure",
- )
- ]
-
- assert response.close_calls == 1
- assert exc_info.value.kind is FailureKind.INVALID_REQUEST
- assert exc_info.value.status_code == 400
- assert "original native provider failure" in exc_info.value.message
- assert "cleanup" not in exc_info.value.message
- assert "SECRET" not in exc_info.value.message
-
-
-async def test_midstream_error_after_native_message_delta_raises_without_wire_terminal(
- provider_config,
-):
- """Providers preserve the committed prefix and leave terminal wire errors to API."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- msg_start = format_sse_event(
- "message_start",
- {
- "type": "message_start",
- "message": {
- "id": "msg_terminal_cutoff",
- "type": "message",
- "role": "assistant",
- "content": [],
- "model": "test-model",
- "stop_reason": None,
- "stop_sequence": None,
- "usage": {"input_tokens": 1, "output_tokens": 1},
- },
- },
- )
- block_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- )
- text_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "hello" + ("x" * 70_000)},
- },
- )
- block_stop = format_sse_event(
- "content_block_stop",
- {"type": "content_block_stop", "index": 0},
- )
- message_delta = format_sse_event(
- "message_delta",
- {
- "type": "message_delta",
- "delta": {"stop_reason": "end_turn", "stop_sequence": None},
- "usage": {"input_tokens": 1, "output_tokens": 2},
- },
- )
- response = FakeResponse(
- lines=_lines_from_events(
- msg_start, block_start, text_delta, block_stop, message_delta
- )
- )
-
- events: list[str] = []
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- patch.object(
- _AnthropicMessagesStreamRunner,
- "_collect_recovery_text",
- new_callable=AsyncMock,
- return_value=("hello recovered", ""),
- ) as mock_collect,
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- async for event in provider.stream_response(req):
- events.extend((event,))
-
- parsed = parse_sse_text("".join(events))
- assert mock_collect.await_count == 0
- assert "Provider stream ended without message_stop." in exc_info.value.message
- assert sum(event.event == "message_delta" for event in parsed) == 1
- assert sum(event.event == "message_stop" for event in parsed) == 0
- assert sum(event.event == "error" for event in parsed) == 0
- message_delta_index = next(
- index for index, event in enumerate(parsed) if event.event == "message_delta"
- )
- assert all(
- event.event
- not in {"content_block_start", "content_block_delta", "content_block_stop"}
- for event in parsed[message_delta_index + 1 :]
- )
-
-
-async def test_native_text_recovery_closes_thinking_before_text_suffix(
- provider_config,
-):
- """Recovery suffixes preserve Anthropic block ordering when switching types."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- runner = _AnthropicMessagesStreamRunner(
- provider,
- request=make_messages_request(),
- input_tokens=0,
- request_id="req_native_recovery",
- thinking_enabled=True,
- )
- ledger = AnthropicStreamLedger("msg_recovery", "test-model")
- ledger.start_thinking_block()
- ledger.emit_thinking_delta("thinking")
-
- with patch.object(
- runner,
- "_collect_recovery_text",
- new_callable=AsyncMock,
- return_value=("answer", "thinking more"),
- ) as mock_collect:
- events = await runner._recovery_events(
- body={"messages": []},
- ledger=ledger,
- error=TimeoutError("cutoff"),
- req_tag="",
- thinking_enabled=True,
- )
-
- assert events is not None
- assert mock_collect.await_args is not None
- recovery_body = mock_collect.await_args.args[0]
- assert "thinking" in recovery_body["messages"][-1]["content"]
- parsed = parse_sse_text("".join(events))
- assert [event.event for event in parsed] == [
- "content_block_delta",
- "content_block_stop",
- "content_block_start",
- "content_block_delta",
- "content_block_stop",
- "message_delta",
- "message_stop",
- ]
- assert parsed[0].data["index"] == 0
- assert parsed[1].data["index"] == 0
- assert parsed[2].data["index"] == 1
- assert parsed[2].data["content_block"]["type"] == "text"
- assert parsed[3].data["index"] == 1
-
-
-async def test_clean_eof_after_complete_native_tool_call_salvages_tool_use(
- provider_config,
-):
- """Native stream EOF after complete tool args gets a deterministic tool_use tail."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- msg_start = format_sse_event(
- "message_start",
- {
- "type": "message_start",
- "message": {
- "id": "msg_tool_eof",
- "type": "message",
- "role": "assistant",
- "content": [],
- "model": "test-model",
- "stop_reason": None,
- "stop_sequence": None,
- "usage": {"input_tokens": 1, "output_tokens": 1},
- },
- },
- )
- block_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {
- "type": "tool_use",
- "id": "toolu_eof",
- "name": "echo_smoke",
- "input": {},
- },
- },
- )
- args = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "input_json_delta", "partial_json": "{}"},
- },
- )
- lines: list[str] = []
- for blob in (msg_start, block_start, args):
- lines.extend(blob.splitlines())
- response = FakeResponse(lines=lines)
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- ):
- events = [e async for e in provider.stream_response(req)]
-
- parsed = parse_sse_text("".join(events))
- assert parsed[-1].event == "message_stop"
- assert any(
- event.event == "message_delta"
- and event.data.get("delta", {}).get("stop_reason") == "tool_use"
- for event in parsed
- )
- assert not any(event.event == "error" for event in parsed)
-
-
-async def test_clean_eof_after_native_text_continues_with_overlap_trim(
- provider_config,
-):
- """Native text truncation is continued and overlap-trimmed."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- msg_start = format_sse_event(
- "message_start",
- {
- "type": "message_start",
- "message": {
- "id": "msg_text_eof",
- "type": "message",
- "role": "assistant",
- "content": [],
- "model": "test-model",
- "stop_reason": None,
- "stop_sequence": None,
- "usage": {"input_tokens": 1, "output_tokens": 1},
- },
- },
- )
- block_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- )
- text_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "hello wor"},
- },
- )
- lines: list[str] = []
- for blob in (msg_start, block_start, text_delta):
- lines.extend(blob.splitlines())
- response = FakeResponse(lines=lines)
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- patch.object(
- _AnthropicMessagesStreamRunner,
- "_collect_recovery_text",
- new_callable=AsyncMock,
- return_value=("world", ""),
- ),
- ):
- events = [e async for e in provider.stream_response(req)]
-
- parsed = parse_sse_text("".join(events))
- text_deltas = [
- event.data.get("delta", {}).get("text", "")
- for event in parsed
- if event.event == "content_block_delta"
- ]
- assert text_deltas == ["hello wor", "ld"]
- assert "".join(text_deltas) == "hello world"
- assert any(
- event.event == "message_delta"
- and event.data.get("delta", {}).get("stop_reason") == "end_turn"
- for event in parsed
- )
- assert not any(event.event == "error" for event in parsed)
-
-
-async def test_native_recovery_collect_text_requires_message_stop(provider_config):
- """Native recovery collectors reject truncated continuation streams."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- text_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "world"},
- },
- )
-
- async def _iter_chunks(_response, *, state, thinking_enabled):
- yield text_delta
-
- runner = _AnthropicMessagesStreamRunner(
- provider,
- request=make_messages_request(),
- input_tokens=0,
- request_id=None,
- thinking_enabled=True,
- )
-
- with (
- patch.object(runner, "_iter_stream_chunks", _iter_chunks),
- patch.object(
- provider,
- "_validated_stream_send",
- new_callable=AsyncMock,
- return_value=FakeResponse(),
- ) as mock_send,
- pytest.raises(TruncatedProviderStreamError),
- ):
- await runner._collect_recovery_text(
- {"messages": []},
- req_tag="",
- thinking_enabled=True,
- )
-
- assert mock_send.await_count == MIDSTREAM_RECOVERY_ATTEMPTS
-
-
-async def test_native_recovery_collect_text_accepts_message_stop(provider_config):
- """Native recovery collectors return text only after message_stop."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- text_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "world"},
- },
- )
- message_stop = format_sse_event("message_stop", {"type": "message_stop"})
-
- async def _iter_chunks(_response, *, state, thinking_enabled):
- yield text_delta
- yield message_stop
-
- runner = _AnthropicMessagesStreamRunner(
- provider,
- request=make_messages_request(),
- input_tokens=0,
- request_id=None,
- thinking_enabled=True,
- )
-
- with (
- patch.object(runner, "_iter_stream_chunks", _iter_chunks),
- patch.object(
- provider,
- "_validated_stream_send",
- new_callable=AsyncMock,
- return_value=FakeResponse(),
- ),
- ):
- result = await runner._collect_recovery_text(
- {"messages": []}, req_tag="", thinking_enabled=True
- )
-
- assert result == ("world", "")
-
-
-async def test_native_recovery_collect_text_reads_eager_start_content(provider_config):
- """Native recovery reads text/thinking carried on content_block_start."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- text_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": "hello"},
- },
- )
- thinking_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 1,
- "content_block": {"type": "thinking", "thinking": "step"},
- },
- )
- text_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": " world"},
- },
- )
- thinking_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 1,
- "delta": {"type": "thinking_delta", "thinking": " two"},
- },
- )
- message_stop = format_sse_event("message_stop", {"type": "message_stop"})
-
- async def _iter_chunks(_response, *, state, thinking_enabled):
- yield text_start
- yield thinking_start
- yield text_delta
- yield thinking_delta
- yield message_stop
-
- runner = _AnthropicMessagesStreamRunner(
- provider,
- request=make_messages_request(),
- input_tokens=0,
- request_id=None,
- thinking_enabled=True,
- )
-
- with (
- patch.object(runner, "_iter_stream_chunks", _iter_chunks),
- patch.object(
- provider,
- "_validated_stream_send",
- new_callable=AsyncMock,
- return_value=FakeResponse(),
- ),
- ):
- result = await runner._collect_recovery_text(
- {"messages": []}, req_tag="", thinking_enabled=True
- )
-
- assert result == ("hello world", "step two")
-
-
-async def test_truncated_native_recovery_stream_raises_after_closing_block(
- provider_config,
-):
- """Partial native recovery bytes are not converted into a success tail."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- msg_start = format_sse_event(
- "message_start",
- {
- "type": "message_start",
- "message": {
- "id": "msg_text_eof",
- "type": "message",
- "role": "assistant",
- "content": [],
- "model": "test-model",
- "stop_reason": None,
- "stop_sequence": None,
- "usage": {"input_tokens": 1, "output_tokens": 1},
- },
- },
- )
- block_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- )
- original_text = "hello wor" + ("x" * 70_000)
- original_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": original_text},
- },
- )
- recovery_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "world"},
- },
- )
- original = FakeResponse(
- lines=_lines_from_events(msg_start, block_start, original_delta)
- )
- recovery_responses = [
- FakeResponse(lines=_lines_from_events(recovery_delta))
- for _ in range(MIDSTREAM_RECOVERY_ATTEMPTS)
- ]
-
- events: list[str] = []
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=[original, *recovery_responses],
- ) as mock_send,
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- async for event in provider.stream_response(req):
- events.extend((event,))
-
- event_text = "".join(events)
- assert mock_send.await_count == 1 + MIDSTREAM_RECOVERY_ATTEMPTS
- assert original_text in event_text
- assert "world" not in event_text
- assert "Provider stream ended without message_stop." in exc_info.value.message
- assert "Provider stream ended without message_stop." not in event_text
- parsed = parse_sse_text(event_text)
- assert parsed[-1].event == "content_block_stop"
- assert not any(event.event == "error" for event in parsed)
- assert not any(event.event == "message_stop" for event in parsed)
- assert not any(
- event.event == "content_block_delta"
- and event.data.get("delta", {}).get("text") == "ld"
- for event in parse_sse_text(event_text)
- )
-
-
-async def test_precommit_native_holdback_retries_without_leaking_partial(
- provider_config,
-):
- """A retryable early cutoff before holdback commit is retried invisibly."""
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
-
- msg_start = format_sse_event(
- "message_start",
- {
- "type": "message_start",
- "message": {
- "id": "msg_holdback",
- "type": "message",
- "role": "assistant",
- "content": [],
- "model": "test-model",
- "stop_reason": None,
- "stop_sequence": None,
- "usage": {"input_tokens": 1, "output_tokens": 1},
- },
- },
- )
- block_start = format_sse_event(
- "content_block_start",
- {
- "type": "content_block_start",
- "index": 0,
- "content_block": {"type": "text", "text": ""},
- },
- )
- hidden_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "hidden"},
- },
- )
- visible_delta = format_sse_event(
- "content_block_delta",
- {
- "type": "content_block_delta",
- "index": 0,
- "delta": {"type": "text_delta", "text": "visible"},
- },
- )
- block_stop = format_sse_event(
- "content_block_stop",
- {"type": "content_block_stop", "index": 0},
- )
- message_delta = format_sse_event(
- "message_delta",
- {
- "type": "message_delta",
- "delta": {"stop_reason": "end_turn", "stop_sequence": None},
- "usage": {"input_tokens": 1, "output_tokens": 1},
- },
- )
- message_stop = format_sse_event("message_stop", {"type": "message_stop"})
- first_lines = _lines_from_events(msg_start, block_start, hidden_delta)
- first = FakeResponse(
- lines=first_lines,
- raise_after_line_index=len(first_lines) - 1,
- raise_error=httpx.ReadError("early cutoff"),
- )
- second = FakeResponse(
- lines=_lines_from_events(
- msg_start,
- block_start,
- visible_delta,
- block_stop,
- message_delta,
- message_stop,
- ),
- )
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=[first, second],
- ) as mock_send,
- ):
- events = [e async for e in provider.stream_response(req)]
-
- event_text = "".join(events)
- assert mock_send.await_count == 2
- assert "hidden" not in event_text
- assert "visible" in event_text
- assert parse_sse_text(event_text)[-1].event == "message_stop"
diff --git a/tests/providers/test_anthropic_messages_429_retry.py b/tests/providers/test_anthropic_messages_429_retry.py
deleted file mode 100644
index 05e41453..00000000
--- a/tests/providers/test_anthropic_messages_429_retry.py
+++ /dev/null
@@ -1,280 +0,0 @@
-"""Native Anthropic transport: HTTP 429 and upstream 5xx are retried inside execute_with_retry."""
-
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import httpx
-import pytest
-
-from free_claude_code.core.anthropic.stream_contracts import event_names, parse_sse_text
-from free_claude_code.core.failures import ExecutionFailure
-from free_claude_code.providers.base import ProviderConfig
-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,
- NativeProvider,
-)
-
-
-def _assert_minimal_success_stream(events: list[str]) -> None:
- assert event_names(parse_sse_text("".join(events))) == [
- "message_start",
- "message_stop",
- ]
-
-
-def provider_config():
- return ProviderConfig(
- api_key="test-key",
- base_url="https://custom.test/v1/",
- rate_limit=100,
- rate_window=60,
- http_read_timeout=600.0,
- http_write_timeout=15.0,
- http_connect_timeout=5.0,
- )
-
-
-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 = make_messages_request()
- request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
- ok_lines = [
- "event: message_start",
- 'data: {"type":"message_start"}',
- "",
- "event: message_stop",
- 'data: {"type":"message_stop"}',
- "",
- ]
- ok_response = FakeResponse(lines=ok_lines)
- too_many = FakeResponse(status_code=429, text="rate limited")
-
- send_calls = {"n": 0}
-
- async def send_side_effect(*_a, **_kw):
- send_calls["n"] += 1
- if send_calls["n"] == 1:
- return too_many
- return ok_response
-
- with (
- patch.object(provider._client, "build_request", return_value=request_obj),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=send_side_effect,
- ),
- patch(
- "asyncio.sleep",
- new_callable=AsyncMock,
- ),
- ):
- events = [e async for e in provider.stream_response(req)]
-
- assert send_calls["n"] == 2
- assert too_many.is_closed
- assert ok_response.is_closed
- _assert_minimal_success_stream(events)
-
-
[email protected]("status_code", [500, 502, 503, 504])
-async def test_native_stream_retries_on_http_5xx_then_streams(
- provider_config, status_code
-):
- """First response is retryable 5xx (closed); second 200 streams; send twice."""
- provider = NativeProvider(provider_config, rate_limiter=retrying_rate_limiter())
- req = make_messages_request()
- request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
- ok_lines = [
- "event: message_start",
- 'data: {"type":"message_start"}',
- "",
- "event: message_stop",
- 'data: {"type":"message_stop"}',
- "",
- ]
- ok_response = FakeResponse(lines=ok_lines)
- bad = FakeResponse(status_code=status_code, text="upstream error")
-
- send_calls = {"n": 0}
-
- async def send_side_effect(*_a, **_kw):
- send_calls["n"] += 1
- if send_calls["n"] == 1:
- return bad
- return ok_response
-
- with (
- patch.object(provider._client, "build_request", return_value=request_obj),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=send_side_effect,
- ),
- patch(
- "asyncio.sleep",
- new_callable=AsyncMock,
- ),
- ):
- events = [e async for e in provider.stream_response(req)]
-
- assert send_calls["n"] == 2
- assert bad.is_closed
- assert ok_response.is_closed
- _assert_minimal_success_stream(events)
-
-
-async def test_native_stream_retries_on_pre_send_connection_error_then_streams(
- provider_config,
-):
- """Pre-response HTTPX transport errors retry through execute_with_retry."""
- provider = NativeProvider(provider_config, rate_limiter=retrying_rate_limiter())
- req = make_messages_request()
- request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
- ok_lines = [
- "event: message_start",
- 'data: {"type":"message_start"}',
- "",
- "event: message_stop",
- 'data: {"type":"message_stop"}',
- "",
- ]
- ok_response = FakeResponse(lines=ok_lines)
-
- send_calls = {"n": 0}
-
- async def send_side_effect(*_a, **_kw):
- send_calls["n"] += 1
- if send_calls["n"] == 1:
- raise httpx.ConnectError("connect failed", request=request_obj)
- return ok_response
-
- with (
- patch.object(provider._client, "build_request", return_value=request_obj),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=send_side_effect,
- ),
- patch("asyncio.sleep", new_callable=AsyncMock),
- ):
- events = [e async for e in provider.stream_response(req)]
-
- assert send_calls["n"] == 2
- assert ok_response.is_closed
- _assert_minimal_success_stream(events)
-
-
- ("status_code", "substr"),
- [
- (500, "Provider API request failed"),
- (502, "Provider is currently overloaded"),
- (503, "Provider is currently overloaded"),
- (504, "Provider is currently overloaded"),
- ],
-)
-async def test_native_stream_5xx_retry_exhausted(provider_config, status_code, substr):
- """Repeated upstream 5xx exhausts execute_with_retry; user message matches mapping."""
-
- provider = NativeProvider(
- provider_config,
- rate_limiter=retrying_rate_limiter(),
- )
- req = make_messages_request()
-
- bad = FakeResponse(status_code=status_code, text="upstream error")
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=bad,
- ) as mock_send,
- patch("asyncio.sleep", new_callable=AsyncMock),
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [e async for e in provider.stream_response(req)]
-
- assert mock_send.await_count == 5
- assert bad.is_closed
- assert substr in exc_info.value.message
-
-
-async def test_native_stream_connection_error_retry_exhausted(provider_config):
- """Repeated pre-response connection failures exhaust at 5 attempts."""
-
- provider = NativeProvider(
- provider_config,
- rate_limiter=retrying_rate_limiter(),
- )
- req = make_messages_request()
- request_obj = httpx.Request("POST", "https://custom.test/v1/messages")
-
- with (
- patch.object(provider._client, "build_request", return_value=request_obj),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=httpx.ConnectError("connect failed", request=request_obj),
- ) as mock_send,
- patch("asyncio.sleep", new_callable=AsyncMock),
- patch(
- "free_claude_code.providers.transports.anthropic_messages.transport.trace_event"
- ) as trace,
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [e async for e in provider.stream_response(req, request_id="req_native_conn")]
-
- assert mock_send.await_count == 5
- error_traces = [
- call.kwargs
- for call in trace.call_args_list
- if call.kwargs.get("event") == "provider.response.error"
- ]
- assert error_traces[-1]["request_id"] == "req_native_conn"
- assert error_traces[-1]["exc_type"] == "ConnectError"
- assert "error_message" not in error_traces[-1]
- assert "Provider exception:\nconnect failed" in exc_info.value.message
-
-
-async def test_non_retryable_4xx_http_error_not_retried(provider_config):
- """HTTP 400 from upstream is not retried; single send (passthrough limiter)."""
-
- provider = NativeProvider(
- provider_config,
- rate_limiter=retrying_rate_limiter(),
- )
- req = make_messages_request()
- err = FakeResponse(status_code=400, text="Bad Request")
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=err,
- ) as mock_send,
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [e async for e in provider.stream_response(req)]
-
- mock_send.assert_awaited_once()
- assert err.is_closed
- assert "Invalid request sent to provider" in exc_info.value.message
diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.py
index e9d37132..e1832c0f 100644
--- a/tests/providers/test_llamacpp.py
+++ b/tests/providers/test_llamacpp.py
@@ -1,13 +1,11 @@
-"""Tests for Llama.cpp native Anthropic provider."""
+"""Tests for the llama.cpp OpenAI-compatible provider."""
from unittest.mock import AsyncMock, MagicMock, patch
-import httpx
import pytest
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.core.failures import ExecutionFailure
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.llamacpp import LlamaCppProvider
from tests.providers.request_factory import make_messages_request
@@ -16,287 +14,72 @@ from tests.providers.support import passthrough_rate_limiter
LLAMACPP_MODEL = "llamacpp-community/qwen2.5-7b-instruct"
-async def _minimal_native_lines():
- yield "event: message_start"
- yield 'data: {"type":"message_start"}'
- yield ""
- yield "event: message_stop"
- yield 'data: {"type":"message_stop"}'
- yield ""
-
-
@pytest.fixture
-def llamacpp_config():
- return ProviderConfig(
- api_key="llamacpp",
- base_url="http://localhost:8080/v1",
- rate_limit=10,
- rate_window=60,
+def provider() -> LlamaCppProvider:
+ return LlamaCppProvider(
+ ProviderConfig(api_key="llamacpp", base_url="http://localhost:8080/v1"),
+ rate_limiter=passthrough_rate_limiter(),
)
-def llamacpp_provider(llamacpp_config):
- return LlamaCppProvider(llamacpp_config, rate_limiter=passthrough_rate_limiter())
-
-
-def test_init(llamacpp_config):
- """Test provider initialization."""
- with patch("httpx.AsyncClient"):
+ ("configured", "expected"),
+ [
+ (None, "http://localhost:8080/v1"),
+ ("http://localhost:8080", "http://localhost:8080/v1"),
+ ("http://localhost:8080/", "http://localhost:8080/v1"),
+ ("http://localhost:8080/v1", "http://localhost:8080/v1"),
+ ("http://localhost:8080/v1/", "http://localhost:8080/v1"),
+ ],
+)
+def test_init_normalizes_openai_base_url(configured: str | None, expected: str) -> None:
+ with patch(
+ "free_claude_code.providers.transports.openai_chat.transport.AsyncOpenAI"
+ ) as openai_client:
provider = LlamaCppProvider(
- llamacpp_config, rate_limiter=passthrough_rate_limiter()
+ ProviderConfig(api_key="", base_url=configured),
+ rate_limiter=passthrough_rate_limiter(),
)
- assert provider._base_url == "http://localhost:8080/v1"
- assert provider._provider_name == "LLAMACPP"
+
+ assert provider._base_url == expected
+ assert openai_client.call_args.kwargs["base_url"] == expected
-def test_init_uses_configurable_timeouts():
- """Test that provider passes configurable read/write/connect timeouts to client."""
+def test_init_uses_openai_chat_client() -> None:
config = ProviderConfig(
- api_key="llamacpp",
- base_url="http://localhost:8080/v1",
+ api_key="",
+ base_url="http://localhost:8080/v1/",
http_read_timeout=600.0,
http_write_timeout=15.0,
http_connect_timeout=5.0,
)
- with patch("httpx.AsyncClient") as mock_client:
- LlamaCppProvider(config, rate_limiter=passthrough_rate_limiter())
- call_kwargs = mock_client.call_args[1]
- timeout = call_kwargs["timeout"]
- assert timeout.read == 600.0
- assert timeout.write == 15.0
- assert timeout.connect == 5.0
-
-
-def test_init_base_url_strips_trailing_slash():
- """Config with base_url trailing slash is stored without it."""
- config = ProviderConfig(
- api_key="llamacpp",
- base_url="http://localhost:8080/v1/",
- rate_limit=10,
- rate_window=60,
- )
- with patch("httpx.AsyncClient"):
+ with patch(
+ "free_claude_code.providers.transports.openai_chat.transport.AsyncOpenAI"
+ ) as openai_client:
provider = LlamaCppProvider(config, rate_limiter=passthrough_rate_limiter())
- assert provider._base_url == "http://localhost:8080/v1"
-
-
-async def test_stream_response_omits_thinking_when_globally_disabled(llamacpp_config):
- provider = LlamaCppProvider(
- llamacpp_config.model_copy(update={"enable_thinking": False}),
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request(LLAMACPP_MODEL)
-
- mock_response = MagicMock()
- mock_response.status_code = 200
-
- mock_response.aiter_lines = _minimal_native_lines
-
- with (
- patch.object(provider._client, "build_request") as mock_build,
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=mock_response,
- ),
- ):
- [e async for e in provider.stream_response(req)]
-
- _, kwargs = mock_build.call_args
- assert "thinking" not in kwargs["json"]
-
-
-async def test_stream_response(llamacpp_provider):
- """Test streaming native Anthropic response."""
- req = make_messages_request(LLAMACPP_MODEL)
-
- mock_response = MagicMock()
- mock_response.status_code = 200
-
- async def mock_aiter_lines():
- yield "event: message_start"
- yield 'data: {"type":"message_start","message":{}}'
- yield ""
- yield "event: content_block_delta"
- yield 'data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"Hello World"}}'
- yield ""
- yield "event: message_stop"
- yield 'data: {"type":"message_stop"}'
- yield ""
-
- mock_response.aiter_lines = mock_aiter_lines
-
- with (
- patch.object(
- llamacpp_provider._client, "build_request", return_value=MagicMock()
- ) as mock_build,
- patch.object(
- llamacpp_provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=mock_response,
- ),
- ):
- events = [e async for e in llamacpp_provider.stream_response(req)]
-
- # Verify request construction
- mock_build.assert_called_once()
- args, kwargs = mock_build.call_args
- assert args[0] == "POST"
- assert args[1] == "/messages"
- assert kwargs["json"]["model"] == "llamacpp-community/qwen2.5-7b-instruct"
- # Verify internal fields are popped
- assert "extra_body" not in kwargs["json"]
- assert kwargs["json"]["max_tokens"] == 100
-
- # Verify internal ThinkingConfig is mapped to Anthropic API format
- assert kwargs["json"]["thinking"] == {"type": "enabled"}
-
- assert [event.event for event in parse_sse_text("".join(events))] == [
- "message_start",
- "content_block_delta",
- "message_stop",
- ]
- assert "Hello World" in "".join(events)
-
-
-async def test_stream_response_adds_max_tokens_if_missing(llamacpp_provider):
- """Fallback max_tokens to 81920 if not present."""
- 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(llamacpp_provider._client, "build_request") as mock_build,
- patch.object(
- llamacpp_provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=mock_response,
- ),
- ):
- # Just run the generator to completion
- [e async for e in llamacpp_provider.stream_response(req)]
+ assert provider._provider_name == "LLAMACPP"
+ assert provider._base_url == "http://localhost:8080/v1"
+ assert provider._api_key == "llamacpp"
+ timeout = openai_client.call_args.kwargs["timeout"]
+ assert (timeout.read, timeout.write, timeout.connect) == (600.0, 15.0, 5.0)
- _, kwargs = mock_build.call_args
- assert kwargs["json"]["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+def test_build_request_body_uses_openai_chat_shape(provider: LlamaCppProvider) -> None:
+ request = make_messages_request(LLAMACPP_MODEL, max_tokens=None)
-async def test_stream_error_status_code(llamacpp_provider):
- """Pre-start non-200 status code raises for API-level non-200 handling."""
- req = make_messages_request(LLAMACPP_MODEL)
-
- mock_response = MagicMock()
- mock_response.status_code = 500
- mock_response.aread = AsyncMock(return_value=b"Internal Server Error")
- mock_response.raise_for_status = MagicMock(
- side_effect=httpx.HTTPStatusError(
- "Internal Server Error", request=MagicMock(), response=mock_response
- )
- )
-
- with (
- patch.object(
- llamacpp_provider._client, "build_request", return_value=MagicMock()
- ),
- patch.object(
- llamacpp_provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=mock_response,
- ),
- ):
- with pytest.raises(ExecutionFailure) as exc_info:
- [
- e
- async for e in llamacpp_provider.stream_response(
- req, request_id="TEST_ID"
- )
- ]
-
- assert "Provider API request failed" in exc_info.value.message
- assert "TEST_ID" in exc_info.value.message
-
-
-async def test_stream_network_error(llamacpp_provider):
- """Pre-start network errors raise for API-level non-200 handling."""
- req = make_messages_request(LLAMACPP_MODEL)
-
- with (
- patch.object(
- llamacpp_provider._client, "build_request", return_value=MagicMock()
- ),
- patch.object(
- llamacpp_provider._client,
- "send",
- new_callable=AsyncMock,
- side_effect=httpx.ConnectError("Connection refused"),
- ),
- ):
- with pytest.raises(ExecutionFailure) as exc_info:
- [
- e
- async for e in llamacpp_provider.stream_response(
- req, request_id="TEST_ID2"
- )
- ]
-
- assert "Could not connect to provider." in exc_info.value.message
- assert "Provider exception" in exc_info.value.message
- assert "Connection refused" in exc_info.value.message
- assert "TEST_ID2" in exc_info.value.message
-
+ body = provider._build_request_body(request)
-async def test_stream_error_405_mentions_upstream_provider(llamacpp_provider):
- req = make_messages_request(LLAMACPP_MODEL)
+ assert body["model"] == LLAMACPP_MODEL
+ assert body["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+ assert body["messages"][0]["role"] == "system"
+ assert "thinking" not in body
- mock_response = MagicMock()
- mock_response.status_code = 405
- mock_response.aread = AsyncMock(return_value=b"Method Not Allowed")
- mock_response.raise_for_status = MagicMock(
- side_effect=httpx.HTTPStatusError(
- "Method Not Allowed", request=MagicMock(), response=mock_response
- )
- )
- with (
- patch.object(
- llamacpp_provider._client, "build_request", return_value=MagicMock()
- ),
- patch.object(
- llamacpp_provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=mock_response,
- ),
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [e async for e in llamacpp_provider.stream_response(req, request_id="REQ405")]
-
- assert (
- "Upstream provider LLAMACPP rejected the request method or endpoint (HTTP 405)."
- in exc_info.value.message
- )
- assert "REQ405" in exc_info.value.message
-
-
-def test_build_request_body_disabled_thinking_strips_native_thinking_history(
- llamacpp_config,
-):
- """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())
- req = make_messages_request(
+def test_disabled_thinking_does_not_replay_assistant_reasoning(
+ provider: LlamaCppProvider,
+) -> None:
+ request = make_messages_request(
LLAMACPP_MODEL,
system=None,
messages=[
@@ -304,14 +87,55 @@ def test_build_request_body_disabled_thinking_strips_native_thinking_history(
{
"role": "assistant",
"content": [
- {"type": "thinking", "thinking": "p"},
- {"type": "redacted_thinking", "data": "ZGF0YQ=="},
+ {"type": "thinking", "thinking": "private", "signature": "s"},
+ {"type": "text", "text": "visible"},
],
},
],
)
- body = provider._build_request_body(req, thinking_enabled=False)
- asst = body["messages"][1]
- assert asst["content"] == ""
- assert "thinking" not in str(body)
- assert "redacted_thinking" not in str(body)
+
+ body = provider._build_request_body(request, thinking_enabled=False)
+
+ assert "private" not in str(body)
+ assert "visible" in str(body)
+
+
+async def test_stream_response_uses_shared_openai_chat_transport(
+ provider: LlamaCppProvider,
+) -> None:
+ chunk = MagicMock()
+ chunk.choices = [
+ MagicMock(
+ delta=MagicMock(
+ content="Hello from llama.cpp",
+ reasoning_content=None,
+ tool_calls=None,
+ ),
+ finish_reason="stop",
+ )
+ ]
+ chunk.usage = MagicMock(prompt_tokens=8, completion_tokens=4)
+
+ async def stream():
+ yield chunk
+
+ with patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream(),
+ ) as create:
+ output = "".join(
+ [
+ event
+ async for event in provider.stream_response(
+ make_messages_request(LLAMACPP_MODEL)
+ )
+ ]
+ )
+
+ assert create.call_args.kwargs["stream"] is True
+ assert create.call_args.kwargs["model"] == LLAMACPP_MODEL
+ assert "Hello from llama.cpp" in output
+ assert parse_sse_text(output)[-1].event == "message_stop"
diff --git a/tests/providers/test_model_validation.py b/tests/providers/test_model_validation.py
index 1a195eab..04e229db 100644
--- a/tests/providers/test_model_validation.py
+++ b/tests/providers/test_model_validation.py
@@ -4,7 +4,6 @@ from types import SimpleNamespace
from typing import Any
from unittest.mock import AsyncMock, patch
-import httpx
import pytest
from free_claude_code.application.errors import ApplicationUnavailableError
@@ -64,14 +63,6 @@ def _manager(
)
-def _response(status_code: int, payload: object) -> httpx.Response:
- return httpx.Response(
- status_code,
- json=payload,
- request=httpx.Request("GET", "https://example.test/models"),
- )
-
-
@pytest.mark.asyncio
async def test_nim_lists_openai_compatible_model_ids() -> None:
config = ProviderConfig(api_key="test-key")
@@ -92,20 +83,31 @@ async def test_nim_lists_openai_compatible_model_ids() -> None:
@pytest.mark.asyncio
-async def test_native_anthropic_messages_provider_lists_model_ids() -> None:
- provider = LlamaCppProvider(
- ProviderConfig(api_key="llamacpp", base_url="http://localhost:8080/v1"),
- rate_limiter=passthrough_rate_limiter(),
- )
+ "provider",
+ [
+ LlamaCppProvider(
+ ProviderConfig(api_key="llamacpp", base_url="http://localhost:8080/v1"),
+ rate_limiter=passthrough_rate_limiter(),
+ ),
+ OllamaProvider(
+ ProviderConfig(api_key="ollama", base_url="http://localhost:11434"),
+ rate_limiter=passthrough_rate_limiter(),
+ ),
+ ],
+)
+async def test_local_openai_chat_providers_list_model_ids(
+ provider: LlamaCppProvider | OllamaProvider,
+) -> None:
with patch.object(
- provider._client,
- "get",
+ provider._client.models,
+ "list",
new_callable=AsyncMock,
- return_value=_response(200, {"data": [{"id": "local/model"}]}),
- ) as mock_get:
+ return_value=SimpleNamespace(data=[SimpleNamespace(id="local/model")]),
+ ) as mock_list:
assert await provider.list_model_ids() == frozenset({"local/model"})
- mock_get.assert_awaited_once_with("/models", headers={})
+ mock_list.assert_awaited_once_with()
@pytest.mark.asyncio
@@ -256,33 +258,6 @@ async def test_openrouter_model_metadata_rejects_malformed_ids() -> None:
await provider.list_model_infos()
-async def test_ollama_lists_native_tag_model_ids() -> None:
- provider = OllamaProvider(
- ProviderConfig(api_key="ollama", base_url="http://localhost:11434"),
- rate_limiter=passthrough_rate_limiter(),
- )
- with patch.object(
- provider._client,
- "get",
- new_callable=AsyncMock,
- return_value=_response(
- 200,
- {
- "models": [
- {"name": "llama3.1:latest", "model": "llama3.1:latest"},
- {"name": "qwen3"},
- ]
- },
- ),
- ) as mock_get:
- assert await provider.list_model_ids() == frozenset(
- {"llama3.1:latest", "qwen3"}
- )
-
- mock_get.assert_awaited_once_with("http://localhost:11434/api/tags")
-
-
@pytest.mark.asyncio
async def test_model_listing_rejects_malformed_payload() -> None:
provider = LlamaCppProvider(
@@ -291,10 +266,10 @@ async def test_model_listing_rejects_malformed_payload() -> None:
)
with (
patch.object(
- provider._client,
- "get",
+ provider._client.models,
+ "list",
new_callable=AsyncMock,
- return_value=_response(200, {"data": [{}]}),
+ return_value=SimpleNamespace(data=[SimpleNamespace()]),
),
pytest.raises(ModelListResponseError, match="malformed"),
):
@@ -302,19 +277,19 @@ async def test_model_listing_rejects_malformed_payload() -> None:
@pytest.mark.asyncio
-async def test_model_listing_raises_http_status_errors() -> None:
+async def test_model_listing_propagates_upstream_errors() -> None:
provider = LlamaCppProvider(
ProviderConfig(api_key="llamacpp", base_url="http://localhost:8080/v1"),
rate_limiter=passthrough_rate_limiter(),
)
with (
patch.object(
- provider._client,
- "get",
+ provider._client.models,
+ "list",
new_callable=AsyncMock,
- return_value=_response(503, {"error": "down"}),
+ side_effect=RuntimeError("upstream unavailable"),
),
- pytest.raises(httpx.HTTPStatusError),
+ pytest.raises(RuntimeError, match="upstream unavailable"),
):
await provider.list_model_ids()
diff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.py
index 559b0c9b..42c315d0 100644
--- a/tests/providers/test_ollama.py
+++ b/tests/providers/test_ollama.py
@@ -1,12 +1,10 @@
-"""Tests for Ollama native Anthropic provider."""
+"""Tests for the Ollama OpenAI-compatible provider."""
from unittest.mock import AsyncMock, MagicMock, patch
-import httpx
import pytest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
-from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.ollama import OLLAMA_DEFAULT_BASE, OllamaProvider
from tests.providers.request_factory import make_messages_request
@@ -15,214 +13,78 @@ from tests.providers.support import passthrough_rate_limiter
OLLAMA_MODEL = "llama3.1:8b"
-def ollama_config():
- return ProviderConfig(
- api_key="ollama",
- base_url="http://localhost:11434",
- rate_limit=10,
- rate_window=60,
- )
-
-
-def ollama_provider(ollama_config):
- return OllamaProvider(ollama_config, rate_limiter=passthrough_rate_limiter())
-
-
-def test_init(ollama_config):
- """Test provider initialization."""
- with patch("httpx.AsyncClient"):
- provider = OllamaProvider(
- ollama_config, rate_limiter=passthrough_rate_limiter()
- )
- assert provider._base_url == "http://localhost:11434"
- assert provider._provider_name == "OLLAMA"
- assert provider._api_key == "ollama"
-
-
-def test_init_uses_default_base_url():
- """Test that provider uses default root URL when not configured."""
- config = ProviderConfig(api_key="ollama", base_url=None)
- with patch("httpx.AsyncClient"):
- provider = OllamaProvider(config, rate_limiter=passthrough_rate_limiter())
- assert provider._base_url == OLLAMA_DEFAULT_BASE
-
-
-def test_init_uses_configurable_timeouts():
- """Test that provider passes configurable read/write/connect timeouts to client."""
- config = ProviderConfig(
- api_key="ollama",
- base_url="http://localhost:11434",
- http_read_timeout=600.0,
- http_write_timeout=15.0,
- http_connect_timeout=5.0,
- )
- with patch("httpx.AsyncClient") as mock_client:
- OllamaProvider(config, rate_limiter=passthrough_rate_limiter())
- call_kwargs = mock_client.call_args[1]
- timeout = call_kwargs["timeout"]
- assert timeout.read == 600.0
- assert timeout.write == 15.0
- assert timeout.connect == 5.0
-
-
-def test_init_base_url_strips_trailing_slash():
- """Config with base_url trailing slash is stored without it."""
- config = ProviderConfig(
- api_key="ollama",
- base_url="http://localhost:11434/",
- rate_limit=10,
- rate_window=60,
- )
- with patch("httpx.AsyncClient"):
- provider = OllamaProvider(config, rate_limiter=passthrough_rate_limiter())
- assert provider._base_url == "http://localhost:11434"
-
-
-def test_init_uses_default_api_key():
- """Test that provider uses default API key when not configured."""
- config = ProviderConfig(
- base_url="http://localhost:11434",
- api_key="",
- rate_limit=10,
- rate_window=60,
- )
- with patch("httpx.AsyncClient"):
- provider = OllamaProvider(config, rate_limiter=passthrough_rate_limiter())
- assert provider._api_key == "ollama"
-
-
-async def test_stream_response(ollama_provider):
- """Test streaming native Anthropic response."""
- req = make_messages_request(OLLAMA_MODEL)
-
- mock_response = MagicMock()
- mock_response.status_code = 200
-
- async def mock_aiter_lines():
- yield "event: message_start"
- yield 'data: {"type":"message_start","message":{}}'
- yield ""
- yield "event: content_block_delta"
- yield 'data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"Hello World"}}'
- yield ""
- yield "event: message_stop"
- yield 'data: {"type":"message_stop"}'
- yield ""
-
- mock_response.aiter_lines = mock_aiter_lines
-
- with (
- patch.object(
- ollama_provider._client, "build_request", return_value=MagicMock()
- ) as mock_build,
- patch.object(
- ollama_provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=mock_response,
- ),
- ):
- events = [event async for event in ollama_provider.stream_response(req)]
-
- mock_build.assert_called_once()
- args, kwargs = mock_build.call_args
- assert args[0] == "POST"
- assert args[1] == "/v1/messages"
- assert kwargs["json"]["model"] == "llama3.1:8b"
- assert kwargs["json"]["stream"] is True
- assert "extra_body" not in kwargs["json"]
- assert kwargs["json"]["thinking"] == {"type": "enabled"}
- assert [event.event for event in parse_sse_text("".join(events))] == [
- "message_start",
- "content_block_delta",
- "message_stop",
- ]
- assert "Hello World" in "".join(events)
-
-
-async def test_build_request_body_omits_thinking_when_disabled(ollama_config):
- """Global disable suppresses provider-side thinking."""
- provider = OllamaProvider(
- ollama_config.model_copy(update={"enable_thinking": False}),
+def _provider(base_url: str | None = OLLAMA_DEFAULT_BASE) -> OllamaProvider:
+ return OllamaProvider(
+ ProviderConfig(api_key="", base_url=base_url),
rate_limiter=passthrough_rate_limiter(),
)
- req = make_messages_request(OLLAMA_MODEL)
- body = provider._build_request_body(req)
+ ("configured", "expected"),
+ [
+ (None, "http://localhost:11434/v1"),
+ ("http://localhost:11434", "http://localhost:11434/v1"),
+ ("http://localhost:11434/", "http://localhost:11434/v1"),
+ ("http://localhost:11434/v1", "http://localhost:11434/v1"),
+ ],
+)
+def test_init_normalizes_openai_base_url(configured: str | None, expected: str) -> None:
+ with patch(
+ "free_claude_code.providers.transports.openai_chat.transport.AsyncOpenAI"
+ ) as openai_client:
+ provider = _provider(configured)
+
+ assert provider._provider_name == "OLLAMA"
+ assert provider._base_url == expected
+ assert provider._api_key == "ollama"
+ assert openai_client.call_args.kwargs["base_url"] == expected
+
+
+def test_build_request_body_uses_openai_chat_shape() -> None:
+ body = _provider()._build_request_body(make_messages_request(OLLAMA_MODEL))
+
+ assert body["model"] == OLLAMA_MODEL
+ assert body["messages"][0]["role"] == "system"
assert "thinking" not in body
- assert body["model"] == "llama3.1:8b"
-
-
-def test_build_request_body_disabled_thinking_strips_assistant_thinking_blocks(
- ollama_config,
-):
- """Prior assistant thinking/redacted blocks are removed when policy is off."""
- provider = OllamaProvider(
- ollama_config.model_copy(update={"enable_thinking": False}),
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request(
- OLLAMA_MODEL,
- system=None,
- messages=[
- {"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)
- assert body["messages"][1]["content"] == ""
+ assert "extra_body" not in body
@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 = make_messages_request(OLLAMA_MODEL)
- mock_response = MagicMock()
- mock_response.status_code = 500
- mock_response.aread = AsyncMock(return_value=b"Internal Server Error")
- mock_response.raise_for_status = MagicMock(
- side_effect=httpx.HTTPStatusError(
- "Internal Server Error", request=MagicMock(), response=mock_response
+async def test_stream_response_uses_shared_openai_chat_transport() -> None:
+ provider = _provider()
+ chunk = MagicMock()
+ chunk.choices = [
+ MagicMock(
+ delta=MagicMock(
+ content="Hello from Ollama",
+ reasoning_content=None,
+ tool_calls=None,
+ ),
+ finish_reason="stop",
+ )
+ ]
+ chunk.usage = MagicMock(prompt_tokens=8, completion_tokens=4)
+
+ async def stream():
+ yield chunk
+
+ with patch.object(
+ provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream(),
+ ) as create:
+ output = "".join(
+ [
+ event
+ async for event in provider.stream_response(
+ make_messages_request(OLLAMA_MODEL)
+ )
+ ]
)
- )
-
- with (
- patch.object(
- ollama_provider._client, "build_request", return_value=MagicMock()
- ),
- patch.object(
- ollama_provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=mock_response,
- ),
- pytest.raises(ExecutionFailure) as exc_info,
- ):
- [
- event
- async for event in ollama_provider.stream_response(req, request_id="REQ")
- ]
-
- assert "Provider API request failed" in exc_info.value.message
- assert "REQ" in exc_info.value.message
-
-
-async def test_cleanup(ollama_provider):
- """Test that cleanup closes the client."""
- ollama_provider._client.aclose = AsyncMock()
-
- await ollama_provider.cleanup()
- ollama_provider._client.aclose.assert_called_once()
+ assert create.call_args.kwargs["stream"] is True
+ assert create.call_args.kwargs["model"] == OLLAMA_MODEL
+ assert "Hello from Ollama" in output
+ assert parse_sse_text(output)[-1].event == "message_stop"
diff --git a/tests/providers/test_preflight_contract.py b/tests/providers/test_preflight_contract.py
index 89b1acf0..8ca65c31 100644
--- a/tests/providers/test_preflight_contract.py
+++ b/tests/providers/test_preflight_contract.py
@@ -1,4 +1,4 @@
-"""Provider transport preflight is explicit at every implementation boundary."""
+"""The shared provider transport owns explicit request preflight."""
from collections.abc import AsyncIterator
@@ -6,9 +6,6 @@ import pytest
from free_claude_code.core.anthropic.models import Message, MessagesRequest
from free_claude_code.providers.base import BaseProvider, ProviderConfig
-from free_claude_code.providers.transports.anthropic_messages import (
- AnthropicMessagesTransport,
-)
from free_claude_code.providers.transports.openai_chat import OpenAIChatTransport
@@ -23,17 +20,6 @@ class RecordingOpenAITransport(OpenAIChatTransport):
return {}
-class RecordingAnthropicTransport(AnthropicMessagesTransport):
- def __init__(self) -> None:
- self.build_calls: list[tuple[MessagesRequest, bool | None]] = []
-
- def _build_request_body(
- self, request: MessagesRequest, thinking_enabled: bool | None = None
- ) -> dict:
- self.build_calls.append((request, thinking_enabled))
- return {}
-
-
class ProviderWithoutPreflight(BaseProvider):
async def cleanup(self) -> None:
return None
@@ -58,20 +44,12 @@ def test_provider_base_requires_an_explicit_preflight_implementation() -> None:
ProviderWithoutPreflight(ProviderConfig(api_key="test"))
-def test_each_transport_family_owns_preflight() -> None:
+def test_openai_transport_owns_preflight() -> None:
assert OpenAIChatTransport.preflight_stream is not BaseProvider.preflight_stream
- assert (
- AnthropicMessagesTransport.preflight_stream is not BaseProvider.preflight_stream
- )
- "transport",
- [RecordingOpenAITransport(), RecordingAnthropicTransport()],
-)
-def test_transport_preflight_calls_its_builder_and_preserves_false(
- transport: RecordingOpenAITransport | RecordingAnthropicTransport,
-) -> None:
+def test_transport_preflight_calls_builder_and_preserves_false() -> None:
+ transport = RecordingOpenAITransport()
request = MessagesRequest(
model="test-model",
messages=[Message(role="user", content="hello")],
diff --git a/tests/providers/test_provider_runtime.py b/tests/providers/test_provider_runtime.py
index a5d84087..d120cd94 100644
--- a/tests/providers/test_provider_runtime.py
+++ b/tests/providers/test_provider_runtime.py
@@ -142,12 +142,11 @@ def test_provider_catalog_covers_advertised_provider_ids():
assert descriptor.provider_id
-def test_ollama_descriptor_uses_local_server_tool_semantics():
+def test_ollama_descriptor_uses_local_openai_endpoint_semantics():
descriptor = PROVIDER_CATALOG["ollama"]
assert descriptor.default_base_url == "http://localhost:11434"
- assert descriptor.capabilities.local is True
- assert descriptor.capabilities.server_tool_passthrough is True
+ assert descriptor.local is True
def test_zai_descriptor_uses_fixed_cloud_base_url():
diff --git a/tests/providers/test_provider_transport_logging.py b/tests/providers/test_provider_transport_logging.py
index be43063d..d8cf830e 100644
--- a/tests/providers/test_provider_transport_logging.py
+++ b/tests/providers/test_provider_transport_logging.py
@@ -1,273 +1,41 @@
-"""Tests for metadata-only provider transport logging by default."""
+"""Tests for credential-safe provider transport logging."""
import logging
from contextlib import asynccontextmanager
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, patch
import httpx
import openai
import pytest
-from free_claude_code.config.constants import NATIVE_MESSAGES_ERROR_BODY_LOG_CAP_BYTES
from free_claude_code.config.nim import NimSettings
from free_claude_code.core.failures import ExecutionFailure
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
-from free_claude_code.providers.transports.anthropic_messages import (
- transport as native_transport,
-)
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,
- NativeProvider,
-)
-def provider_config():
- return ProviderConfig(
- api_key="test-key",
- base_url="https://custom.test/v1/",
- proxy="socks5://127.0.0.1:9999",
- rate_limit=10,
- rate_window=60,
- http_read_timeout=600.0,
- http_write_timeout=15.0,
- http_connect_timeout=5.0,
- )
-
-
-async def test_native_non_200_logs_exclude_body_text_by_default(
- caplog, provider_config
-):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- response = FakeResponse(status_code=500, text="SECRET_UPSTREAM_BODY")
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- caplog.at_level(logging.ERROR),
- pytest.raises(ExecutionFailure),
- ):
- [e async for e in provider.stream_response(req)]
-
- messages = " | ".join(r.getMessage() for r in caplog.records)
- assert "SECRET_UPSTREAM_BODY" not in messages
- assert "HTTP 500" in messages
- assert "body_preview_bytes=" not in messages
-
-
-async def test_native_non_200_logs_body_when_verbose(caplog, provider_config):
- provider_config.log_api_error_tracebacks = True
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- response = FakeResponse(
- status_code=500,
- text="api_key=SECRET_UPSTREAM_BODY useful native detail",
- )
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- caplog.at_level(logging.ERROR),
- pytest.raises(ExecutionFailure),
- ):
- [e async for e in provider.stream_response(req)]
-
- messages = " | ".join(r.getMessage() for r in caplog.records)
- assert "api_key=<redacted>" in messages
- assert "useful native detail" in messages
- assert "SECRET_UPSTREAM_BODY" not in messages
- assert "truncated=False" in messages
-
-
-async def test_native_non_200_verbose_logs_only_capped_error_body(
- caplog, provider_config
-):
- provider_config.log_api_error_tracebacks = True
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- 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)
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- caplog.at_level(logging.ERROR),
- pytest.raises(ExecutionFailure),
- ):
- [e async for e in provider.stream_response(req)]
-
- messages = " | ".join(r.getMessage() for r in caplog.records)
- assert "SECRET_TAIL_NOT_LOGGED" not in messages
- assert "truncated=True" in messages
- assert f"body_preview_bytes={NATIVE_MESSAGES_ERROR_BODY_LOG_CAP_BYTES}" in messages
-
-
-async def test_native_non_200_default_does_not_read_oversized_body(
- caplog, provider_config
-):
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- huge = f"{'Z' * 500_000}LEAK_MARKER"
- response = FakeResponse(status_code=500, text=huge)
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
+def _provider(*, verbose: bool = False) -> NvidiaNimProvider:
+ return NvidiaNimProvider(
+ ProviderConfig(
+ api_key="k",
+ base_url="http://localhost:1/v1",
+ log_api_error_tracebacks=verbose,
),
- caplog.at_level(logging.ERROR),
- pytest.raises(ExecutionFailure),
- ):
- [e async for e in provider.stream_response(req)]
-
- messages = " | ".join(r.getMessage() for r in caplog.records)
- assert "LEAK_MARKER" not in messages
- assert "ZZZ" not in messages
- assert "HTTP 500" in messages
-
-
-async def test_native_stream_failure_logs_exclude_exception_str_by_default(
- caplog, provider_config
-):
- provider = NativeProvider(
- provider_config,
+ nim_settings=NimSettings(),
rate_limiter=passthrough_rate_limiter(),
)
- req = make_messages_request()
- response = FakeResponse(
- lines=[
- "event: ping",
- 'data: {"type":"ping"}',
- "",
- ]
- )
- async def boom(_response):
- raise RuntimeError("SECRET_DETAIL")
- if False:
- yield ""
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- patch.object(native_transport, "_iter_sse_events", boom),
- caplog.at_level(logging.ERROR),
- pytest.raises(ExecutionFailure),
- ):
- [e async for e in provider.stream_response(req)]
-
- messages = " | ".join(r.getMessage() for r in caplog.records)
- assert "SECRET_DETAIL" not in messages
- assert "exc_type=RuntimeError" in messages
- assert "http_status=None" in messages
+@asynccontextmanager
+async def _noop_slot():
+ yield
@pytest.mark.asyncio
-async def test_native_stream_failure_verbose_traceback_redacts_credentials(
- caplog, provider_config
-):
- provider_config.log_api_error_tracebacks = True
- provider = NativeProvider(
- provider_config,
- rate_limiter=passthrough_rate_limiter(),
- )
- req = make_messages_request()
- response = FakeResponse(
- lines=[
- "event: ping",
- '{"type":"ping"}',
- "",
- ]
- )
-
- async def boom(_response):
- raise RuntimeError(
- "authorization: Bearer NATIVE_TRACE_SECRET useful traceback detail"
- )
- if False:
- yield ""
-
- with (
- patch.object(provider._client, "build_request", return_value=MagicMock()),
- patch.object(
- provider._client,
- "send",
- new_callable=AsyncMock,
- return_value=response,
- ),
- patch.object(native_transport, "_iter_sse_events", boom),
- caplog.at_level(logging.ERROR),
- pytest.raises(ExecutionFailure),
- ):
- [e async for e in provider.stream_response(req)]
-
- messages = " | ".join(r.getMessage() for r in caplog.records)
- assert "authorization: <redacted>" in messages
- assert "useful traceback detail" in messages
- assert "NATIVE_TRACE_SECRET" not in messages
-
-
-async def test_openai_compat_stream_failure_default_logs_exclude_exception_str(caplog):
- config = ProviderConfig(
- api_key="k",
- base_url="http://localhost:1/v1",
- log_api_error_tracebacks=False,
- )
- provider = NvidiaNimProvider(
- config, nim_settings=NimSettings(), rate_limiter=passthrough_rate_limiter()
- )
- req = make_messages_request()
-
- @asynccontextmanager
- async def _noop_slot():
- yield
-
+async def test_stream_failure_default_logs_exclude_exception_text(caplog) -> None:
+ provider = _provider()
with (
patch.object(
provider,
@@ -275,41 +43,24 @@ async def test_openai_compat_stream_failure_default_logs_exclude_exception_str(c
new_callable=AsyncMock,
side_effect=RuntimeError("SECRET_OPENAI_COMPAT"),
),
- patch.object(
- provider._rate_limiter,
- "concurrency_slot",
- _noop_slot,
- ),
+ patch.object(provider._rate_limiter, "concurrency_slot", _noop_slot),
caplog.at_level(logging.ERROR),
pytest.raises(ExecutionFailure),
):
- [e async for e in provider.stream_response(req)]
+ [event async for event in provider.stream_response(make_messages_request())]
- messages = " | ".join(r.getMessage() for r in caplog.records)
+ messages = " | ".join(record.getMessage() for record in caplog.records)
assert "SECRET_OPENAI_COMPAT" not in messages
assert "exc_type=RuntimeError" in messages
@pytest.mark.asyncio
-async def test_openai_compat_stream_failure_default_logs_cause_types_only(caplog):
- config = ProviderConfig(
- api_key="k",
- base_url="http://localhost:1/v1",
- log_api_error_tracebacks=False,
- )
- provider = NvidiaNimProvider(
- config, nim_settings=NimSettings(), rate_limiter=passthrough_rate_limiter()
- )
- req = make_messages_request()
+async def test_stream_failure_default_logs_cause_types_only(caplog) -> None:
+ provider = _provider()
error = openai.APIConnectionError(
request=httpx.Request("POST", "http://localhost:1/v1/chat/completions")
)
error.__cause__ = httpx.ConnectError("SECRET_CAUSE_DETAIL")
-
- @asynccontextmanager
- async def _noop_slot():
- yield
-
with (
patch.object(
provider,
@@ -317,38 +68,21 @@ async def test_openai_compat_stream_failure_default_logs_cause_types_only(caplog
new_callable=AsyncMock,
side_effect=error,
),
- patch.object(
- provider._rate_limiter,
- "concurrency_slot",
- _noop_slot,
- ),
+ patch.object(provider._rate_limiter, "concurrency_slot", _noop_slot),
caplog.at_level(logging.ERROR),
pytest.raises(ExecutionFailure),
):
- [e async for e in provider.stream_response(req)]
+ [event async for event in provider.stream_response(make_messages_request())]
- messages = " | ".join(r.getMessage() for r in caplog.records)
+ messages = " | ".join(record.getMessage() for record in caplog.records)
assert "SECRET_CAUSE_DETAIL" not in messages
assert "exc_type=APIConnectionError" in messages
assert "cause_types=ConnectError" in messages
@pytest.mark.asyncio
-async def test_openai_compat_stream_failure_respects_verbose_flag(caplog):
- config = ProviderConfig(
- api_key="k",
- base_url="http://localhost:1/v1",
- log_api_error_tracebacks=True,
- )
- provider = NvidiaNimProvider(
- config, nim_settings=NimSettings(), rate_limiter=passthrough_rate_limiter()
- )
- req = make_messages_request()
-
- @asynccontextmanager
- async def _noop_slot():
- yield
-
+async def test_stream_failure_verbose_traceback_redacts_credentials(caplog) -> None:
+ provider = _provider(verbose=True)
with (
patch.object(
provider,
@@ -358,17 +92,13 @@ async def test_openai_compat_stream_failure_respects_verbose_flag(caplog):
"api_key=SECRET_OPENAI_COMPAT useful traceback detail"
),
),
- patch.object(
- provider._rate_limiter,
- "concurrency_slot",
- _noop_slot,
- ),
+ patch.object(provider._rate_limiter, "concurrency_slot", _noop_slot),
caplog.at_level(logging.ERROR),
pytest.raises(ExecutionFailure),
):
- [e async for e in provider.stream_response(req)]
+ [event async for event in provider.stream_response(make_messages_request())]
- messages = " | ".join(r.getMessage() for r in caplog.records)
+ messages = " | ".join(record.getMessage() for record in caplog.records)
assert "api_key=<redacted>" in messages
assert "useful traceback detail" in messages
assert "SECRET_OPENAI_COMPAT" not in messages
diff --git a/uv.lock b/uv.lock
index 4404f296..734f0f16 100644
--- a/uv.lock
+++ b/uv.lock
@@ -561,7 +561,7 @@ wheels = [
[[package]]
name = "free-claude-code"
-version = "3.5.10"
+version = "3.5.12"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },