File size: 5,116 Bytes
e99df76
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e7b8ca
 
e99df76
 
 
 
2e7b8ca
 
 
 
 
e99df76
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e7b8ca
e99df76
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e7b8ca
 
 
 
 
e99df76
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e7b8ca
e99df76
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
from __future__ import annotations
"""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,
)

from .generation_paths import generation_api

_FAILURE_EVENTS = frozenset({"error", "response.error", "response.failed"})


def _observe_event(event: SSEEvent) -> None:
    kind = (
        event.event
        or event.data.get("type")
        or ("error" if "error" in event.data else None)
    )
    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 generation_api(scope.get("path", "")) is None
        ):
            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=None
                        if generation_api(scope["path"]) == "gemini"
                        else _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=generation_api(scope["path"]),
                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)