verifiers 0.1.15.dev364__tar.gz → 0.1.15.dev366__tar.gz

{verifiers-0.1.15.dev364 → verifiers-0.1.15.dev366}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev364
+Version: 0.1.15.dev366
 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.1.15.dev364 → verifiers-0.1.15.dev366}/verifiers/v1/dialects/anthropic.py

@@ -122,15 +122,15 @@ def response_from_wire(message: AnthropicMessage) -> Response:
     data = message.model_dump()
     blocks = data.get("content") or []
     state = [block for block in blocks if block["type"] in THINKING]
-    content = ""
-    reasoning = ""
+    content: list[str] = []
+    reasoning: list[str] = []
     calls: list[ToolCall] = []
     for block in blocks:
         kind = block.get("type")
         if kind == "text":
-            content += block.get("text", "")
+            content.append(block.get("text", ""))
         elif kind == "thinking":
-            reasoning += block.get("thinking", "")
+            reasoning.append(block.get("thinking", ""))
         elif kind == "tool_use":
             calls.append(
                 ToolCall(
@@ -161,8 +161,8 @@ def response_from_wire(message: AnthropicMessage) -> Response:
         created=0,
         model=data.get("model", ""),
         message=AssistantMessage(
-            content=content or None,
-            reasoning_content=reasoning or None,
+            content="".join(content) or None,
+            reasoning_content="".join(reasoning) or None,
             tool_calls=calls or None,
             provider_state=state or None,
         ),
@@ -220,30 +220,38 @@ class AnthropicDialect(Dialect[dict, AnthropicMessage]):
         message, then parse it."""
         message: dict = {}
         blocks: dict[int, dict] = {}
-        partial_json: dict[int, str] = {}
+        block_parts: dict[int, dict[str, list[str]]] = {}
+        partial_json: dict[int, list[str]] = {}
         for event in iter_sse(raw):
             kind = event.get("type")
             if kind == "message_start":
                 message = event.get("message") or {}
             elif kind == "content_block_start":
-                blocks[event["index"]] = dict(event.get("content_block") or {})
+                index = event["index"]
+                blocks[index] = dict(event.get("content_block") or {})
+                block_parts.pop(index, None)
             elif kind == "content_block_delta":
-                block = blocks.setdefault(event["index"], {"type": "text", "text": ""})
+                index = event["index"]
+                block = blocks.setdefault(index, {"type": "text", "text": ""})
                 delta = event.get("delta") or {}
-                if delta.get("type") == "text_delta":
-                    block["text"] = block.get("text", "") + delta.get("text", "")
-                elif delta.get("type") == "thinking_delta":
-                    block["thinking"] = block.get("thinking", "") + delta.get(
-                        "thinking", ""
-                    )
-                elif delta.get("type") == "signature_delta":
-                    block["signature"] = block.get("signature", "") + delta.get(
-                        "signature", ""
-                    )
-                elif delta.get("type") == "input_json_delta":
-                    partial_json[event["index"]] = partial_json.get(
-                        event["index"], ""
-                    ) + delta.get("partial_json", "")
+                delta_type = delta.get("type")
+                if delta_type in ("text_delta", "thinking_delta", "signature_delta"):
+                    field = delta_type.removesuffix("_delta")
+                    fields = block_parts.get(index)
+                    if fields is None:
+                        fields = {}
+                        block_parts[index] = fields
+                    parts = fields.get(field)
+                    if parts is None:
+                        parts = [block.get(field, "")]
+                        fields[field] = parts
+                    parts.append(delta.get(field, ""))
+                elif delta_type == "input_json_delta":
+                    parts = partial_json.get(index)
+                    if parts is None:
+                        parts = []
+                        partial_json[index] = parts
+                    parts.append(delta.get("partial_json", ""))
             elif kind == "message_delta":
                 message.update(
                     {
@@ -256,8 +264,11 @@ class AnthropicDialect(Dialect[dict, AnthropicMessage]):
                     **(message.get("usage") or {}),
                     **(event.get("usage") or {}),
                 }
-        for index, partial in partial_json.items():
-            blocks[index]["input"] = json.loads(partial or "{}")
+        for index, fields in block_parts.items():
+            for field, parts in fields.items():
+                blocks[index][field] = "".join(parts)
+        for index, parts in partial_json.items():
+            blocks[index]["input"] = json.loads("".join(parts) or "{}")
         message["content"] = [blocks[i] for i in sorted(blocks)]
         return response_from_wire(self.validate_response(message))
 

{verifiers-0.1.15.dev364 → verifiers-0.1.15.dev366}/verifiers/v1/dialects/base.py

@@ -13,37 +13,63 @@ the eval's model + sampling in this format's shape) and `extend` (chat-only user
 """
 
 import json
+import logging
 from abc import ABC, abstractmethod
 from collections.abc import Iterator, Mapping
 from typing import ClassVar, Generic, TypeVar
 
 from pydantic import BaseModel
+from pydantic_core import from_json
 
 from verifiers.v1.types import Messages, Response, SamplingConfig, Tool
 
 ReqT = TypeVar("ReqT")
 RespT = TypeVar("RespT", bound=BaseModel)
 
-
-def iter_sse(raw: bytes) -> list[dict]:
-    """Parse a complete SSE byte stream into its JSON data payloads, in order (skipping
-    non-JSON sentinels like OpenAI's `data: [DONE]`). Shared by the dialects' `parse_stream`."""
-    events: list[dict] = []
-    for block in raw.decode("utf-8", errors="replace").split("\n\n"):
-        data = "\n".join(
-            line.removeprefix("data:").strip()
+logger = logging.getLogger(__name__)
+
+
+def iter_sse(raw: bytes) -> Iterator[dict]:
+    """Yield JSON SSE payloads in order without retaining prior events."""
+    # Detect the wire line ending once, then scan without retaining prior payloads.
+    first_newline = raw.find(b"\n")
+    separator = (
+        b"\r\n\r\n"
+        if first_newline > 0 and raw[first_newline - 1] == ord("\r")
+        else b"\n\n"
+    )
+    start = 0
+    while start < len(raw):
+        end = raw.find(separator, start)
+        if end == -1:
+            end = len(raw)
+        block = raw[start:end]
+        data = b"\n".join(
+            line.removeprefix(b"data:").strip()
             for line in block.splitlines()
-            if line.startswith("data:")
+            if line.startswith(b"data:")
         )
-        if not data or data == "[DONE]":
-            continue
-        events.append(json.loads(data))
-    return events
+        if data and data != b"[DONE]":
+            try:
+                yield from_json(data)
+            except ValueError:
+                logger.warning(
+                    "SSE JSON fast-path failed; falling back to stdlib with invalid UTF-8 replacement"
+                )
+                yield json.loads(data.decode("utf-8", errors="replace"))
+        start = end + len(separator)
 
 
 def iter_sse_reverse(raw: bytes) -> Iterator[dict]:
     """Yield JSON SSE payloads from the end without decoding earlier events."""
-    for block in reversed(raw.decode("utf-8", errors="replace").split("\n\n")):
+    decoded = raw.decode("utf-8", errors="replace")
+    first_newline = decoded.find("\n")
+    separator = (
+        "\r\n\r\n"
+        if first_newline > 0 and decoded[first_newline - 1] == "\r"
+        else "\n\n"
+    )
+    for block in reversed(decoded.split(separator)):
         data = "\n".join(
             line.removeprefix("data:").strip()
             for line in block.splitlines()

{verifiers-0.1.15.dev364 → verifiers-0.1.15.dev366}/verifiers/v1/dialects/chat.py

@@ -229,13 +229,19 @@ class ChatDialect(Dialect[dict, ChatCompletion]):
 
     def parse_stream(self, raw: bytes) -> Response:
         """Assemble `chat.completion.chunk` deltas into one completion, then parse it."""
-        chunks = iter_sse(raw)
         message: dict = {"role": "assistant", "content": None}
+        # Join streamed fields once; repeated concatenation recopies the growing response.
+        message_parts = {key: [] for key in REASONING_FIELDS[:2] + ("content",)}
         tool_calls: dict[int, dict] = {}
+        tool_arguments: dict[int, list[str]] = {}
         reasoning_details: list[dict] = []
+        reasoning_detail_parts: dict[int, list[str]] = {}
         finish_reason = None
         usage = None
-        for chunk in chunks:
+        head = None
+        for chunk in iter_sse(raw):
+            if head is None:
+                head = chunk
             usage = chunk.get("usage") or usage
             for choice in chunk.get("choices") or []:
                 if choice.get("index", 0) != 0:
@@ -244,32 +250,43 @@ class ChatDialect(Dialect[dict, ChatCompletion]):
                 delta = choice.get("delta") or {}
                 for key in ("content", "reasoning_content", "reasoning"):
                     if delta.get(key) is not None:
-                        message[key] = (message.get(key) or "") + delta[key]
+                        message_parts[key].append(delta[key])
                 for detail in delta.get("reasoning_details") or []:
                     previous = reasoning_details[-1] if reasoning_details else {}
                     if detail.get("type") == previous.get("type") == "reasoning.text":
-                        previous["text"] = (previous.get("text") or "") + (
-                            detail.get("text") or ""
-                        )
+                        reasoning_detail_parts.setdefault(
+                            len(reasoning_details) - 1, [previous.get("text") or ""]
+                        ).append(detail.get("text") or "")
                         for field in ("signature", "format"):
                             previous[field] = previous.get(field) or detail.get(field)
                     else:
                         reasoning_details.append(detail)
                 for tc in delta.get("tool_calls") or []:
+                    index = tc.get("index", 0)
                     slot = tool_calls.setdefault(
-                        tc.get("index", 0),
+                        index,
                         {"type": "function", "function": {"name": "", "arguments": ""}},
                     )
                     slot["id"] = tc.get("id") or slot.get("id", "")
                     fn = tc.get("function") or {}
                     if fn.get("name"):
                         slot["function"]["name"] = fn["name"]
-                    slot["function"]["arguments"] += fn.get("arguments") or ""
+                    tool_arguments.setdefault(index, []).append(
+                        fn.get("arguments") or ""
+                    )
+        for key, parts in message_parts.items():
+            if parts:
+                message[key] = "".join(parts)
+        for index, parts in reasoning_detail_parts.items():
+            reasoning_details[index]["text"] = "".join(parts)
+        for index, parts in tool_arguments.items():
+            tool_calls[index]["function"]["arguments"] = "".join(parts)
         if tool_calls:
             message["tool_calls"] = [tool_calls[i] for i in sorted(tool_calls)]
         if reasoning_details:
             message["reasoning_details"] = reasoning_details
-        head = chunks[0] if chunks else {}
+        if head is None:
+            head = {}
         return response_from_wire(
             ChatCompletion.model_validate(
                 {

{verifiers-0.1.15.dev364 → verifiers-0.1.15.dev366}/verifiers/v1/graph.py

@@ -376,18 +376,20 @@ def _attribute_routed_experts(
     raw = binascii.a2b_base64(payload["data"])
     arr = np.frombuffer(raw, dtype=np.uint8).reshape(payload["shape"])
     off = path_len - int(payload.get("start", 0) or 0)
-    # The engine omits routing for the turn's final position (no forward pass follows the last
-    # generated token), so the array is one row short of the turn's new tokens. Pad the tail
-    # with a copy of the last row so the final node still aligns 1:1 with its tokens.
     needed = off + sum(len(trace.nodes[nid].token_ids) for nid in new_node_ids)
-    if arr.shape[0] and 0 < needed - arr.shape[0] <= 1:
-        arr = np.concatenate([arr, arr[-1:]], axis=0)
     for nid in new_node_ids:
         n = len(trace.nodes[nid].token_ids)
-        if n and 0 <= off and off + n <= arr.shape[0]:
+        end = off + n
+        if n and 0 <= off and end <= arr.shape[0]:
             # Own only this node's rows; a view would retain the turn's full-context array.
-            trace.nodes[nid].routed_experts = arr[off : off + n].copy()
-        off += n
+            trace.nodes[nid].routed_experts = arr[off:end].copy()
+        elif n and arr.shape[0] and 0 <= off and end == needed == arr.shape[0] + 1:
+            # The engine omits the turn's final position because no forward pass follows it.
+            # Pad only the final node's suffix instead of copying the full-context array.
+            trace.nodes[nid].routed_experts = np.concatenate(
+                [arr[off:], arr[-1:]], axis=0
+            )
+        off = end
 
 
 def _commit_turn(turn: PendingTurn, response: Response) -> None: