verifiers 0.3.2.dev131__py3-none-any.whl → 0.3.2.dev133__py3-none-any.whl

verifiers/v1/dialects/anthropic.py

@@ -512,6 +512,14 @@ class AnthropicDialect(Dialect[AnthropicMessage]):
             "error": {"type": "invalid_request_error", "message": message},
         }
 
+    def stream_keepalive(self, first: bool) -> bytes:
+        # Anthropic's own keepalive; its SDKs skip it anywhere in the stream.
+        return b'event: ping\ndata: {"type": "ping"}\n\n'
+
+    def stream_error(self, error: dict) -> bytes:
+        # The Anthropic SDKs raise only on a named `error` event.
+        return b"event: error\ndata: " + json.dumps(error).encode() + b"\n\n"
+
     def parse_request(self, body: RawRequest) -> Request:
         native_tools = body.get("tools") or []
         if not isinstance(native_tools, list) or any(

verifiers/v1/dialects/base.py

@@ -317,6 +317,18 @@ class Dialect(ABC, Generic[RespT]):
         """An error payload in this format's error shape (OpenAI by default)."""
         return {"error": {"message": message, "type": "invalid_request_error"}}
 
+    def stream_keepalive(self, first: bool) -> bytes:
+        """A keepalive for a committed SSE stream whose turn is still being produced (`first`
+        on the stream's first one). A comment line by default: these clients count any bytes
+        as activity. A dialect whose clients only count events sends a no-op event instead."""
+        # Don't terminate an empty event; some SSE clients try to JSON-decode it.
+        return b": keepalive\n"
+
+    def stream_error(self, error: dict) -> bytes:
+        """An `error_body` as an SSE event, for a failure after the stream is committed.
+        OpenAI SDKs raise on any event carrying `error`."""
+        return b"data: " + json.dumps(error).encode() + b"\n\n"
+
     @abstractmethod
     def mediate_external_capabilities(
         self, body: RawRequest, policy: NetworkPolicyConfig

verifiers/v1/dialects/responses.py

@@ -49,6 +49,20 @@ from verifiers.v1.types import (
     UserMessage,
 )
 
+# The placeholder response a committed stream's keepalives carry until its turn is ready:
+# schema-valid, so strictly validating clients accept the events that carry it.
+_KEEPALIVE_RESPONSE = {
+    "id": "resp_keepalive",
+    "object": "response",
+    "created_at": 0,
+    "model": "",
+    "status": "in_progress",
+    "output": [],
+    "parallel_tool_calls": True,
+    "tool_choice": "auto",
+    "tools": [],
+}
+
 FINAL_EVENTS = ("response.completed", "response.incomplete", "response.failed")
 # Byte markers for the terminal event types above, in both compact and spaced JSON, so the
 # interception server can cheaply spot the turn-ending event without parsing each delta.
@@ -648,6 +662,33 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
         if "output_text" in raw:
             raw["output_text"] = text
 
+    def stream_keepalive(self, first: bool) -> bytes:
+        # Codex's idle timer resets only on data events (it drops comments), and the OpenAI
+        # SDK's stream helper rejects any event before `response.created`: open with a
+        # placeholder `response.created`, then repeat `response.in_progress`. The turn's own
+        # `response.created` follows and supersedes it; clients take the turn's id and final
+        # state from its own events, and its sequence numbers restart at 0.
+        kind = "response.created" if first else "response.in_progress"
+        payload = {"type": kind, "sequence_number": 0, "response": _KEEPALIVE_RESPONSE}
+        return f"event: {kind}\ndata: {json.dumps(payload)}\n\n".encode()
+
+    def stream_error(self, error: dict) -> bytes:
+        # `response.failed` is what Responses clients (codex) act on; the `error` key is what
+        # the OpenAI SDK raises on.
+        message = error["error"]["message"]
+        failed = {
+            **_KEEPALIVE_RESPONSE,
+            "status": "failed",
+            "error": {"code": "server_error", "message": message},
+        }
+        payload = {
+            "type": "response.failed",
+            "sequence_number": 0,
+            "response": failed,
+            **error,
+        }
+        return f"event: response.failed\ndata: {json.dumps(payload)}\n\n".encode()
+
     def stream_events(self, raw: dict) -> list[bytes]:
         item = raw["output"][0]
         part = item["content"][0]

verifiers/v1/harnesses/utils/core.py

@@ -240,7 +240,9 @@ async def chat(
     *,
     tool_choice: str | None = None,
 ):
-    kwargs = {"model": model, "messages": messages, "tools": tools or None}
+    kwargs = {"model": model, "messages": messages}
+    if tools:
+        kwargs["tools"] = tools
     if tools and tool_choice is not None:
         kwargs["tool_choice"] = tool_choice
     raw_stream = await client.chat.completions.create(

verifiers/v1/interception/server.py

@@ -27,10 +27,9 @@ import logging
 import secrets
 import time
 import traceback
-from collections.abc import AsyncIterator, Collection, Mapping
+from collections.abc import AsyncIterator, Awaitable, Collection, Mapping
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from tempfile import SpooledTemporaryFile
 from typing import Literal
 
 import httpx
@@ -41,6 +40,7 @@ from pydantic_core import PydanticSerializationError, from_json, to_json
 from verifiers.v1 import graph
 from verifiers.v1.clients import Client, resolve_client
 from verifiers.v1.clients.base import join_url
+from verifiers.v1.clients.client import RelayReply
 from verifiers.v1.configs.client import (
     BaseClientConfig,
     TrainClientConfig,
@@ -66,7 +66,7 @@ from verifiers.v1.interception.tunnel import (
 from verifiers.v1.semantic import ACPInfo, extract_acp_info
 from verifiers.v1.session import IdempotentRequest, ReplayResponse, RolloutSession
 from verifiers.v1.trace import Error, ModelCall, PolicyEvent, TimeSpan
-from verifiers.v1.types import FinishReason, Request, Response, Usage
+from verifiers.v1.types import FinishReason, Response, Usage
 
 logger = logging.getLogger(__name__)
 
@@ -77,8 +77,10 @@ logger = logging.getLogger(__name__)
 # context window are the real limits, this is just a host-OOM backstop.
 MAX_REQUEST_BODY = 1024**3  # 1 GiB (aiohttp's default is 1 MiB)
 KEEPALIVE_INTERVAL_SECONDS = 3
-STREAM_QUEUE_MAXSIZE = 16
-STREAM_MEMORY_BUFFER = 4 * 1024**2
+# A streamed turn commits its SSE stream only after this long: a result within it keeps
+# its HTTP status (so the harness SDK can retry 5xx/429), and a longer one is kept alive
+# well inside the tunnel's response-header timeout.
+KEEPALIVE_GRACE_SECONDS = 60
 # blake2b saturates ~1.7 GB/s, so a body up to this size hashes inline in well under a
 # millisecond; a larger one (bodies may reach `MAX_REQUEST_BODY`) is hashed off the event
 # loop instead — see `_request_digest`.
@@ -204,18 +206,108 @@ def _prune_idempotent_requests(session: RolloutSession, now: float) -> None:
                 session.idempotent_requests.pop(key)
 
 
-async def _queue_chunks(
-    chunks: AsyncIterator[bytes],
-    queue: asyncio.Queue[bytes | None],
-    ready: asyncio.Event,
-) -> None:
+async def _collect_stream(
+    dialect: Dialect, reply: RelayReply
+) -> tuple[Response, bytes]:
+    """Read a relayed provider stream whole: the assembled response and the events to serve
+    for it. Comment-only events (the provider's own keepalives) are dropped; the served
+    stream sends its own."""
+    events = bytearray()
+    parser = dialect.stream_parser()
+    saw_terminal = False
     try:
-        async for chunk in chunks:
-            await queue.put(chunk)
-            ready.set()
+        async for chunk in reply.chunks:
+            if not any(line.startswith(b"data:") for line in chunk.splitlines()):
+                continue
+            events += chunk
+            saw_terminal |= dialect.is_terminal_event(chunk)
+            if parser.on_done is not None and is_sse_done_event(chunk):
+                parser.on_done()
+            parser.feed(chunk)
+        if not saw_terminal:
+            raise ProviderError("upstream stream ended before its terminal event")
+        return parser.finish(), bytes(events)
+    except RolloutError:
+        raise
+    except Exception as e:  # a malformed provider stream
+        raise ProviderError(str(e)) from e
     finally:
-        await queue.put(None)
-        ready.set()
+        await reply.close()
+
+
+async def _buffered_stream(
+    request: web.Request,
+    dialect: Dialect,
+    pending: Awaitable[web.Response],
+    trace_id: str,
+) -> web.StreamResponse:
+    """Serve a turn to an SSE client once it is committed, keeping the connection alive
+    while it is produced. A result within the grace period is served as is; after it the
+    stream is committed and sent the dialect's keepalives, so neither a proxy's timeout
+    nor a client's own idle timeout cuts a long turn. Once committed, a failure is framed
+    as the dialect's SSE error. A reader that goes away leaves the turn running for its
+    retries to coalesce onto."""
+    task = asyncio.ensure_future(pending)
+    started = time.monotonic()
+    try:
+        done, _ = await asyncio.wait({task}, timeout=KEEPALIVE_GRACE_SECONDS)
+        if done:
+            return task.result()
+        stream = web.StreamResponse(
+            headers={
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+            }
+        )
+        connected = True
+        try:
+            await stream.prepare(request)
+            first = True
+            while not task.done():
+                await stream.write(dialect.stream_keepalive(first))
+                first = False
+                await asyncio.wait({task}, timeout=KEEPALIVE_INTERVAL_SECONDS)
+        except ConnectionResetError:
+            # A reader that goes away mid-turn is the failure a tunnel or proxy drop looks
+            # like from here; its retry (if any) coalesces onto this turn.
+            connected = False
+            logger.warning(
+                "intercept stream: reader disconnected: id=%s after=%.1fs",
+                trace_id,
+                time.monotonic() - started,
+            )
+        response = await task
+        replay = _capture_response(response)
+        # Release coalesced retries now rather than after the write to this reader.
+        _finish_idempotent_attempt(request, replay)
+        if connected:
+            try:
+                await stream.write(
+                    replay.body
+                    if response.status < 400
+                    else dialect.stream_error(from_json(replay.body))
+                )
+                await stream.write_eof()
+            except ConnectionResetError:
+                logger.warning(
+                    "intercept stream: reader disconnected before the turn was served: "
+                    "id=%s after=%.1fs",
+                    trace_id,
+                    time.monotonic() - started,
+                )
+        return stream
+    finally:
+        if not task.done():
+            logger.info(
+                "intercept stream: turn cancelled: id=%s after=%.1fs",
+                trace_id,
+                time.monotonic() - started,
+            )
+            task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await task
 
 
 class InterceptionServerConfig(BaseInterceptionConfig):
@@ -503,10 +595,10 @@ class InterceptionServer(Interception):
             body = json.loads(raw)
         body = dialect.apply_overrides(body, session.ctx.model, session.ctx.sampling)
         streaming = dialect.streaming(body)
-        relay_streaming = streaming and not isinstance(
-            session.ctx.client, TrainClientConfig
-        )
-        req_hash = await _request_digest(raw) if not relay_streaming else b""
+        # A streamed request is served whole once its turn commits: the eval client's
+        # provider stream is read to the end, and the train client generates the response.
+        relay = streaming and not isinstance(session.ctx.client, TrainClientConfig)
+        req_hash = await _request_digest(raw)
         # Keep `read()` for aiohttp's size guard, then release its cache and our local
         # alias after parsing so the wire body does not survive model inference.
         request._read_bytes = None
@@ -516,10 +608,11 @@ class InterceptionServer(Interception):
         except ValueError as error:
             return web.json_response(dialect.error_body(str(error)), status=400)
         logger.debug(
-            "intercept %s: id=%s stream=%s",
+            "intercept %s: id=%s stream=%s retry=%s",
             request.path,
             session.trace.id,
             streaming,
+            request.headers.get(RETRY_COUNT_HEADER, "0"),
         )
         # Graph atomicity under retries: one logical buffered call must commit at most
         # one turn. An explicit key identifies that call directly; otherwise only the SDK's
@@ -528,18 +621,9 @@ class InterceptionServer(Interception):
         retried = is_retried_request(request.headers)
         idempotent: IdempotentRequest | None = None
         idempotency_key = request.headers.get(IDEMPOTENCY_KEY_HEADER)
-        replay_key: str | None = None
         binding = (request.path, req_hash)
         if idempotency_key:
-            if relay_streaming and acp is None:
-                return web.json_response(
-                    dialect.error_body(
-                        "Idempotency-Key is not supported for streaming requests"
-                    ),
-                    status=400,
-                )
-            if not relay_streaming:
-                replay_key = f"explicit:{idempotency_key}"
+            replay_key = f"explicit:{idempotency_key}"
             # This key identifies the harness-to-interception hop. The server owns its
             # replay semantics, and the body has since been rewritten with rollout model
             # and sampling overrides, so never expose the local key to the provider.
@@ -548,27 +632,26 @@ class InterceptionServer(Interception):
                 for name, value in upstream_headers.items()
                 if name.lower() != IDEMPOTENCY_KEY_HEADER.lower()
             }
-        elif not relay_streaming:
+        else:
             replay_key = f"retry:{request.path}:{req_hash.hex()}"
 
-        if replay_key is not None:
-            now = time.monotonic()
-            _prune_idempotent_requests(session, now)
-            if idempotency_key or retried:
-                idempotent = session.idempotent_requests.get(replay_key)
-            if idempotent is not None and idempotent.binding != binding:
-                return web.json_response(
-                    dialect.error_body(
-                        "Idempotency-Key was reused with a different request"
-                    ),
-                    status=400,
-                )
-            if idempotent is not None and idempotent.response is not None:
-                logger.debug(
-                    "intercept replay: id=%s (idempotent request)", session.trace.id
-                )
-                idempotent.completed_at = now
-                return _replay_response(idempotent.response)
+        now = time.monotonic()
+        _prune_idempotent_requests(session, now)
+        if idempotency_key or retried:
+            idempotent = session.idempotent_requests.get(replay_key)
+        if idempotent is not None and idempotent.binding != binding:
+            return web.json_response(
+                dialect.error_body(
+                    "Idempotency-Key was reused with a different request"
+                ),
+                status=400,
+            )
+        if idempotent is not None and idempotent.response is not None:
+            logger.debug(
+                "intercept replay: id=%s (idempotent request)", session.trace.id
+            )
+            idempotent.completed_at = now
+            return _replay_response(idempotent.response)
 
         try:
             model_request = dialect.parse_request(body)
@@ -583,7 +666,7 @@ class InterceptionServer(Interception):
                 dialect.error_body(f"rollout stopped: {session.trace.stop_condition}"),
                 status=400,
             )
-        if replay_key is not None and idempotent is None:
+        if idempotent is None:
             idempotent = IdempotentRequest(binding=binding)
             session.idempotent_requests[replay_key] = idempotent
 
@@ -600,20 +683,22 @@ class InterceptionServer(Interception):
                 )
             return _replay_response(response)
 
-        if idempotent is not None:
-            if idempotent.inflight is not None:
-                return await coalesced(idempotent.inflight)
-            assert replay_key is not None
-            future: asyncio.Future[ReplayResponse | None] = (
-                asyncio.get_running_loop().create_future()
-            )
-            idempotent.inflight = future
-            request[_IDEMPOTENT_ATTEMPT] = _IdempotentAttempt(
-                session=session,
-                key=replay_key,
-                request=idempotent,
-                future=future,
-            )
+        if idempotent.inflight is not None:
+            if streaming:
+                return await _buffered_stream(
+                    request, dialect, coalesced(idempotent.inflight), session.trace.id
+                )
+            return await coalesced(idempotent.inflight)
+        future: asyncio.Future[ReplayResponse | None] = (
+            asyncio.get_running_loop().create_future()
+        )
+        idempotent.inflight = future
+        request[_IDEMPOTENT_ATTEMPT] = _IdempotentAttempt(
+            session=session,
+            key=replay_key,
+            request=idempotent,
+            future=future,
+        )
 
         try:
             refused = await session.refused()
@@ -668,46 +753,27 @@ class InterceptionServer(Interception):
         # turns): live watchers see it now rather than with the model's reply.
         session.trace.preview(turn, turn.tail)
 
-        # Request hooks police the proposed tool calls at commit, before the response is
-        # released, so a stream is buffered for them too.
-        inspect_response = bool(
-            session.response_interceptors
-            or session.response_stops
-            or session.request_interceptors
-            or session.request_stops
-        )
-        if relay_streaming:
-            return await self._stream(
-                request,
-                session,
-                dialect,
-                body,
-                model_request,
-                turn=turn,
-                inspect_response=inspect_response,
-                policy_paths=policy_paths,
-                acp=acp,
-                upstream_headers=upstream_headers,
-            )
-
-        def serve(response: Response) -> web.Response:
+        def serve(response: Response, events: bytes | None) -> web.Response:
             if streaming:
-                # Training generates a complete response with token metadata.
-                # Commit it through the normal path, then frame it for SSE clients.
+                # The committed turn as SSE: the provider's own events when relayed
+                # unchanged, else framed from the response (training generates it whole,
+                # and a hook may have rewritten a relayed one).
                 served = web.Response(
-                    body=b"".join(dialect.stream_events(response.raw or {})),
+                    body=events
+                    if events is not None
+                    else b"".join(dialect.stream_events(response.raw or {})),
                     content_type="text/event-stream",
                 )
             else:
                 served = _completion_response(response.raw)
-            if idempotent is not None:
-                idempotent.response = _capture_response(served)
-                idempotent.completed_at = time.monotonic()
+            idempotent.response = _capture_response(served)
+            idempotent.completed_at = time.monotonic()
             return served
 
         async def sample() -> web.Response:
             session.error = None
             call_response: Response | None = None
+            events: bytes | None = None
             node: int | None = None
             error: Exception | None = None
             started = time.time()
@@ -715,14 +781,23 @@ class InterceptionServer(Interception):
                 try:
                     # What actually goes upstream: the native body with the rollout's model +
                     # sampling imposed — recorded raw on the trace, per call.
-                    call_response = await session.client.get_response(
-                        dialect,
-                        body,
-                        session.ctx.sampling,
-                        headers=upstream_headers,
-                        session_id=session.trace.id,
-                        turn=turn,
-                    )
+                    if relay:
+                        reply = await session.client.relay(
+                            dialect,
+                            body,
+                            headers=upstream_headers,
+                            session_id=session.trace.id,
+                        )
+                        call_response, events = await _collect_stream(dialect, reply)
+                    else:
+                        call_response = await session.client.get_response(
+                            dialect,
+                            body,
+                            session.ctx.sampling,
+                            headers=upstream_headers,
+                            session_id=session.trace.id,
+                            turn=turn,
+                        )
                     logger.debug(
                         "intercept turn: id=%s tools=%d",
                         session.trace.id,
@@ -741,6 +816,7 @@ class InterceptionServer(Interception):
                             stopped,
                         ) = await session.rewrite_response(call_response)
                         if response_rewrites:
+                            events = None
                             assert call_response.raw is not None
                             dialect.rewrite_response(
                                 call_response.raw, call_response.message.content or ""
@@ -816,279 +892,12 @@ class InterceptionServer(Interception):
                     policy_paths=policy_paths,
                     acp=acp,
                 )
-            return serve(call_response)
+            return serve(call_response, events)
 
+        if streaming:
+            return await _buffered_stream(request, dialect, sample(), session.trace.id)
         return await sample()
 
-    async def _stream(
-        self,
-        request: web.Request,
-        session: RolloutSession,
-        dialect: Dialect,
-        body: dict,
-        model_request: Request,
-        *,
-        turn: graph.PendingTurn,
-        inspect_response: bool,
-        policy_paths: list[str] | None = None,
-        acp: ACPInfo | None = None,
-        upstream_headers: Mapping[str, str] | None = None,
-    ) -> web.StreamResponse:
-        """A streamed (SSE) model turn: relay the provider's stream through to the program,
-        incrementally assembling the response to record on the trace (the only client that
-        streams is the eval relay)."""
-        session.error = None
-        reply = None
-        response: Response | None = None
-        node: int | None = None
-        error: Exception | None = None
-        started = time.time()
-        try:
-            try:
-                reply = await session.client.relay(
-                    dialect,
-                    body,
-                    headers=upstream_headers,
-                    session_id=session.trace.id,
-                )
-            except RolloutError as e:
-                error = e
-                session.error = e
-                logger.warning(
-                    "model call failed: id=%s %s: %s",
-                    session.trace.id,
-                    type(e).__name__,
-                    e,
-                )
-                return web.json_response(
-                    dialect.error_body(str(e)), status=getattr(e, "status_code", 502)
-                )
-            except Exception as e:  # noqa: BLE001 - surface as an API error
-                error = e
-                logger.warning("model call failed: id=%s %s", session.trace.id, e)
-                return web.json_response(dialect.error_body(str(e)), status=502)
-
-            if inspect_response:
-                buffered = SpooledTemporaryFile(  # noqa: SIM115 - closed before every exit
-                    max_size=STREAM_MEMORY_BUFFER
-                )
-                parser = dialect.stream_parser()
-                saw_terminal = False
-                try:
-                    async for chunk in reply.chunks:
-                        buffered.write(chunk)
-                        saw_terminal |= dialect.is_terminal_event(chunk)
-                        if parser.on_done is not None and is_sse_done_event(chunk):
-                            parser.on_done()
-                        parser.feed(chunk)
-                    if not saw_terminal:
-                        raise ProviderError(
-                            "upstream stream ended before its terminal event"
-                        )
-                    response = parser.finish()
-                    response_rewrites = []
-                    stopped = None
-                    if session.response_interceptors or session.response_stops:
-                        (
-                            response,
-                            response_rewrites,
-                            stopped,
-                        ) = await session.rewrite_response(response)
-                        if response_rewrites:
-                            assert response.raw is not None
-                            dialect.rewrite_response(
-                                response.raw, response.message.content or ""
-                            )
-                            raw_response = response.raw
-                            response = dialect.parse_response(
-                                dialect.validate_response(raw_response)
-                            )
-                            response.raw = raw_response
-                except RolloutError as e:
-                    buffered.close()
-                    error = e
-                    session.error = e
-                    return self._fail(session, dialect, e)
-                except Exception as e:  # noqa: BLE001 - malformed provider stream
-                    buffered.close()
-                    error = ProviderError(str(e))
-                    session.error = error
-                    return self._fail(session, dialect, error)
-                finally:
-                    await reply.close()
-
-                if session.released or session.stopped:
-                    buffered.close()
-                    return web.json_response(
-                        dialect.error_body(
-                            "rollout concluded"
-                            if session.released
-                            else f"rollout stopped: {session.trace.stop_condition}"
-                        ),
-                        status=409 if session.released else 400,
-                    )
-                node = turn.commit(response)
-                session.consume_prepared(turn.tail)
-                session.trace.response_rewrites.extend(response_rewrites)
-                if stopped is None:
-                    try:
-                        stopped = await session.gate_tool_calls(node)
-                    except RolloutError as e:
-                        error = e
-                        buffered.close()
-                        return self._fail(session, dialect, e)
-                if stopped is not None:
-                    buffered.close()
-                    session.trace.stop(stopped)
-                    return web.json_response(
-                        dialect.error_body(f"rollout stopped: {stopped}"),
-                        status=400,
-                    )
-
-                resp = web.StreamResponse(
-                    headers={"Cache-Control": "no-cache", "Connection": "keep-alive"}
-                )
-                resp.content_type = reply.content_type.split(";")[0].strip()
-                try:
-                    await resp.prepare(request)
-                    if response_rewrites:
-                        for event in dialect.stream_events(response.raw or {}):
-                            await resp.write(event)
-                    else:
-                        buffered.seek(0)
-                        while chunk := buffered.read(64 * 1024):
-                            await resp.write(chunk)
-                    await resp.write_eof()
-                except ConnectionResetError:
-                    pass
-                finally:
-                    buffered.close()
-                return resp
-
-            resp = web.StreamResponse(
-                headers={"Cache-Control": "no-cache", "Connection": "keep-alive"}
-            )
-            resp.content_type = reply.content_type.split(";")[0].strip()
-            # Parse complete events as they relay, avoiding a full-stream byte copy.
-            parser = dialect.stream_parser()
-            feed_event = parser.feed
-            on_done = parser.on_done
-            # One bounded producer avoids per-event tasks; keepalive timeouts only cancel readiness waits.
-            queue: asyncio.Queue[bytes | None] = asyncio.Queue(
-                maxsize=STREAM_QUEUE_MAXSIZE
-            )
-            ready = asyncio.Event()
-            producer = asyncio.create_task(_queue_chunks(reply.chunks, queue, ready))
-            parser_error: Exception | None = None
-            # SSE events from the turn-ending one onward (the terminal event and any trailing
-            # `[DONE]`), withheld until the turn is committed: a client that ends its turn on the
-            # terminal event (e.g. codex on `response.completed`) would otherwise reach scoring
-            # with the turn still unrecorded.
-            deferred: list[bytes] = []
-            try:
-                await resp.prepare(request)
-                while True:
-                    try:
-                        async with asyncio.timeout(KEEPALIVE_INTERVAL_SECONDS):
-                            await ready.wait()
-                    except TimeoutError:
-                        # Don't terminate an empty event; some SSE clients try to JSON-decode it.
-                        await resp.write(b": keepalive\n")
-                        continue
-                    chunk = queue.get_nowait()
-                    if queue.empty():
-                        ready.clear()
-                    if chunk is None:
-                        await producer
-                        break
-                    # We send our own keepalive above. Some clients treat a complete
-                    # comment-only event from upstream as an empty JSON payload.
-                    if not any(
-                        line.startswith(b"data:") for line in chunk.splitlines()
-                    ):
-                        await resp.write(b": keepalive\n")
-                        continue
-                    if deferred or dialect.is_terminal_event(chunk):
-                        if parser_error is None:
-                            try:
-                                if on_done is not None and is_sse_done_event(chunk):
-                                    on_done()
-                                feed_event(chunk)
-                            except Exception as e:  # noqa: BLE001 - defer parser failure
-                                parser_error = e
-                        # forwarded after the turn is committed, below
-                        deferred.append(chunk)
-                        continue
-                    await resp.write(chunk)
-                    if parser_error is None:
-                        try:
-                            feed_event(chunk)
-                        except Exception as e:  # noqa: BLE001 - defer parser failure
-                            parser_error = e
-            except ConnectionResetError as e:
-                # The harness went away mid-stream; the provider exchange still happened.
-                error = e
-                return resp
-            finally:
-                producer.cancel()
-                # Let a canceled producer enqueue EOF while unwinding.
-                if queue.full():
-                    queue.get_nowait()
-                await asyncio.gather(producer, return_exceptions=True)
-                await reply.close()
-
-            try:
-                if parser_error is not None:
-                    raise parser_error
-                response = parser.finish()
-                if not session.released and not session.stopped:
-                    node = turn.commit(response)
-                    session.consume_prepared(turn.tail)
-                    logger.debug("intercept stream turn: id=%s", session.trace.id)
-                elif session.stopped:
-                    with contextlib.suppress(ConnectionResetError):
-                        await resp.write_eof()
-                    return resp
-            finally:
-                # Release the withheld events only now — after the commit — then close.
-                with contextlib.suppress(ConnectionResetError):
-                    for event in deferred:
-                        await resp.write(event)
-                    await resp.write_eof()
-            return resp
-        except RolloutError as e:
-            # A streamed terminal provider failure is discovered only after the
-            # response body has been relayed. Keep it off the graph and preserve
-            # the typed cause for the rollout if the native SDK does not retry it.
-            if node is None:
-                error = e
-                session.error = e
-            raise
-        except BaseException as e:
-            # Anything that propagates (a mid-relay upstream failure, a parser or commit
-            # error, a cancellation) ends a real exchange; couple it to the record unless
-            # the turn already committed (then only post-commit delivery failed).
-            if node is None:
-                error = e
-            raise
-        finally:
-            if node is None:
-                turn.abandon()
-            # The turn's one per-exchange record: settings, timing, outcome, and the
-            # error that ended it (if any).
-            self.record_call(
-                session,
-                dialect,
-                body,
-                started,
-                node=node,
-                finish_reason=response.finish_reason if response is not None else None,
-                usage=response.usage if response is not None else None,
-                error=error,
-                policy_paths=policy_paths,
-                acp=acp,
-            )
-
     async def handle_aux(
         self, request: web.Request, dialect: Dialect, route: str
     ) -> web.Response:

{verifiers-0.3.2.dev131.dist-info → verifiers-0.3.2.dev133.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev131
+Version: 0.3.2.dev133
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.3.2.dev131.dist-info → verifiers-0.3.2.dev133.dist-info}/RECORD

@@ -60,10 +60,10 @@ verifiers/v1/configs/cli/init.py,sha256=JvIUOdhfZfNOXg2wm2i06jLLHpb97tNMzZqmcK_9
 verifiers/v1/configs/cli/replay.py,sha256=vUCNs-9j1CXcAZhGozN1EaztcXK_dYVK3iN_fRmbSXw,2929
 verifiers/v1/configs/cli/validate.py,sha256=z7iueq4ndDFKOQ1GA2vaK3C8RhxhDUim-Nn-71T3kGw,3694
 verifiers/v1/dialects/__init__.py,sha256=MNOYM2NdTlSxGK4VtoEjMtD5zya2MpjPDX5jMvZUWEo,736
-verifiers/v1/dialects/anthropic.py,sha256=mcZmNfby2dUaqfFlYHntlVbzEyS_eq6O2V_Hl7xqIPQ,25725
-verifiers/v1/dialects/base.py,sha256=0fowpPl8mrxFM9xZGPpBvse5kFgYefUnyfNjxKfug-0,15425
+verifiers/v1/dialects/anthropic.py,sha256=rkxS8K4xvSTZwS86Mz_a4MfHzrkYf9Vvu8wCerzVNIw,26111
+verifiers/v1/dialects/base.py,sha256=7peaHJGdVT93G3erTnlAcRJi7tGvJ9BUkd_W5O4HGms,16140
 verifiers/v1/dialects/chat.py,sha256=KOrDW2f4WMLl37Pv2EilKddCXUUgRNjl4tQseMiPC-o,23775
-verifiers/v1/dialects/responses.py,sha256=Z2WulSL14XyqlbdY_rVZKj0aluOeOlec9jmXXw9-FDI,28688
+verifiers/v1/dialects/responses.py,sha256=GXI4xzvZWL5Dugi9uHPhrSdgV6RQ5zQuuPfzVztu2Go,30457
 verifiers/v1/envs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 verifiers/v1/envs/agentic_judge/__init__.py,sha256=LfEcRHLG_siKzhzWmODDXWSLpLgfum3UFdQDK9XG0gk,325
 verifiers/v1/envs/agentic_judge/env.py,sha256=GovnHqgRm8nQLAM7wMx57-A_wJBRYopsfiy2Bgf32nA,15339
@@ -118,14 +118,14 @@ verifiers/v1/harnesses/terminus_2/harness.py,sha256=cKQJluW01mkxEccTLFwSWsVMavyi
 verifiers/v1/harnesses/terminus_2/program.py,sha256=X8MZdyItU3gbXGXnGOlJ9LWcUTnqIDaxlhkZvoRiqKY,2703
 verifiers/v1/harnesses/utils/__init__.py,sha256=eTS-Ft2HwoLiYn5u1t_KueLmaZB_W12cdYmcVsE-G5A,364
 verifiers/v1/harnesses/utils/compaction.py,sha256=DeY6CYLEsv7-vJm26sT2mRaPHu3W2ywiZhvFr_pi6Hg,10495
-verifiers/v1/harnesses/utils/core.py,sha256=r7kYmIr27jGXIgGHzYwaqmEkTZc7r310mxRH2tc_slc,18498
+verifiers/v1/harnesses/utils/core.py,sha256=emAeNqtha__3cR0u7pvoQGnl2sE57wadE0wlKGtO1Yk,18520
 verifiers/v1/harnesses/utils/install.py,sha256=BDkkUVZ1brSzCrbQOvMO5mVIE2DsV2pE7rTC5yROYUw,2992
 verifiers/v1/harnesses/utils/launch.py,sha256=RqPuUY-kT2XVuLSGtXW7kRQEaP-o2KzkiJ7vcoo2neM,2883
 verifiers/v1/harnesses/utils/mcp.py,sha256=oNhKfLjAW-wScJcDIsW_HfuvKY-JkaGBBZrRLqgRK1g,7355
 verifiers/v1/interception/__init__.py,sha256=5Kvo7tcBUVaa65s9A1NiOH3CPpzw-P5btXwxB4Nbbvs,4251
 verifiers/v1/interception/base.py,sha256=Mg16Y104lyZilF9shdivdqYoqz4OYp978i_myyrulu8,2529
 verifiers/v1/interception/pool.py,sha256=sk_zcdTV8EVRuzqlYMXxon_42tSDAlFvwcyOO2EF7hw,6473
-verifiers/v1/interception/server.py,sha256=wxw67OQkLgzvt1HMJyjYmdcoIhn4vuJBe5oXZN-MIVU,54299
+verifiers/v1/interception/server.py,sha256=DnPvQcZZX0JYvxrTLOQuJn4QFX5Z44edGjpvfdxZmRw,45773
 verifiers/v1/interception/tunnel/__init__.py,sha256=eVNZJszj6myrKhx9jmJz7VRd9qlfj0AUvUZwI2bXEj8,893
 verifiers/v1/interception/tunnel/base.py,sha256=DZB6uPLwM4Qy7n7m0vKeyg-Px87MhsmpYTpe2vpPEng,1998
 verifiers/v1/interception/tunnel/custom.py,sha256=yL4UbGf4bAuMsxk42mEP-t1wITQCT8BE9FHQIz0qRMA,1708
@@ -190,8 +190,8 @@ verifiers/v1/utils/retries.py,sha256=Y2ZgrAjn-qNkRKZP_RVNL_7EK0iaRcZeCa404lpGYi4
 verifiers/v1/utils/scope.py,sha256=bzUEiWDOVdbj7dXOwGOlzsQ_-Xu0j9NR5TalQB-8TS8,838
 verifiers/v1/utils/score.py,sha256=493yJVMw8teCu9JxapxMFPFzI0hNUqdo0Y2nGW4kckk,6200
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.3.2.dev131.dist-info/METADATA,sha256=OUiO38608oHRrsfZlI0G-wWxevOOaVxNHkiDzHpuk0A,4161
-verifiers-0.3.2.dev131.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-verifiers-0.3.2.dev131.dist-info/entry_points.txt,sha256=iugElcdWPKbQM7uFF0lZ8iUpHsNr17-BwEAAjJWxV3U,259
-verifiers-0.3.2.dev131.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.3.2.dev131.dist-info/RECORD,,
+verifiers-0.3.2.dev133.dist-info/METADATA,sha256=Ff2GNRZ7xB_YdcKn5Cu6_FLNmVH6PuNJYVXZ-brj6mE,4161
+verifiers-0.3.2.dev133.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+verifiers-0.3.2.dev133.dist-info/entry_points.txt,sha256=iugElcdWPKbQM7uFF0lZ8iUpHsNr17-BwEAAjJWxV3U,259
+verifiers-0.3.2.dev133.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.3.2.dev133.dist-info/RECORD,,