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
patch: Log final inference request outcomes at INFO (#1943)
Ali Khokharc2a4c5a7d2ca
diff --git a/src/free_claude_code/api/app.py b/src/free_claude_code/api/app.pyindex 215315fb..77c8c67c 100644--- a/src/free_claude_code/api/app.py+++ b/src/free_claude_code/api/app.py@@ -37,6 +37,7 @@ from .request_ids import (get_request_id,)from .request_lifetime import ClientRequestLifetimeMiddleware+from .request_outcomes import RequestOutcomeMiddlewarefrom .routes import routerfrom .validation_log import summarize_request_validation_body@@ -47,6 +48,7 @@ def create_app(services: ApiServices) -> FastAPI:app.state.services = servicesapp.add_middleware(AdminNoStoreMiddleware)app.add_middleware(ClientRequestLifetimeMiddleware)+ app.add_middleware(RequestOutcomeMiddleware)app.add_middleware(RequestCorrelationMiddleware)app.include_router(admin_router)diff --git a/src/free_claude_code/api/handlers/messages.py b/src/free_claude_code/api/handlers/messages.pyindex 2dfd9e5f..505a2565 100644--- a/src/free_claude_code/api/handlers/messages.py+++ b/src/free_claude_code/api/handlers/messages.py@@ -42,6 +42,7 @@ from free_claude_code.core.anthropic import (from free_claude_code.core.diagnostics import safe_exception_messagefrom free_claude_code.core.failures import ExecutionFailure, find_execution_failurefrom free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy+from free_claude_code.core.request_outcomes import record_request_routefrom free_claude_code.core.trace import trace_eventfrom .classifier_response import classifier_response@@ -103,6 +104,10 @@ class MessagesHandler:require_non_empty_messages(request_data.messages)routed = self._model_router.resolve_messages_request(request_data)routed = self._apply_message_routing_policies(routed)+ record_request_route(+ routed.resolved.primary.provider_id,+ routed.resolved.primary.provider_model,+ )tool_body = self._web_tools.try_stream_messages(routed, request_id=request_id)diff --git a/src/free_claude_code/api/handlers/responses.py b/src/free_claude_code/api/handlers/responses.pyindex abd90f2e..8c10f100 100644--- a/src/free_claude_code/api/handlers/responses.py+++ b/src/free_claude_code/api/handlers/responses.py@@ -29,6 +29,7 @@ from free_claude_code.core.openai_responses import (openai_error_type_for_failure,openai_failure_payload,)+from free_claude_code.core.request_outcomes import record_request_routeclass ResponsesHandler:@@ -77,6 +78,10 @@ class ResponsesHandler:try:routed = self._model_router.resolve_responses_request(request_data)+ record_request_route(+ routed.resolved.primary.provider_id,+ routed.resolved.primary.provider_model,+ )streamed = self._provider_executor.stream_responses(routed,raw_log_payload=request_payload,diff --git a/src/free_claude_code/api/request_errors.py b/src/free_claude_code/api/request_errors.pyindex 4607250e..83b093ec 100644--- a/src/free_claude_code/api/request_errors.py+++ b/src/free_claude_code/api/request_errors.py@@ -21,6 +21,10 @@ from free_claude_code.core.openai_responses import (openai_error_payload,openai_error_type_for_failure,)+from free_claude_code.core.request_outcomes import (+ record_request_exception,+ record_request_failure,+)WireApi = Literal["messages", "responses"]@@ -37,6 +41,7 @@ def ordinary_application_error_response(request_id: str,) -> JSONResponse:"""Serialize a deterministic application error without terminal headers."""+ record_request_failure(error.kind.value)if wire_api == "responses":return JSONResponse(status_code=error.status_code,@@ -67,6 +72,7 @@ def log_unexpected_api_exception(request_id: str | None = None,) -> None:"""Log API failures without echoing exception text unless opted in."""+ record_request_exception(exc)if settings.log_api_error_tracebacks:if request_id is not None:logger.error(diff --git a/src/free_claude_code/api/request_outcomes.py b/src/free_claude_code/api/request_outcomes.pynew file mode 100644index 00000000..c1d63d68--- /dev/null+++ b/src/free_claude_code/api/request_outcomes.py@@ -0,0 +1,126 @@+"""Log one final inference outcome after HTTP delivery and owned cleanup."""++import asyncio+import codecs+from time import monotonic++from loguru import logger+from starlette.datastructures import Headers+from starlette.types import ASGIApp, Message, Receive, Scope, Send++from free_claude_code.core.anthropic.stream_contracts import SSEEvent+from free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoder+from free_claude_code.core.request_outcomes import (+ RequestOutcome,+ current_request_outcome,+ record_request_exception,+ record_request_failure,+)++_FAILURE_EVENTS = frozenset({"error", "response.error", "response.failed"})+++def _observe_event(event: SSEEvent) -> None:+ kind = event.event or event.data.get("type")+ if not isinstance(kind, str) or kind not in _FAILURE_EVENTS:+ return+ response = event.data.get("response")+ payload = response if isinstance(response, dict) else event.data+ error = payload.get("error")+ error = error if isinstance(error, dict) else payload+ reason = error.get("code") or error.get("type")+ record_request_failure(reason if isinstance(reason, str) else str(kind))+++class RequestOutcomeMiddleware:+ """Observe inference delivery without changing its body or control flow."""++ def __init__(self, app: ASGIApp) -> None:+ self._app = app++ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:+ if (+ scope["type"] != "http"+ or scope.get("method") != "POST"+ or scope.get("path") not in {"/v1/messages", "/v1/responses"}+ ):+ await self._app(scope, receive, send)+ return++ started = monotonic()+ outcome = RequestOutcome()+ status_code: int | None = None+ completed = disconnected = cancelled = False+ decoder: AnthropicSSEDecoder | None = None+ text_decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")++ async def receive_observed() -> Message:+ nonlocal disconnected+ message = await receive()+ if message["type"] == "http.disconnect":+ disconnected = True+ return message++ async def send_observed(message: Message) -> None:+ nonlocal status_code, completed, decoder, disconnected+ try:+ await send(message)+ except OSError:+ disconnected = True+ raise+ if message["type"] == "http.response.start":+ status_code = message["status"]+ if (+ Headers(raw=message.get("headers", []))+ .get("content-type", "")+ .startswith("text/event-stream")+ ):+ decoder = AnthropicSSEDecoder(event_names=_FAILURE_EVENTS)+ elif message["type"] == "http.response.body":+ completed = not message.get("more_body", False)+ if decoder is not None:+ text = text_decoder.decode(+ message.get("body", b""), final=completed+ )+ for event in decoder.feed(text):+ _observe_event(event)+ if completed:+ for event in decoder.finish():+ _observe_event(event)++ token = current_request_outcome.set(outcome)+ try:+ await self._app(scope, receive_observed, send_observed)+ except asyncio.CancelledError:+ cancelled = True+ raise+ except BaseException as error:+ if not disconnected:+ record_request_exception(error)+ if status_code is None:+ status_code = 500+ raise+ finally:+ current_request_outcome.reset(token)+ reason = outcome.failure_reason+ if reason is not None or (status_code is not None and status_code >= 400):+ result = "failure"+ reason = reason or f"http_{status_code}"+ elif (cancelled or disconnected) and not completed:+ result = "cancelled"+ elif not completed:+ result, reason = "failure", "incomplete_response"+ else:+ result = "success"+ logger.bind(+ event="request.completed",+ wire_api="responses"+ if scope["path"] == "/v1/responses"+ else "messages",+ provider_id=outcome.provider_id,+ model=outcome.model,+ status_code=status_code,+ outcome=result,+ duration_ms=round((monotonic() - started) * 1000, 2),+ failure_reason=reason,+ ).info("Inference request {}", result)diff --git a/src/free_claude_code/api/response_streams.py b/src/free_claude_code/api/response_streams.pyindex 136b469c..2a1777af 100644--- a/src/free_claude_code/api/response_streams.py+++ b/src/free_claude_code/api/response_streams.py@@ -28,6 +28,10 @@ from free_claude_code.core.openai_responses import (committed_response_failure_frame,openai_error_type_for_failure,)+from free_claude_code.core.request_outcomes import (+ record_request_exception,+ record_request_failure,+)from free_claude_code.core.trace import close_stream_input, trace_eventTERMINAL_EXECUTION_ERROR_HEADERS = {"x-should-retry": "false"}@@ -198,6 +202,10 @@ def trace_terminal_execution_error(error: BaseException | None = None,) -> None:"""Record one correlated terminal-execution decision at the HTTP boundary."""+ if error is not None:+ record_request_exception(error)+ else:+ record_request_failure(error_type)fields: dict[str, object] = {"stage": "egress","event": "free_claude_code.api.response.terminal_execution_error",diff --git a/src/free_claude_code/application/execution.py b/src/free_claude_code/application/execution.pyindex 0181bddb..03c9582b 100644--- a/src/free_claude_code/application/execution.py+++ b/src/free_claude_code/application/execution.py@@ -23,6 +23,7 @@ from free_claude_code.core.openai_responses import (estimate_responses_input_tokens,)from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.core.request_outcomes import record_request_routefrom free_claude_code.core.trace import (close_stream_input,trace_event,@@ -341,6 +342,7 @@ class ProviderExecutor:loop = asyncio.get_running_loop()progress_deadline = loop.time() + self._progress_timeout_secondsfor index, target in enumerate(candidates):+ record_request_route(target.provider_id, target.provider_model)provider_stream: AsyncIterator[str] | None = Nonecandidate_committed = Falsecandidate_failure: ExecutionFailure | None = Nonediff --git a/src/free_claude_code/core/anthropic/stream_contracts.py b/src/free_claude_code/core/anthropic/stream_contracts.pyindex a5aa76d3..270917c5 100644--- a/src/free_claude_code/core/anthropic/stream_contracts.py+++ b/src/free_claude_code/core/anthropic/stream_contracts.py@@ -47,7 +47,10 @@ class SSEEvent:raw: str-def parse_sse_lines(lines: Iterable[str]) -> list[SSEEvent]:+def parse_sse_lines(+ lines: Iterable[str], *, event_names: frozenset[str] | None = None+) -> list[SSEEvent]:+ """Decode selected named events and all unnamed events when a filter is supplied."""events: list[SSEEvent] = []current_event = ""data_parts: list[str] = []@@ -56,7 +59,7 @@ def parse_sse_lines(lines: Iterable[str]) -> list[SSEEvent]:for line in lines:stripped = line.rstrip("\r\n")if stripped == "":- _append_event(events, current_event, data_parts, raw_parts)+ _append_event(events, current_event, data_parts, raw_parts, event_names)current_event = ""data_parts = []raw_parts = []@@ -67,13 +70,15 @@ def parse_sse_lines(lines: Iterable[str]) -> list[SSEEvent]:elif stripped.startswith("data:"):data_parts.append(stripped.split(":", 1)[1].strip())- _append_event(events, current_event, data_parts, raw_parts)+ _append_event(events, current_event, data_parts, raw_parts, event_names)return events-def parse_sse_text(text: str) -> list[SSEEvent]:+def parse_sse_text(+ text: str, *, event_names: frozenset[str] | None = None+) -> list[SSEEvent]:# SSE uses CR/LF framing; Unicode line separators can occur inside JSON text.- return parse_sse_lines(re.split(r"\r\n|\r|\n", text))+ return parse_sse_lines(re.split(r"\r\n|\r|\n", text), event_names=event_names)def _append_event(@@ -81,9 +86,12 @@ def _append_event(current_event: str,data_parts: list[str],raw_parts: list[str],+ event_names: frozenset[str] | None,) -> None:if not current_event and not data_parts:return+ if event_names is not None and current_event and current_event not in event_names:+ returndata_text = "\n".join(data_parts)data: dict[str, Any]try:diff --git a/src/free_claude_code/core/anthropic/streaming/decoder.py b/src/free_claude_code/core/anthropic/streaming/decoder.pyindex 6c7f66a3..efabb81f 100644--- a/src/free_claude_code/core/anthropic/streaming/decoder.py+++ b/src/free_claude_code/core/anthropic/streaming/decoder.py@@ -8,14 +8,15 @@ _EVENT_BOUNDARY = re.compile(r"(?>\r\n|\r|\n){2}")class AnthropicSSEDecoder:- """Decode arbitrarily split SSE text without losing frame order."""+ """Decode split SSE text, optionally filtering named events before JSON parsing."""- def __init__(self) -> None:+ def __init__(self, *, event_names: frozenset[str] | None = None) -> None:+ self._event_names = event_namesself._parts: list[str] = []self._boundary_tail = ""def feed(self, chunk: str) -> tuple[SSEEvent, ...]:- """Consume one wire chunk and return every complete event."""+ """Consume one wire chunk and return its selected complete events."""events: list[SSEEvent] = []probe = self._boundary_tail + chunk@@ -26,7 +27,7 @@ class AnthropicSSEDecoder:self._parts.append(chunk[chunk_start:chunk_end])raw = "".join(self._parts)self._parts.clear()- events.extend(parse_sse_text(raw))+ events.extend(parse_sse_text(raw, event_names=self._event_names))chunk_start = chunk_endremainder = chunk[chunk_start:]@@ -46,4 +47,4 @@ class AnthropicSSEDecoder:self._boundary_tail = ""if not remainder.strip():return ()- return tuple(parse_sse_text(remainder))+ return tuple(parse_sse_text(remainder, event_names=self._event_names))diff --git a/src/free_claude_code/core/request_outcomes.py b/src/free_claude_code/core/request_outcomes.pynew file mode 100644index 00000000..934c2b96--- /dev/null+++ b/src/free_claude_code/core/request_outcomes.py@@ -0,0 +1,38 @@+"""Request-scoped diagnostic fields shared by routing and HTTP delivery."""++from contextvars import ContextVar+from dataclasses import dataclass++from .failures import find_execution_failure+++@dataclass+class RequestOutcome:+ """Mutable fields shared with the request's response and cleanup tasks."""++ provider_id: str | None = None+ model: str | None = None+ failure_reason: str | None = None+++current_request_outcome: ContextVar[RequestOutcome | None] = ContextVar(+ "request_outcome", default=None+)+++def record_request_route(provider_id: str, model: str) -> None:+ outcome = current_request_outcome.get()+ if outcome is not None:+ outcome.provider_id = provider_id+ outcome.model = model+++def record_request_failure(reason: str) -> None:+ outcome = current_request_outcome.get()+ if outcome is not None and outcome.failure_reason is None:+ outcome.failure_reason = reason+++def record_request_exception(error: BaseException) -> None:+ failure = find_execution_failure(error)+ record_request_failure(failure.kind.value if failure else type(error).__name__)diff --git a/tests/api/test_request_outcomes.py b/tests/api/test_request_outcomes.pynew file mode 100644index 00000000..e45a98b3--- /dev/null+++ b/tests/api/test_request_outcomes.py@@ -0,0 +1,438 @@+"""Final inference outcomes include failures hidden inside HTTP 200 streams."""++import asyncio+import json+from unittest.mock import patch++import pytest+from fastapi.testclient import TestClient+from loguru import logger++from free_claude_code.api.request_ids import RequestCorrelationMiddleware+from free_claude_code.api.request_outcomes import RequestOutcomeMiddleware+from free_claude_code.config.settings import Settings+from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.request_outcomes import (+ current_request_outcome,+ record_request_route,+)+from tests.api.support import create_test_app+from tests.api.test_request_lifetime import _http_scope+++def outcomes():+ records = []+ sink = logger.add(+ lambda message: records.append(message.record),+ level="INFO",+ filter=lambda record: record["extra"].get("event") == "request.completed",+ )+ try:+ yield records+ finally:+ logger.remove(sink)+++class OutcomeProvider:+ def __init__(self, result):+ self.result = result+ self.started = asyncio.Event()++ async def stream_messages(self, request, **kwargs):+ async for chunk in self._stream("messages"):+ yield chunk++ async def stream_responses(self, request, **kwargs):+ async for chunk in self._stream("responses"):+ yield chunk++ async def _stream(self, wire_api):+ failure = ExecutionFailure(+ FailureKind.RATE_LIMIT, 429, "private error text", True+ )+ if self.result == "wait_before_start":+ self.started.set()+ await asyncio.Event().wait()+ if self.result == "pre_start":+ raise failure+ if wire_api == "responses":+ yield 'event: response.created\ndata: {"type":"response.created","response":{"id":"resp_test","object":"response","status":"in_progress","output":[]}}\n\n'+ else:+ yield 'event: message_start\ndata: {"type":"message_start","message":{"id":"msg_test","type":"message","role":"assistant","content":[]}}\n\n'+ if self.result == "exception":+ raise failure+ if self.result == "wait_after_start":+ self.started.set()+ await asyncio.Event().wait()+ if self.result == "wire_error":+ event = "error" if wire_api == "messages" else "response.failed"+ data = {"type": event, "error": {"type": "rate_limit_error"}}+ if wire_api == "responses":+ data = {+ "type": event,+ "response": {"status": "failed", "error": data["error"]},+ }+ frame = f"event: {event}\ndata: {json.dumps(data)}\n\n"+ # Framing must work even when a wire event is split between chunks.+ yield frame[:12]+ yield frame[12:]+ else:+ yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'++[email protected]("wire_api", ["messages", "responses"])[email protected]("result", ["success", "pre_start", "exception", "wire_error"])+def test_one_final_outcome_for_streamed_inference(outcomes, wire_api, result):+ payload = {"model": "nvidia_nim/test-model", "stream": True}+ if wire_api == "messages":+ payload.update(+ max_tokens=64, messages=[{"role": "user", "content": "private input"}]+ )+ else:+ payload["input"] = "private input"+ with (+ patch(+ "free_claude_code.api.routes.resolve_provider",+ return_value=OutcomeProvider(result),+ ),+ TestClient(create_test_app(Settings())) as client,+ ):+ response = client.post(f"/v1/{wire_api}", json=payload)+ assert response.status_code == (429 if result == "pre_start" else 200)+ assert len(outcomes) == 1+ record = outcomes[0]+ fields = record["extra"]+ assert record["level"].name == "INFO"+ assert fields["request_id"] == response.headers["request-id"]+ assert fields["provider_id"] == "nvidia_nim"+ assert fields["model"] == "test-model"+ assert fields["wire_api"] == wire_api+ assert fields["status_code"] == response.status_code+ assert fields["outcome"] == ("success" if result == "success" else "failure")+ assert fields["duration_ms"] >= 0+ assert (+ fields["failure_reason"]+ == {+ "success": None,+ "pre_start": "rate_limit",+ "exception": "rate_limit",+ "wire_error": "rate_limit_error",+ }[result]+ )+ assert "private input" not in str(record)+ assert "private error text" not in str(record)+++def test_fallback_records_selected_provider_without_logging_failed_attempt(outcomes):+ settings = Settings(model_fallbacks=["open_router/fallback-model"])+ providers = {+ "nvidia_nim": OutcomeProvider("pre_start"),+ "open_router": OutcomeProvider("success"),+ }+ with (+ patch(+ "free_claude_code.api.routes.resolve_provider",+ side_effect=lambda name, **kwargs: providers[name],+ ),+ TestClient(create_test_app(settings)) as client,+ ):+ response = client.post(+ "/v1/messages",+ json={+ "model": "nvidia_nim/test-model",+ "messages": [{"role": "user", "content": "Hello"}],+ "stream": True,+ },+ )+ assert response.status_code == 200+ assert len(outcomes) == 1+ fields = outcomes[0]["extra"]+ assert (+ fields["provider_id"],+ fields["model"],+ fields["outcome"],+ fields["failure_reason"],+ ) == (+ "open_router",+ "fallback-model",+ "success",+ None,+ )++[email protected]("result", ["success", "exception", "wire_error"])+def test_non_streaming_messages_have_one_outcome(outcomes, result):+ with (+ patch(+ "free_claude_code.api.routes.resolve_provider",+ return_value=OutcomeProvider(result),+ ),+ TestClient(create_test_app(Settings())) as client,+ patch(+ "free_claude_code.api.request_outcomes.monotonic", side_effect=[10.0, 12.5]+ ),+ ):+ response = client.post(+ "/v1/messages",+ json={+ "model": "nvidia_nim/test-model",+ "messages": [{"role": "user", "content": "Hello"}],+ "stream": False,+ },+ )+ assert response.status_code == (200 if result == "success" else 429)+ assert len(outcomes) == 1+ assert outcomes[0]["extra"]["duration_ms"] == 2500+ assert outcomes[0]["extra"]["outcome"] == (+ "success" if result == "success" else "failure"+ )+++ "payload,status,reason",+ [+ ({}, 422, "http_422"),+ (+ {"model": "nvidia_nim/test-model", "input": "hello", "stream": False},+ 400,+ "invalid_request",+ ),+ ],+)+def test_rejections_before_execution_are_recorded(outcomes, payload, status, reason):+ with TestClient(create_test_app(Settings())) as client:+ response = client.post("/v1/responses", json=payload)+ assert response.status_code == status+ assert len(outcomes) == 1+ fields = outcomes[0]["extra"]+ assert fields["outcome"] == "failure"+ assert fields["failure_reason"] == reason+ assert fields["provider_id"] is None++[email protected]("wire_api", ["messages", "responses"])[email protected]("stage", ["wait_before_start", "wait_after_start"])+async def test_disconnect_logs_cancellation_after_cleanup(outcomes, wire_api, stage):+ provider = OutcomeProvider(stage)+ frames = asyncio.Queue()+ payload = {"model": "nvidia_nim/test-model", "stream": True}+ payload.update(+ {"messages": [{"role": "user", "content": "hello"}]}+ if wire_api == "messages"+ else {"input": "hello"}+ )+ await frames.put({"type": "http.request", "body": json.dumps(payload).encode()})+ sent = []++ async def send(message):+ sent.append(message)++ with patch("free_claude_code.api.routes.resolve_provider", return_value=provider):+ app = create_test_app(Settings())+ scope = _http_scope(f"/v1/{wire_api}")+ scope["headers"] = [(b"content-type", b"application/json")]+ task = asyncio.create_task(app(scope, frames.get, send))+ try:+ async with asyncio.timeout(5):+ await provider.started.wait()+ assert outcomes == []+ await frames.put({"type": "http.disconnect"})+ await task+ finally:+ task.cancel()+ await asyncio.gather(task, return_exceptions=True)+ assert len(outcomes) == 1+ fields = outcomes[0]["extra"]+ assert fields["outcome"] == "cancelled"+ assert fields["status_code"] == (200 if stage == "wait_after_start" else None)+ assert fields["provider_id"] == "nvidia_nim"+ assert current_request_outcome.get() is None+++ "path,method",+ [+ ("/health", "GET"),+ ("/v1/models", "GET"),+ ("/admin/api/status", "GET"),+ ("/v1/messages/count_tokens", "POST"),+ ("/v1/messages", "OPTIONS"),+ ],+)+async def test_other_endpoints_do_not_emit_inference_outcomes(outcomes, path, method):+ async def app(scope, receive, send):+ assert current_request_outcome.get() is None+ await send({"type": "http.response.start", "status": 200})+ await send({"type": "http.response.body", "body": b"{}"})++ async def receive():+ return {"type": "http.disconnect"}++ async def send(message):+ pass++ await RequestOutcomeMiddleware(app)(_http_scope(path, method=method), receive, send)+ assert outcomes == []+++ "ending", ["send_failure", "late_disconnect", "exception", "cancelled"]+)+async def test_delivery_outcomes_preserve_control_flow(outcomes, ending):+ async def app(scope, receive, send):+ if ending == "exception":+ raise ValueError("private exception message")+ if ending == "cancelled":+ raise asyncio.CancelledError()+ await send({"type": "http.response.start", "status": 200})+ await send({"type": "http.response.body", "body": b"{}"})+ await receive()++ async def receive():+ return {"type": "http.disconnect"}++ async def send(message):+ if ending == "send_failure" and message["type"] == "http.response.body":+ raise OSError("connection closed")++ middleware = RequestCorrelationMiddleware(RequestOutcomeMiddleware(app))+ if ending == "late_disconnect":+ await middleware(_http_scope(), receive, send)+ else:+ with pytest.raises(+ {+ "exception": ValueError,+ "cancelled": asyncio.CancelledError,+ "send_failure": OSError,+ }[ending]+ ):+ await middleware(_http_scope(), receive, send)+ assert len(outcomes) == 1+ fields = outcomes[0]["extra"]+ assert (+ fields["outcome"]+ == {+ "send_failure": "cancelled",+ "late_disconnect": "success",+ "exception": "failure",+ "cancelled": "cancelled",+ }[ending]+ )+ assert fields["failure_reason"] == ("ValueError" if ending == "exception" else None)+ assert "private exception message" not in str(outcomes)+ assert current_request_outcome.get() is None++[email protected]("event_header", ["event: error\r\n", ""])+async def test_wire_observation_preserves_split_utf8_body(outcomes, event_header):+ frame = (+ event_header+ + 'data: {"type":"error","error":{"type":"api_error","message":"☃"}}\r\n\r\n'+ ).encode()+ chunks = [frame[index : index + 2] for index in range(0, len(frame), 2)]+ sent = []++ async def app(scope, receive, send):+ await send(+ {+ "type": "http.response.start",+ "status": 200,+ "headers": [(b"content-type", b"text/event-stream")],+ }+ )+ for chunk in chunks:+ await send({"type": "http.response.body", "body": chunk, "more_body": True})+ await send({"type": "http.response.body", "body": b""})++ async def receive():+ return {"type": "http.disconnect"}++ async def send(message):+ sent.append(message)++ await RequestCorrelationMiddleware(RequestOutcomeMiddleware(app))(+ _http_scope(), receive, send+ )+ assert b"".join(message.get("body", b"") for message in sent) == frame+ assert len(outcomes) == 1+ assert outcomes[0]["extra"]["outcome"] == "failure"+ assert outcomes[0]["extra"]["failure_reason"] == "api_error"+ assert "☃" not in str(outcomes)+++async def test_successful_named_events_skip_json_decoding(outcomes):+ frame = (+ b'event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"hello"}\n\n'+ b'event: response.completed\ndata: {"type":"response.completed","response":{"output":[]}}\n\n'+ )++ async def app(scope, receive, send):+ await send(+ {+ "type": "http.response.start",+ "status": 200,+ "headers": [(b"content-type", b"text/event-stream")],+ }+ )+ await send({"type": "http.response.body", "body": frame})++ async def receive():+ return {"type": "http.disconnect"}++ async def send(message):+ pass++ with patch(+ "free_claude_code.core.anthropic.stream_contracts.json.loads", wraps=json.loads+ ) as loads:+ await RequestCorrelationMiddleware(RequestOutcomeMiddleware(app))(+ _http_scope("/v1/responses"), receive, send+ )+ loads.assert_not_called()+ assert len(outcomes) == 1+ assert outcomes[0]["extra"]["outcome"] == "success"+++async def test_overlapping_requests_keep_separate_outcomes(outcomes):+ ready = asyncio.Event()+ count = 0++ async def app(scope, receive, send):+ nonlocal count+ name = scope["query_string"].decode()+ record_request_route(name, f"{name}-model")+ count += 1+ if count == 2:+ ready.set()+ await ready.wait()+ await send({"type": "http.response.start", "status": 200})+ await send({"type": "http.response.body", "body": b"{}"})++ async def receive():+ await asyncio.Event().wait()++ async def send(message):+ pass++ middleware = RequestCorrelationMiddleware(RequestOutcomeMiddleware(app))+ scopes = [_http_scope(), _http_scope()]+ for scope, name in zip(scopes, [b"first", b"second"], strict=True):+ scope["query_string"] = name+ async with asyncio.timeout(5):+ await asyncio.gather(*(middleware(scope, receive, send) for scope in scopes))+ assert len(outcomes) == 2+ assert {+ (row["extra"]["provider_id"], row["extra"]["model"]) for row in outcomes+ } == {+ ("first", "first-model"),+ ("second", "second-model"),+ }+ assert len({row["extra"]["request_id"] for row in outcomes}) == 2+ assert current_request_outcome.get() is Nonediff --git a/tests/core/anthropic/test_sse_decoder.py b/tests/core/anthropic/test_sse_decoder.pyindex 2d9821ab..50ee375e 100644--- a/tests/core/anthropic/test_sse_decoder.py+++ b/tests/core/anthropic/test_sse_decoder.py@@ -1,3 +1,8 @@+import json+from unittest.mock import patch++import pytest+from free_claude_code.core.anthropic.streaming import AnthropicSSEDecoder@@ -26,6 +31,42 @@ def test_decoder_returns_one_unterminated_final_event():assert decoder.finish() == ()[email protected]("ending", ["\n\n", ""])+def test_event_filter_skips_json_and_preserves_unnamed_events_at_every_split(ending):+ wire = (+ 'event: delta\r\ndata: {"text":"ignored"}\r\n\r\n'+ 'data: {"type":"error"}\nevent: error\n\n'+ 'data: {"type":"response.failed"}\r\n\r\n'+ 'event: delta\ndata: {"text":"ignored final"}' + ending+ )+ for split in range(len(wire) + 1):+ decoder = AnthropicSSEDecoder(event_names=frozenset({"error"}))+ with patch(+ "free_claude_code.core.anthropic.stream_contracts.json.loads",+ wraps=json.loads,+ ) as loads:+ events = (+ *decoder.feed(wire[:split]),+ *decoder.feed(wire[split:]),+ *decoder.finish(),+ )+ assert [(event.event, event.data["type"]) for event in events] == [+ ("error", "error"),+ ("", "response.failed"),+ ]+ assert [call.args[0] for call in loads.call_args_list] == [+ '{"type":"error"}',+ '{"type":"response.failed"}',+ ]+ assert decoder.finish() == ()+++def test_event_filter_decodes_selected_unterminated_event():+ decoder = AnthropicSSEDecoder(event_names=frozenset({"error"}))+ assert decoder.feed('event: error\ndata: {"type":"error"}') == ()+ assert [event.data for event in decoder.finish()] == [{"type": "error"}]++def test_decoder_handles_many_tiny_fragments_without_losing_frames():wire = "".join(f'event: delta\ndata: {{"index":{index}}}\n\n' for index in range(250)