verifiers 0.3.2.dev85__tar.gz → 0.3.2.dev86__tar.gz

{verifiers-0.3.2.dev85 → verifiers-0.3.2.dev86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev85
+Version: 0.3.2.dev86
 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.dev85 → verifiers-0.3.2.dev86}/verifiers/v1/dialects/chat.py

@@ -549,14 +549,19 @@ class ChatDialect(Dialect[ChatCompletion]):
 
     def stream_events(self, raw: dict) -> list[bytes]:
         choice = (raw.get("choices") or [{}])[0]
+        message = dict(choice.get("message") or {"role": "assistant", "content": ""})
+        if message.get("tool_calls"):
+            message["tool_calls"] = [
+                {**call, "index": index}
+                for index, call in enumerate(message["tool_calls"])
+            ]
         chunk = {
             **{key: value for key, value in raw.items() if key != "choices"},
             "object": "chat.completion.chunk",
             "choices": [
                 {
                     "index": 0,
-                    "delta": choice.get("message")
-                    or {"role": "assistant", "content": ""},
+                    "delta": message,
                     "finish_reason": choice.get("finish_reason"),
                 }
             ],

{verifiers-0.3.2.dev85 → verifiers-0.3.2.dev86}/verifiers/v1/harnesses/utils/core.py

@@ -9,7 +9,8 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import httpx
-from openai import APIStatusError, AsyncOpenAI
+from openai import APIStatusError, AsyncOpenAI, omit
+from openai.lib.streaming.chat import AsyncChatCompletionStream
 
 if TYPE_CHECKING:
     # The harness bundles this module into the generated script before execution.
@@ -191,7 +192,29 @@ async def chat(
     kwargs = {"model": model, "messages": messages, "tools": tools or None}
     if tools and tool_choice is not None:
         kwargs["tool_choice"] = tool_choice
-    return await client.chat.completions.create(**kwargs)
+    raw_stream = await client.chat.completions.create(
+        **kwargs, stream=True, stream_options={"include_usage": True}
+    )
+    # Accumulate native deltas without auto-parsing tool arguments or treating
+    # finish_reason="length" as an exception: compaction owns that decision.
+    async with AsyncChatCompletionStream(
+        raw_stream=raw_stream, response_format=omit, input_tools=[]
+    ) as response:
+        completion = None
+        async for event in response:
+            if event.type == "chunk":
+                completion = event.snapshot
+        if (
+            completion is None
+            or not completion.choices
+            or any(choice.finish_reason is None for choice in completion.choices)
+        ):
+            raise RuntimeError("model stream ended before a completion finished")
+        for choice in completion.choices:
+            # Some providers repeat the role in each delta. The SDK concatenates
+            # these strings, but the role is metadata, not incremental content.
+            choice.message.role = "assistant"
+        return completion
 
 
 async def run_tool_hook(

{verifiers-0.3.2.dev85 → verifiers-0.3.2.dev86}/verifiers/v1/interception/server.py

@@ -41,7 +41,11 @@ 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.configs.client import BaseClientConfig, resolve_api_key
+from verifiers.v1.configs.client import (
+    BaseClientConfig,
+    TrainClientConfig,
+    resolve_api_key,
+)
 from verifiers.v1.dialects import DIALECTS, Dialect
 from verifiers.v1.dialects.base import (
     PROVIDER_CAPABILITY_POLICY_CODE,
@@ -648,7 +652,7 @@ class InterceptionServer(Interception):
             return self._fail(session, dialect, error)
 
         inspect_response = bool(session.response_interceptors or session.response_stops)
-        if streaming:
+        if streaming and not isinstance(session.ctx.client, TrainClientConfig):
             return await self._stream(
                 request,
                 session,
@@ -663,6 +667,13 @@ class InterceptionServer(Interception):
             )
 
         def serve(response: Response) -> web.Response:
+            if streaming:
+                # Training generates a complete response with token metadata.
+                # Commit it through the normal path, then frame it for SSE clients.
+                return web.Response(
+                    body=b"".join(dialect.stream_events(response.raw or {})),
+                    content_type="text/event-stream",
+                )
             served = _completion_response(response.raw)
             if idempotent is not None:
                 idempotent.response = _capture_response(served)