Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
Fix stream:false requests returning malformed response (matches #917, #868, #771, #497 symptom) (#977)
jankeydadondc-bytedfbff528c668
diff --git a/api/handlers/messages.py b/api/handlers/messages.pyindex 45895589..37ae5c43 100644--- a/api/handlers/messages.py+++ b/api/handlers/messages.py@@ -2,9 +2,10 @@from __future__ import annotations-from collections.abc import Callable-from dataclasses import replace+from collections.abc import AsyncIterator, Callable+from dataclasses import dataclass, replace+from fastapi.responses import JSONResponsefrom loguru import loggerfrom api.detection import is_safety_classifier_request@@ -22,14 +23,11 @@ from api.web_tools.request import (from api.web_tools.streaming import stream_web_server_tool_responsefrom config.provider_catalog import PROVIDER_CATALOGfrom config.settings import Settings-from core.anthropic import get_token_count+from core.anthropic import aggregate_anthropic_sse_to_message, get_token_countfrom core.trace import trace_eventfrom providers.base import BaseProviderfrom providers.exceptions import InvalidRequestError, ProviderError-ProviderGetter = Callable[[str], BaseProvider]-MessageIntercept = Callable[[RoutedMessagesRequest], object | None]-_OPENAI_CHAT_UPSTREAM_IDS = frozenset(provider_idfor provider_id, descriptor in PROVIDER_CATALOG.items()@@ -37,6 +35,21 @@ _OPENAI_CHAT_UPSTREAM_IDS = frozenset()+@dataclass(frozen=True)+class _MessagesStreamResult:+ body: AsyncIterator[str]+++@dataclass(frozen=True)+class _MessagesCompleteResult:+ response: object+++ProviderGetter = Callable[[str], BaseProvider]+_MessagesResult = _MessagesStreamResult | _MessagesCompleteResult+MessageIntercept = Callable[[RoutedMessagesRequest], _MessagesResult | None]++class MessagesHandler:"""Handle Anthropic-compatible Messages requests."""@@ -62,7 +75,7 @@ class MessagesHandler:self._intercept_local_optimization,)- def create(self, request_data: MessagesRequest) -> object:+ async def create(self, request_data: MessagesRequest) -> object:"""Create an Anthropic-compatible message response."""try:require_non_empty_messages(request_data.messages)@@ -70,19 +83,18 @@ class MessagesHandler:routed = self._apply_message_routing_policies(routed)self._reject_unsupported_server_tools(routed)- intercepted = self._run_message_intercepts(routed)- if intercepted is not None:- return intercepted-- logger.debug("No optimization matched, routing to provider")- return anthropic_sse_streaming_response(- self._provider_execution.stream(- routed,- wire_api="messages",- raw_log_label="FULL_PAYLOAD",- raw_log_payload=routed.request.model_dump(),+ result = self._run_message_intercepts(routed)+ if result is None:+ logger.debug("No optimization matched, routing to provider")+ result = _MessagesStreamResult(+ self._provider_execution.stream(+ routed,+ wire_api="messages",+ raw_log_label="FULL_PAYLOAD",+ raw_log_payload=routed.request.model_dump(),+ ))- )+ return await self._to_public_response(result, stream=request_data.stream)except ProviderError:raiseexcept Exception as exc:@@ -90,6 +102,24 @@ class MessagesHandler:self._settings, exc, context="CREATE_MESSAGE_ERROR") from exc+ async def _to_public_response(+ self, result: _MessagesResult, *, stream: bool | None+ ) -> object:+ if isinstance(result, _MessagesCompleteResult):+ return result.response+ if stream is False:+ # Non-streaming clients (e.g. Claude Code utility calls) need a+ # complete JSON Message; the internal pipeline is always SSE, so+ # serving that raw here breaks the client SDK's response parse.+ message, error = await aggregate_anthropic_sse_to_message(result.body)+ if error is not None and not message.get("content"):+ return JSONResponse(+ status_code=502,+ content={"type": "error", "error": error},+ )+ return JSONResponse(content=message)+ return anthropic_sse_streaming_response(result.body)+def _reject_unsupported_server_tools(self, routed: RoutedMessagesRequest) -> None:if routed.resolved.provider_id not in _OPENAI_CHAT_UPSTREAM_IDS:return@@ -120,7 +150,9 @@ class MessagesHandler:resolved=replace(routed.resolved, thinking_enabled=False),)- def _run_message_intercepts(self, routed: RoutedMessagesRequest) -> object | None:+ def _run_message_intercepts(+ self, routed: RoutedMessagesRequest+ ) -> _MessagesResult | None:for intercept in self._message_intercepts:result = intercept(routed)if result is not None:@@ -129,7 +161,7 @@ class MessagesHandler:def _intercept_web_server_tool(self, routed: RoutedMessagesRequest- ) -> object | None:+ ) -> _MessagesResult | None:if not self._settings.enable_web_server_tools:return Noneif not is_web_server_tool_request(routed.request):@@ -150,7 +182,7 @@ class MessagesHandler:self._settings.web_fetch_allowed_schemes),)- return anthropic_sse_streaming_response(+ return _MessagesStreamResult(stream_web_server_tool_response(routed.request,input_tokens=input_tokens,@@ -161,7 +193,7 @@ class MessagesHandler:def _intercept_local_optimization(self, routed: RoutedMessagesRequest- ) -> object | None:+ ) -> _MessagesResult | None:optimized = try_optimizations(routed.request, self._settings)if optimized is None:return None@@ -171,4 +203,4 @@ class MessagesHandler:source="api",model=routed.request.model,)- return optimized+ return _MessagesCompleteResult(optimized)diff --git a/api/routes.py b/api/routes.pyindex a815c89f..95fb3e7b 100644--- a/api/routes.py+++ b/api/routes.py@@ -69,8 +69,8 @@ async def create_message(handler: MessagesHandler = Depends(get_messages_handler),_auth=Depends(require_api_key),):- """Create a message (always streaming)."""- return handler.create(request_data)+ """Create a message (streaming by default; stream=false gets aggregated JSON)."""+ return await handler.create(request_data)@router.api_route("/v1/messages", methods=["HEAD", "OPTIONS"])diff --git a/core/anthropic/__init__.py b/core/anthropic/__init__.pyindex 93939797..a458645b 100644--- a/core/anthropic/__init__.py+++ b/core/anthropic/__init__.py@@ -15,6 +15,7 @@ from .errors import (from .native_messages_request import sanitize_native_messages_thinking_policyfrom .provider_stream_error import iter_provider_stream_error_sse_eventsfrom .request_serialization import serialize_tool_result_content+from .sse_aggregation import aggregate_anthropic_sse_to_messagefrom .streaming import (AnthropicStreamLedger,StreamBlockLedger,@@ -38,6 +39,7 @@ __all__ = ["StreamBlockLedger","ThinkTagParser","ToolBlockState",+ "aggregate_anthropic_sse_to_message","append_request_id","build_base_request_body","extract_text_from_content",diff --git a/core/anthropic/sse_aggregation.py b/core/anthropic/sse_aggregation.pynew file mode 100644index 00000000..6abd485b--- /dev/null+++ b/core/anthropic/sse_aggregation.py@@ -0,0 +1,137 @@+"""Fold an Anthropic Messages SSE stream into a single JSON Message body.++Used to honor client requests with ``stream: false``. The internal pipeline+is always SSE (providers/transports only know how to speak streaming), so+callers that need a non-streaming response consume the stream here and get+back the same shape the real Anthropic API returns for a non-streaming+``messages.create()`` call.+"""++from __future__ import annotations++import json+import uuid+from collections.abc import AsyncIterator+from typing import Any++from .native_sse_block_policy import parse_native_sse_event++__all__ = ["aggregate_anthropic_sse_to_message"]+++async def aggregate_anthropic_sse_to_message(+ stream: AsyncIterator[str],+) -> tuple[dict[str, Any], dict[str, Any] | None]:+ """Assemble a complete Messages JSON body from an Anthropic SSE stream.++ Returns ``(message_body, error)`` where ``error`` is the payload of a+ top-level ``event: error`` if one arrived, else ``None``.+ """+ buffer = ""+ message: dict[str, Any] = {}+ blocks: dict[int, dict[str, Any]] = {}+ parts: dict[int, list[str]] = {}+ error: dict[str, Any] | None = None++ def handle_payload(payload: dict[str, Any]) -> None:+ nonlocal message, error+ ptype = payload.get("type")+ if ptype == "message_start":+ started = payload.get("message")+ if isinstance(started, dict):+ message = dict(started)+ elif ptype == "content_block_start":+ idx = payload.get("index")+ block = payload.get("content_block")+ if isinstance(idx, int) and isinstance(block, dict):+ blocks[idx] = dict(block)+ parts.setdefault(idx, [])+ elif ptype == "content_block_delta":+ idx = payload.get("index")+ delta = payload.get("delta")+ if not isinstance(idx, int) or not isinstance(delta, dict):+ return+ if idx not in blocks:+ blocks[idx] = {"type": "text", "text": ""}+ parts[idx] = []+ dtype = delta.get("type")+ if dtype == "text_delta":+ parts[idx].append(str(delta.get("text", "")))+ elif dtype == "thinking_delta":+ parts[idx].append(str(delta.get("thinking", "")))+ elif dtype == "input_json_delta":+ parts[idx].append(str(delta.get("partial_json", "")))+ elif dtype == "signature_delta":+ blocks[idx]["signature"] = str(delta.get("signature", ""))+ elif ptype == "message_delta":+ delta = payload.get("delta")+ if isinstance(delta, dict):+ if delta.get("stop_reason"):+ message["stop_reason"] = delta["stop_reason"]+ if "stop_sequence" in delta:+ message["stop_sequence"] = delta["stop_sequence"]+ usage = payload.get("usage")+ if isinstance(usage, dict):+ merged = (+ dict(message["usage"])+ if isinstance(message.get("usage"), dict)+ else {}+ )+ merged.update(+ {k: v for k, v in usage.items() if isinstance(v, int | dict)}+ )+ message["usage"] = merged+ elif ptype == "error":+ err = payload.get("error")+ error = (+ err+ if isinstance(err, dict)+ else {"type": "api_error", "message": "provider error"}+ )++ async for chunk in stream:+ 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)++ content: list[dict[str, Any]] = []+ for idx in sorted(blocks):+ block = blocks[idx]+ accumulated = "".join(parts.get(idx, []))+ btype = block.get("type")+ if btype == "text":+ block["text"] = str(block.get("text", "")) + accumulated+ elif btype == "thinking":+ block["thinking"] = str(block.get("thinking", "")) + accumulated+ block.setdefault("signature", "")+ elif btype == "tool_use":+ if accumulated.strip():+ try:+ block["input"] = json.loads(accumulated)+ except json.JSONDecodeError:+ block["input"] = block.get("input") or {}+ elif not isinstance(block.get("input"), dict):+ block["input"] = {}+ content.append(block)++ message["content"] = content+ message.setdefault("id", f"msg_{uuid.uuid4()}")+ message.setdefault("type", "message")+ message.setdefault("role", "assistant")+ message.setdefault("model", "unknown")+ message.setdefault("stop_reason", "end_turn")+ message.setdefault("stop_sequence", None)+ usage = dict(message["usage"]) if isinstance(message.get("usage"), dict) else {}+ usage.setdefault("input_tokens", 0)+ usage.setdefault("output_tokens", 0)+ message["usage"] = usage+ return message, errordiff --git a/providers/transports/anthropic_messages/transport.py b/providers/transports/anthropic_messages/transport.pyindex f028c485..480b93fd 100644--- a/providers/transports/anthropic_messages/transport.py+++ b/providers/transports/anthropic_messages/transport.py@@ -138,10 +138,14 @@ class AnthropicMessagesTransport(BaseProvider):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,+ json={**body, "stream": True},headers=self._request_headers(),)return await self._client.send(request, stream=True)diff --git a/pyproject.toml b/pyproject.tomlindex ecbbc8a7..67ce95db 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "2.5.1"+version = "2.5.2"description = "Middleware between Claude Code CLI (Anthropic API) and NVIDIA NIM"readme = "README.md"requires-python = ">=3.14.0"diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.pyindex beca4ee1..71cfee93 100644--- a/tests/api/test_api_handlers.py+++ b/tests/api/test_api_handlers.py@@ -1,16 +1,18 @@from __future__ import annotations+import jsonfrom collections.abc import AsyncIteratorfrom typing import Anyfrom unittest.mock import MagicMock, patchimport pytest-from fastapi.responses import StreamingResponse+from fastapi.responses import JSONResponse, StreamingResponsefrom api.handlers import MessagesHandler, ResponsesHandler, TokenCountHandlerfrom api.models.anthropic import Message, MessagesRequest, TokenCountRequestfrom api.models.openai_responses import OpenAIResponsesRequestfrom config.settings import Settings+from core.anthropic.streaming import format_sse_eventfrom providers.base import BaseProvider, ProviderConfig_CLASSIFIER_SYSTEM = (@@ -23,11 +25,15 @@ _CLASSIFIER_USER = (class FakeProvider(BaseProvider):- def __init__(self) -> None:+ def __init__(self, events: list[str] | None = None) -> None:super().__init__(ProviderConfig(api_key="test"))self.preflight_calls: list[tuple[Any, bool | None]] = []self.requests: list[Any] = []self.stream_kwargs: list[dict[str, Any]] = []+ self.events = events or [+ 'event: message_start\ndata: {"type":"message_start"}\n\n',+ 'event: message_stop\ndata: {"type":"message_stop"}\n\n',+ ]def preflight_stream(self, request: Any, *, thinking_enabled: bool | None = None@@ -56,8 +62,8 @@ class FakeProvider(BaseProvider):"thinking_enabled": thinking_enabled,})- yield 'event: message_start\ndata: {"type":"message_start"}\n\n'- yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'+ for event in self.events:+ yield eventasync def _streaming_body_text(response: StreamingResponse) -> str:@@ -70,6 +76,12 @@ async def _streaming_body_text(response: StreamingResponse) -> str:return "".join(parts)+def _json_response_content(response: JSONResponse) -> dict[str, Any]:+ content = json.loads(bytes(response.body).decode("utf-8"))+ assert isinstance(content, dict)+ return content++def _trace_events(trace_mock: MagicMock, event: str) -> list[dict[str, Any]]:return [dict(call.kwargs)@@ -88,7 +100,7 @@ async def test_messages_handler_passes_routed_request_and_stream_metadata() -> Nmessages=[Message(role="user", content="hi")],)- response = handler.create(request)+ response = await handler.create(request)assert isinstance(response, StreamingResponse)body = await _streaming_body_text(response)@@ -100,6 +112,110 @@ async def test_messages_handler_passes_routed_request_and_stream_metadata() -> Nassert len(provider.preflight_calls) == 1+async def test_messages_handler_aggregates_provider_stream_when_stream_false() -> None:+ provider = FakeProvider(+ [+ format_sse_event(+ "message_start",+ {+ "type": "message_start",+ "message": {+ "id": "msg_test",+ "type": "message",+ "role": "assistant",+ "content": [],+ "model": "test-model",+ "stop_reason": None,+ "stop_sequence": None,+ "usage": {"input_tokens": 7, "output_tokens": 1},+ },+ },+ ),+ 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": "OK"},+ },+ ),+ format_sse_event(+ "content_block_stop", {"type": "content_block_stop", "index": 0}+ ),+ format_sse_event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "end_turn", "stop_sequence": None},+ "usage": {"input_tokens": 7, "output_tokens": 2},+ },+ ),+ format_sse_event("message_stop", {"type": "message_stop"}),+ ]+ )+ handler = MessagesHandler(Settings(), provider_getter=lambda _: provider)+ request = MessagesRequest(+ model="nvidia_nim/test-model",+ max_tokens=100,+ stream=False,+ messages=[Message(role="user", content="hi")],+ )++ response = await handler.create(request)++ assert isinstance(response, JSONResponse)+ assert response.headers["content-type"].startswith("application/json")+ body = _json_response_content(response)+ assert body["id"] == "msg_test"+ assert body["type"] == "message"+ assert body["role"] == "assistant"+ assert body["model"] == "test-model"+ assert body["content"] == [{"type": "text", "text": "OK"}]+ assert body["stop_reason"] == "end_turn"+ assert body["usage"] == {"input_tokens": 7, "output_tokens": 2}+++async def test_messages_handler_returns_error_json_for_stream_false_sse_error() -> None:+ provider = FakeProvider(+ [+ format_sse_event(+ "error",+ {+ "type": "error",+ "error": {"type": "api_error", "message": "upstream failed"},+ },+ )+ ]+ )+ handler = MessagesHandler(Settings(), provider_getter=lambda _: provider)+ request = MessagesRequest(+ model="nvidia_nim/test-model",+ max_tokens=100,+ stream=False,+ messages=[Message(role="user", content="hi")],+ )++ response = await handler.create(request)++ assert isinstance(response, JSONResponse)+ assert response.status_code == 502+ body = _json_response_content(response)+ assert body == {+ "type": "error",+ "error": {"type": "api_error", "message": "upstream failed"},+ }++@pytest.mark.asyncioasync def test_messages_handler_forces_no_thinking_for_safety_classifier() -> None:provider = FakeProvider()@@ -112,7 +228,7 @@ async def test_messages_handler_forces_no_thinking_for_safety_classifier() -> No)with patch("api.handlers.messages.trace_event") as trace_mock:- response = handler.create(request)+ response = await handler.create(request)assert isinstance(response, StreamingResponse)await _streaming_body_text(response)@@ -153,7 +269,7 @@ async def test_messages_handler_preserves_thinking_for_non_classifier() -> None:)with patch("api.handlers.messages.trace_event") as trace_mock:- response = handler.create(request)+ response = await handler.create(request)assert isinstance(response, StreamingResponse)await _streaming_body_text(response)@@ -177,7 +293,7 @@ async def test_messages_handler_keeps_existing_no_thinking_for_classifier() -> N)with patch("api.handlers.messages.trace_event") as trace_mock:- response = handler.create(request)+ response = await handler.create(request)assert isinstance(response, StreamingResponse)await _streaming_body_text(response)@@ -196,7 +312,10 @@ async def test_messages_handler_keeps_existing_no_thinking_for_classifier() -> N]-def test_messages_handler_optimization_intercepts_before_provider_execution() -> None:+async def test_messages_handler_optimization_intercepts_before_provider_execution() -> (+ None+):provider_getter = MagicMock()handler = MessagesHandler(Settings(), provider_getter=provider_getter)request = MessagesRequest(@@ -207,7 +326,7 @@ def test_messages_handler_optimization_intercepts_before_provider_execution() ->optimized = object()with patch("api.handlers.messages.try_optimizations", return_value=optimized):- assert handler.create(request) is optimized+ assert await handler.create(request) is optimizedprovider_getter.assert_not_called()diff --git a/tests/api/test_safe_logging.py b/tests/api/test_safe_logging.pyindex aa685f07..94c59448 100644--- a/tests/api/test_safe_logging.py+++ b/tests/api/test_safe_logging.py@@ -14,7 +14,8 @@ from config.settings import Settingsfrom core.anthropic import AnthropicStreamLedger-def test_create_message_skips_full_payload_debug_log_by_default():+async def test_create_message_skips_full_payload_debug_log_by_default():settings = Settings()assert settings.log_raw_api_payloads is Falsemock_provider = MagicMock()@@ -32,7 +33,7 @@ def test_create_message_skips_full_payload_debug_log_by_default():)with patch.object(provider_execution.logger, "debug") as mock_debug:- service.create(request)+ await service.create(request)full_payload_calls = [c@@ -42,7 +43,8 @@ def test_create_message_skips_full_payload_debug_log_by_default():assert not full_payload_calls-def test_create_message_logs_full_payload_when_opt_in():+async def test_create_message_logs_full_payload_when_opt_in():settings = Settings()settings.log_raw_api_payloads = Truemock_provider = MagicMock()@@ -59,7 +61,7 @@ def test_create_message_logs_full_payload_when_opt_in():)with patch.object(provider_execution.logger, "debug") as mock_debug:- service.create(request)+ await service.create(request)keys = [c.args[0] for c in mock_debug.call_args_list if c.args]assert any(k == "FULL_PAYLOAD [{}]: {}" for k in keys)@@ -92,7 +94,8 @@ def _flatten_log_calls(mock_log) -> str:return " ".join(parts)-def test_create_message_unexpected_error_default_logs_exclude_exception_text():+async def test_create_message_unexpected_error_default_logs_exclude_exception_text():settings = Settings()assert settings.log_api_error_tracebacks is Falsesecret = "upstream-secret-token-abc"@@ -114,14 +117,15 @@ def test_create_message_unexpected_error_default_logs_exclude_exception_text():patch.object(request_errors.logger, "error") as log_err,pytest.raises(HTTPException),):- service.create(request)+ await service.create(request)blob = _flatten_log_calls(log_err)assert secret not in blobassert "RuntimeError" in blob-def test_create_message_unexpected_error_always_returns_500():+async def test_create_message_unexpected_error_always_returns_500():"""Non-provider failures must not leak arbitrary status_code attributes."""class WeirdError(Exception):@@ -142,7 +146,7 @@ def test_create_message_unexpected_error_always_returns_500():)with pytest.raises(HTTPException) as excinfo:- service.create(request)+ await service.create(request)assert excinfo.value.status_code == 500diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.pyindex 6ca12301..b88b79ae 100644--- a/tests/api/test_web_server_tools.py+++ b/tests/api/test_web_server_tools.py@@ -1,8 +1,10 @@+import jsonfrom typing import Anyfrom unittest.mock import AsyncMock, MagicMock, patchimport httpximport pytest+from fastapi.responses import JSONResponse, StreamingResponseimport api.web_tools.constants as web_tool_constantsfrom api.handlers import MessagesHandler@@ -105,8 +107,9 @@ def test_web_server_tool_not_detected_when_forced_name_missing_from_tools():assert not is_web_server_tool_request(request)@pytest.mark.parametrize("provider_id", _OPENAI_CHAT_PROVIDER_IDS)-def test_service_rejects_forced_server_tool_on_openai_when_disabled(+async def test_service_rejects_forced_server_tool_on_openai_when_disabled(provider_id: str,):"""OpenAI Chat upstreams cannot run forced server tools without the local handler."""@@ -130,7 +133,7 @@ def test_service_rejects_forced_server_tool_on_openai_when_disabled(tool_choice={"type": "tool", "name": "web_search"},)with pytest.raises(InvalidRequestError, match="ENABLE_WEB_SERVER_TOOLS"):- service.create(request)+ await service.create(request)@pytest.mark.parametrize(@@ -179,6 +182,20 @@ def _stream_cm(response: httpx.Response) -> MagicMock:return cm+def _json_body(response: JSONResponse) -> dict[str, Any]:+ payload = json.loads(bytes(response.body).decode("utf-8"))+ assert isinstance(payload, dict)+ return payload+++async def _streaming_body_text(response: StreamingResponse) -> str:+ parts = [+ chunk.decode("utf-8") if isinstance(chunk, bytes) else str(chunk)+ async for chunk in response.body_iterator+ ]+ return "".join(parts)++def _aiohttp_response(status: int,*,@@ -372,6 +389,75 @@ async def test_streams_web_search_server_tool_result(monkeypatch):assert deltas[-1].data["usage"]["server_tool_use"] == {"web_search_requests": 1}+async def test_service_streams_forced_web_search_by_default(monkeypatch):+ async def fake_search(_query: str) -> list[dict[str, str]]:+ return [{"title": "DeepSeek V4 Released", "url": "https://example.com/v4"}]++ monkeypatch.setattr("api.web_tools.outbound._run_web_search", fake_search)+ settings = Settings.model_validate({"ENABLE_WEB_SERVER_TOOLS": True})+ provider_getter = MagicMock()+ service = MessagesHandler(+ settings,+ provider_getter=provider_getter,+ model_router=FixedProviderModelRouter(settings, _OPENAI_CHAT_PROVIDER_IDS[0]),+ )+ request = MessagesRequest(+ model="claude-haiku-4-5-20251001",+ max_tokens=100,+ messages=[Message(role="user", content="Search for DeepSeek V4")],+ tools=[Tool(name="web_search", type="web_search_20250305")],+ tool_choice={"type": "tool", "name": "web_search"},+ )++ response = await service.create(request)++ assert isinstance(response, StreamingResponse)+ assert response.media_type == "text/event-stream"+ raw = await _streaming_body_text(response)+ assert "event: message_start" in raw+ assert "DeepSeek V4 Released" in raw+ provider_getter.assert_not_called()+++async def test_service_aggregates_forced_web_search_when_stream_false(monkeypatch):+ async def fake_search(_query: str) -> list[dict[str, str]]:+ return [{"title": "DeepSeek V4 Released", "url": "https://example.com/v4"}]++ monkeypatch.setattr("api.web_tools.outbound._run_web_search", fake_search)+ settings = Settings.model_validate({"ENABLE_WEB_SERVER_TOOLS": True})+ provider_getter = MagicMock()+ service = MessagesHandler(+ settings,+ provider_getter=provider_getter,+ model_router=FixedProviderModelRouter(settings, _OPENAI_CHAT_PROVIDER_IDS[0]),+ )+ request = MessagesRequest(+ model="claude-haiku-4-5-20251001",+ max_tokens=100,+ messages=[Message(role="user", content="Search for DeepSeek V4")],+ stream=False,+ tools=[Tool(name="web_search", type="web_search_20250305")],+ tool_choice={"type": "tool", "name": "web_search"},+ )++ response = await service.create(request)++ assert isinstance(response, JSONResponse)+ assert response.headers["content-type"].startswith("application/json")+ body = _json_body(response)+ assert [block["type"] for block in body["content"]] == [+ "server_tool_use",+ "web_search_tool_result",+ "text",+ ]+ assert body["content"][1]["content"][0]["url"] == "https://example.com/v4"+ assert "DeepSeek V4 Released" in body["content"][2]["text"]+ assert body["usage"]["server_tool_use"] == {"web_search_requests": 1}+ provider_getter.assert_not_called()++@pytest.mark.asyncioasync def test_forced_web_fetch_ignores_stale_url_from_prior_user_turns(monkeypatch):"""Only the latest user message supplies the URL (not earlier transcript text)."""@@ -416,6 +502,49 @@ async def test_forced_web_fetch_ignores_stale_url_from_prior_user_turns(monkeypaassert target in raw+async def test_service_aggregates_forced_web_fetch_when_stream_false(monkeypatch):+ async def fake_fetch(url: str, _egress: WebFetchEgressPolicy) -> dict[str, str]:+ return {+ "url": url,+ "title": "Example Article",+ "media_type": "text/plain",+ "data": "Article body",+ }++ monkeypatch.setattr("api.web_tools.outbound._run_web_fetch", fake_fetch)+ settings = Settings.model_validate({"ENABLE_WEB_SERVER_TOOLS": True})+ provider_getter = MagicMock()+ service = MessagesHandler(+ settings,+ provider_getter=provider_getter,+ model_router=FixedProviderModelRouter(settings, _OPENAI_CHAT_PROVIDER_IDS[0]),+ )+ request = MessagesRequest(+ model="claude-haiku-4-5-20251001",+ max_tokens=100,+ messages=[Message(role="user", content="Fetch https://example.com/article")],+ stream=False,+ tools=[Tool(name="web_fetch", type="web_fetch_20250910")],+ tool_choice={"type": "tool", "name": "web_fetch"},+ )++ response = await service.create(request)++ assert isinstance(response, JSONResponse)+ assert response.headers["content-type"].startswith("application/json")+ body = _json_body(response)+ assert [block["type"] for block in body["content"]] == [+ "server_tool_use",+ "web_fetch_tool_result",+ "text",+ ]+ assert body["content"][1]["content"]["content"]["title"] == "Example Article"+ assert body["content"][2]["text"] == "Article body"+ assert body["usage"]["server_tool_use"] == {"web_fetch_requests": 1}+ provider_getter.assert_not_called()++@pytest.mark.asyncioasync def test_streams_web_fetch_server_tool_result(monkeypatch):async def fake_fetch(url: str, _egress: WebFetchEgressPolicy) -> dict[str, str]:@@ -593,8 +722,9 @@ async def test_drain_response_body_capped_stops_after_first_chunk_when_oversizedassert chunk_calls["n"] == 1@pytest.mark.parametrize("provider_id", _OPENAI_CHAT_PROVIDER_IDS)-def test_service_rejects_listed_server_tools_on_openai_chat(+async def test_service_rejects_listed_server_tools_on_openai_chat(provider_id: str,) -> None:settings = Settings()@@ -610,11 +740,12 @@ def test_service_rejects_listed_server_tools_on_openai_chat(tools=[Tool(name="web_search", type="web_search_20250305")],)with pytest.raises(InvalidRequestError, match="OpenAI Chat upstreams"):- service.create(request)+ await service.create(request)@pytest.mark.parametrize("provider_id", _ANTHROPIC_MESSAGES_PROVIDER_IDS)-def test_listed_server_tools_routed_on_anthropic_messages_providers(+async def test_listed_server_tools_routed_on_anthropic_messages_providers(provider_id: str,) -> None:"""Native Anthropic transports may receive listed server tool definitions."""@@ -637,12 +768,13 @@ def test_listed_server_tools_routed_on_anthropic_messages_providers(messages=[Message(role="user", content="q")],tools=[Tool(name="web_search", type="web_search_20250305")],)- service.create(request)+ await service.create(request)mock_provider.preflight_stream.assert_called()@pytest.mark.parametrize("provider_id", _ANTHROPIC_MESSAGES_PROVIDER_IDS)-def test_forced_server_tools_routed_on_anthropic_messages_providers_when_local_disabled(+async def test_forced_server_tools_routed_on_anthropic_messages_providers_when_local_disabled(provider_id: str,) -> None:"""Native Anthropic transports may receive forced server tools when local tools are off."""@@ -666,5 +798,5 @@ def test_forced_server_tools_routed_on_anthropic_messages_providers_when_local_dtools=[Tool(name="web_search", type="web_search_20250305")],tool_choice={"type": "tool", "name": "web_search"},)- service.create(request)+ await service.create(request)mock_provider.preflight_stream.assert_called()diff --git a/tests/providers/test_anthropic_messages.py b/tests/providers/test_anthropic_messages.pyindex 28ba76ef..fcf97012 100644--- a/tests/providers/test_anthropic_messages.py+++ b/tests/providers/test_anthropic_messages.py@@ -179,6 +179,30 @@ def test_default_request_body_preserves_thinking_budget(provider_config):assert body["thinking"] == {"type": "enabled", "budget_tokens": 4096}+async def test_send_stream_request_forces_upstream_streaming(provider_config):+ provider = NativeProvider(provider_config)+ 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++@pytest.mark.asyncioasync def test_stream_uses_retry_builds_request_and_closes_response(provider_config,diff --git a/uv.lock b/uv.lockindex e560f392..beda0f55 100644--- a/uv.lock+++ b/uv.lock@@ -561,7 +561,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "2.5.1"+version = "2.5.2"source = { editable = "." }dependencies = [{ name = "aiohttp" },