verifiers 0.3.2.dev132__tar.gz → 0.3.2.dev134__tar.gz

{verifiers-0.3.2.dev132 → verifiers-0.3.2.dev134}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev132
+Version: 0.3.2.dev134
 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.dev132 → verifiers-0.3.2.dev134}/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-0.3.2.dev132 → verifiers-0.3.2.dev134}/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-0.3.2.dev132 → verifiers-0.3.2.dev134}/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]