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

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.py
index 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 RequestOutcomeMiddleware
from .routes import router
from .validation_log import summarize_request_validation_body
@@ -47,6 +48,7 @@ def create_app(services: ApiServices) -> FastAPI:
app.state.services = services
app.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.py
index 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_message
from free_claude_code.core.failures import ExecutionFailure, find_execution_failure
from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
+from free_claude_code.core.request_outcomes import record_request_route
from free_claude_code.core.trace import trace_event
from .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.py
index 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_route
class 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.py
index 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.py
new file mode 100644
index 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.py
index 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_event
TERMINAL_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.py
index 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_route
from 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_seconds
for index, target in enumerate(candidates):
+ record_request_route(target.provider_id, target.provider_model)
provider_stream: AsyncIterator[str] | None = None
candidate_committed = False
candidate_failure: ExecutionFailure | None = None
diff --git a/src/free_claude_code/core/anthropic/stream_contracts.py b/src/free_claude_code/core/anthropic/stream_contracts.py
index 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:
+ return
data_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.py
index 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_names
self._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_end
remainder = 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 None
diff --git a/tests/core/anthropic/test_sse_decoder.py b/tests/core/anthropic/test_sse_decoder.py
index 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)