claude-proxy / src /free_claude_code /api /stream_delivery.py
dheraingoud's picture
Copilot App
Sync upstream v6.19.35 and preserve custom addons
a9e27c0
Raw History Blame Contribute Delete
19.4 kB
from __future__ import annotations
"""Own public projection, tool release, recovery mapping and wire termination."""
import re
from collections.abc import AsyncGenerator, AsyncIterator, Callable, Iterator
from copy import deepcopy
from typing import Any, Literal
try:
import simplejson
except ImportError:
import json as simplejson
from free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoder
from free_claude_code.core.async_iterators import try_close_async_iterator
from free_claude_code.core.continuation_stream import ContinuationStream
from free_claude_code.core.delivered_response import DeliveredResponse
from free_claude_code.core.failures import (
ExecutionFailure,
FailureKind,
find_execution_failure,
)
from free_claude_code.core.gemini.response import gemini_finished, gemini_parts
from free_claude_code.core.replay_finalization import finalize_replay
from free_claude_code.core.stream_delivery import (
StreamDeliveryState,
bind_stream_delivery,
)
from free_claude_code.core.stream_output import StreamOutput, call_references
from .classifier_projection import ClassifierProjection
from .stream_frames import frame_data, replace_frame_data
class DeliveryObservedStream(AsyncIterator[StreamOutput]):
"""Bind observation for each read/close, including prefetch in another task."""
def __init__(
self, body: AsyncIterator[StreamOutput], state: StreamDeliveryState
) -> None:
self._body = body
self._state = state
def __aiter__(self) -> DeliveryObservedStream:
return self
async def __anext__(self) -> StreamOutput:
with bind_stream_delivery(self._state):
return await anext(self._body)
async def aclose(self) -> None:
with bind_stream_delivery(self._state):
error = await try_close_async_iterator(self._body)
if error is not None:
raise error
class PublicResponseStream(AsyncIterator[str]):
"""Publish one response while providers retain their physical request loops."""
def __init__(
self,
body: AsyncIterator[StreamOutput],
state: StreamDeliveryState,
*,
wire_api: Literal["messages", "responses", "gemini", "chat"],
first_chunk: StreamOutput,
terminal_frame: Callable[[str, str, BaseException], str] | None,
terminal_failure_observer: Callable[[BaseException], None] | None,
hide_reasoning: bool = False,
) -> None:
self._body = body
self.state = state
self._wire_api = wire_api
self._revision = state.attempt_revision
self._hide_reasoning = hide_reasoning
self._decoder = AnthropicSSEDecoder()
self._projection = ClassifierProjection() if hide_reasoning else None
self._delivered = DeliveredResponse(wire_api)
self._continuation = ContinuationStream(self._delivered)
state.bind_prefix(self._delivered.snapshot)
self._published_starts: set[str] = set()
self._seen_starts: set[str] = set()
self._replacement = False
self._public_id: str | None = None
self._created_at: object = None
self._sequence = -1
self._pending_starts: list[str] = []
self._replay_carriers: dict[str, str] = {}
self.start_frame = ""
self._initial_chunk = "".join(first_chunk.frames)
self._latest_chunk = ""
self._terminal_frame = terminal_frame
self._terminal_failure_observer = terminal_failure_observer
self._done = False
self._closed = False
self._pending_release = False
self._pending_call_proofs: set[tuple[object, ...]] = set()
self._events = self._iterate()
def __aiter__(self) -> PublicResponseStream:
return self
async def __anext__(self) -> str:
if self._closed or self._done:
raise StopAsyncIteration
try:
while True:
packet, synthetic = await anext(self._events)
value = self._publish_packet(packet, synthetic=synthetic)
if value is not None:
self._latest_chunk = value
return value
except StopAsyncIteration:
self._done = True
raise
except (Exception, BaseExceptionGroup) as exc:
self._done = True
self._pending_starts.clear()
failure = find_execution_failure(exc) or exc
if self._terminal_frame is None:
raise
if self._terminal_failure_observer is not None:
self._terminal_failure_observer(failure)
frame = self._terminal_frame(
self.start_frame or self._initial_chunk, self._latest_chunk, failure
)
return self._publish_packet(StreamOutput((frame,)), synthetic=True) or frame
def _publish_packet(self, packet: StreamOutput, *, synthetic: bool) -> str | None:
excluded = {
"_body",
"state",
"_events",
"_terminal_frame",
"_terminal_failure_observer",
}
saved = deepcopy(
{key: value for key, value in self.__dict__.items() if key not in excluded}
)
try:
self._pending_call_proofs.update(
self._continuation.map_call_reference(call).identity
for call in packet.completed_calls
)
published = []
for chunk in packet.frames:
for raw in self._decoder.feed_frames(chunk):
for frame in (raw,) if synthetic else self._process(raw):
frame = self._finalize_frame(frame)
value = self._publish(frame, synthetic=synthetic)
if value is not None:
published.append(value)
# Replay removal can hold a completed call until a later text packet.
# Retain only its proof identity and consume it at actual publication.
calls = tuple(
call
for call in call_references(published)
if call.identity in self._pending_call_proofs
)
self._delivered.complete_calls(calls)
self._pending_call_proofs.difference_update(call.identity for call in calls)
if self._pending_release:
self.state.release_content(synthetic=synthetic)
self._pending_release = False
return "".join(published) or None
except BaseException:
self.__dict__.update(saved)
self.state.bind_prefix(self._delivered.snapshot)
raise
def _finalize_frame(self, frame: str) -> str:
payload = frame_data(frame)
if payload is None:
return frame
if finalize_replay(payload, self._delivered.snapshot, self._replay_carriers):
if self._continuation.active and not self._continuation.made_progress:
raise ExecutionFailure(
kind=FailureKind.UPSTREAM,
status_code=502,
message="The provider continuation completed without adding output.",
retryable=False,
)
frame = replace_frame_data(frame, payload)
kind = payload.get("type")
if kind == "response.failed":
response = payload.get("response")
if not isinstance(response, dict):
return frame
# Failure snapshots may be based on the provider's empty start frame.
# Use only retained public evidence, independently of a failed mapper.
if self._delivered.retention_exhausted:
response["output"] = []
response["usage"] = None
error = response.get("error")
error = error if isinstance(error, dict) else {}
message = error.get("message") or "Provider response failed."
response["error"] = {
**error,
"message": f"{message}\n\nThe partial answer was already streamed. "
"A complete final snapshot is unavailable.",
}
elif self._continuation.active or self.state.transition is not None:
# A timeout can precede the first frame that activates recovery.
response["output"] = [
deepcopy(item) for _, item in sorted(self._delivered.items.items())
]
response["usage"] = self._delivered.usage(response["output"])
else:
return frame
elif not self._continuation.active or kind in {"error", "response.error"}:
return frame
else:
payload = self._continuation.finalize(payload)
return replace_frame_data(frame, payload)
async def _iterate(self) -> AsyncGenerator[tuple[StreamOutput, bool]]:
while True:
try:
packet = await anext(self._body)
except StopAsyncIteration:
for frame in self._synchronize():
yield StreamOutput((frame,)), True
if self._continuation.handoff:
for payload in self._delivered.handoff_events():
yield StreamOutput((self._format(payload),)), True
if self._wire_api == "chat":
yield StreamOutput(("data: [DONE]\n\n",)), True
return
for frame in self._synchronize():
yield StreamOutput((frame,)), True
yield packet, False
def _synchronize(self) -> Iterator[str]:
transition = self.state.transition
if self._revision == self.state.attempt_revision and transition is None:
return
self._revision = self.state.attempt_revision
self.state.transition = None
self._decoder = AnthropicSSEDecoder()
self._projection = ClassifierProjection() if self._hide_reasoning else None
self._seen_starts.clear()
self._pending_starts.clear()
self._pending_call_proofs.clear()
if self._wire_api == "chat" and not (
self.state.content_released or self._pending_release
):
self._public_id = None
self._created_at = None
if transition is not None:
self._continuation.begin(handoff=transition == "handoff")
elif self._continuation.active:
self._continuation.restart_attempt()
self._replacement = (
bool(self._published_starts) and not self._continuation.active
)
for event in self._continuation.boundary():
yield self._format(event)
def _process(self, frame: str) -> Iterator[str]:
if self._projection is not None:
projected = self._projection.feed(frame)
if projected is None:
return
frame = projected
yield from self._prepare(frame)
def _prepare(self, frame: str) -> Iterator[str]:
if not self._continuation.active:
yield frame
return
payload = frame_data(frame)
if payload is None:
yield frame
return
for item in self._continuation.prepare(payload):
yield (
replace_frame_data(frame, item)
if item.get("type") == payload.get("type")
else self._format(item)
)
@staticmethod
def _format(payload: dict[str, Any]) -> str:
if "type" not in payload:
return f"data: {simplejson.dumps(payload, use_decimal=True)}\n\n"
return f"event: {payload['type']}\ndata: {simplejson.dumps(payload, use_decimal=True)}\n\n"
async def aclose(self) -> None:
if self._closed:
return
self._closed = self._done = True
await self._events.aclose()
self._pending_starts.clear()
self._pending_call_proofs.clear()
self._decoder = AnthropicSSEDecoder()
self._replay_carriers.clear()
self.state.bind_prefix(None)
self._delivered = DeliveredResponse(self._wire_api)
self._continuation = ContinuationStream(self._delivered)
self.start_frame = self._initial_chunk = self._latest_chunk = ""
error = await try_close_async_iterator(self._body)
if error is not None:
raise error
def _release_content(self, frame: str, *, synthetic: bool) -> str:
self._pending_release = True
for start in self._pending_starts:
self._record(start, synthetic=synthetic)
self._record(frame, synthetic=synthetic)
if not self._pending_starts:
return frame
self.start_frame = self._pending_starts[0]
self._published_starts.add("message_start")
prefix = "".join(self._pending_starts)
self._pending_starts.clear()
return prefix + frame
def _record(self, frame: str, *, synthetic: bool) -> None:
if self._wire_api == "chat" and frame.strip() == "data: [DONE]":
return
payload = frame_data(frame)
if payload is not None:
self._delivered.observe(payload, count_progress=not synthetic)
elif any(line.startswith("data:") for line in frame.splitlines()):
self._delivered.unsafe_reason = "unknown_event"
def _publish(self, frame: str, *, synthetic: bool = False) -> str | None:
"""Keep replacement and failure envelopes in the public response lifecycle."""
payload = frame_data(frame)
if payload is None:
if self._wire_api == "chat" and frame.strip() == "data: [DONE]":
return self._release_content(frame, synthetic=synthetic)
if any(
line.strip() and not line.startswith(":")
for line in re.split(r"\r\n|\r|\n", frame)
):
return self._release_content(frame, synthetic=synthetic)
return frame
raw_kind = payload.get("type")
if self._wire_api == "chat":
if self._public_id is None and isinstance(payload.get("id"), str):
self._public_id = payload["id"]
self._created_at = payload.get("created")
elif self._public_id is not None and "id" in payload:
payload["id"] = self._public_id
if self._created_at is not None:
payload["created"] = self._created_at
frame = replace_frame_data(frame, payload)
if "error" in payload:
self._pending_starts.clear()
elif self._metadata("", payload) and not (
self.state.content_released or self._pending_release
):
self._pending_starts.append(frame)
return None
if self._wire_api == "gemini":
if self._public_id is None and isinstance(payload.get("responseId"), str):
self._public_id = payload["responseId"]
self.start_frame = frame
elif self._public_id is not None and "responseId" in payload:
payload["responseId"] = self._public_id
frame = replace_frame_data(frame, payload)
kind = raw_kind if isinstance(raw_kind, str) else ""
metadata = self._metadata(kind, payload)
if self._wire_api == "messages":
if (
kind == "message_start"
and metadata
and not (self.state.content_released or self._pending_release)
):
self._pending_starts.append(frame)
return None
if kind == "error":
self._pending_starts.clear()
start = kind in {"message_start", "response.created", "response.in_progress"}
if start and metadata:
if kind not in self._seen_starts:
self._seen_starts.add(kind)
if self._replacement and kind in self._published_starts:
return None
self._published_starts.add(kind)
if not self.start_frame:
self.start_frame = frame
value = payload.get(
"message" if self._wire_api == "messages" else "response"
)
if isinstance(value, dict):
self._public_id = value.get("id")
self._created_at = value.get("created_at")
changed = False
failure = kind == "response.failed"
if (self._replacement or failure) and self._wire_api == "responses":
response = payload.get("response")
if isinstance(response, dict):
if (
self._public_id is not None
and response.get("id") != self._public_id
):
response["id"] = self._public_id
changed = True
if (
self._created_at is not None
and response.get("created_at") != self._created_at
):
response["created_at"] = self._created_at
changed = True
if (
"response_id" in payload
and self._public_id is not None
and payload["response_id"] != self._public_id
):
payload["response_id"] = self._public_id
changed = True
if self._wire_api == "responses":
self._sequence += 1
payload["sequence_number"] = self._sequence
changed = True
frame = replace_frame_data(frame, payload) if changed else frame
if metadata:
self._record(frame, synthetic=synthetic)
return frame
return self._release_content(frame, synthetic=synthetic)
def _metadata(self, kind: str, payload: dict[str, Any]) -> bool:
if self._wire_api == "chat":
return "error" not in payload and all(
choice.get("finish_reason") is None
and all(
key == "role" or value in (None, "", [], {})
for key, value in (choice.get("delta") or {}).items()
)
for choice in payload.get("choices", [])
)
if self._wire_api == "gemini":
return (
not gemini_parts(payload)
and not gemini_finished(payload)
and "error" not in payload
)
if kind == "ping":
return True
if self._wire_api == "messages" and kind == "message_start":
message = payload.get("message")
return (
isinstance(message, dict)
and message.get("content", []) == []
and message.get("stop_reason") is None
)
if self._wire_api == "responses" and kind in {
"response.created",
"response.in_progress",
}:
response = payload.get("response")
return (
isinstance(response, dict)
and response.get("output", []) == []
and response.get("status") in (None, "queued", "in_progress")
)
return False