Spaces:
Running
Running
sync: upstream 8dfff832 (v6.18.5) + custom addons (KeyRotator, 401/403 rotation, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
2e7b8ca Download src/free_claude_code/api/request_outcomes.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 5.12 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/api/request_outcomes.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/src/free_claude_code/api/request_outcomes.py
-
curl -L -o request_outcomes.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/src/free_claude_code/api/request_outcomes.py
5.12 kB
| 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) | |