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
4.8 KB
Raw Blame
"""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)