verifiers 0.3.2.dev102__tar.gz → 0.3.2.dev103__tar.gz

{verifiers-0.3.2.dev102 → verifiers-0.3.2.dev103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev102
+Version: 0.3.2.dev103
 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.dev102 → verifiers-0.3.2.dev103}/tests/v1/test_serve_delta.py

@@ -4,6 +4,7 @@ the episode the worker finished with."""
 import asyncio
 import copy
 
+import numpy as np
 import pytest
 
 import verifiers.v1 as vf
@@ -176,7 +177,8 @@ async def test_pending_preview_streams_and_clears_on_commit():
 
 
 @pytest.mark.asyncio
-async def test_deltas_stream_once_and_reassemble_the_episode():
+@pytest.mark.parametrize("routing_dtype", [np.uint8, np.uint16])
+async def test_deltas_stream_once_and_reassemble_the_episode(routing_dtype):
     slot = Slot()
     frames: list[bytes] = []
 
@@ -192,8 +194,15 @@ async def test_deltas_stream_once_and_reassemble_the_episode():
         await settle()
         assert len(frames) == 1, "the mint and the boot span coalesce into one delta"
         add_turn(trace, "a1")
+        trace.nodes[1].routed_experts = np.arange(6, dtype=np.uint8).reshape(3, 2, 1)
         await settle()
         add_turn(trace, "a2")
+        # The next prefill corrects the previous turn's last routing row, potentially
+        # widening its dtype. The previous node has already crossed the wire.
+        trace.nodes[1].routed_experts = np.array(
+            [[[0], [1]], [[2], [3]], [[100], [np.iinfo(routing_dtype).max]]],
+            dtype=routing_dtype,
+        )
         trace.nodes[0].semantic_parents.append(ParentLink(node=1, type="reply"))
         await settle()
         trace.record_reward("match", 1.0)
@@ -224,6 +233,10 @@ async def test_deltas_stream_once_and_reassemble_the_episode():
     rebuilt = WireEpisode.model_validate(unpack(pack(assembly.finish(head, summaries))))
     assert rebuilt.ok and rebuilt.traces[0].id == trace.id
     assert rebuilt.traces[0].messages == trace.messages
+    np.testing.assert_array_equal(
+        rebuilt.traces[0].nodes[1].routed_experts, trace.nodes[1].routed_experts
+    )
+    assert rebuilt.traces[0].nodes[1].routed_experts.dtype == routing_dtype
     assert (
         rebuilt.traces[0].nodes[0].semantic_parents == trace.nodes[0].semantic_parents
     )

{verifiers-0.3.2.dev102 → verifiers-0.3.2.dev103}/verifiers/v1/serve/delta.py

@@ -4,12 +4,12 @@ The worker streams a served episode as it grows. Each trace announces its own ch
 (`Trace.notify`, fired by the rollout at every phase change and by the interception proxy
 after every recorded turn); the `DeltaStreamer` then diffs the run's live traces against
 what it has already sent and ships only the new part — the trace header once, then
-appended nodes / calls / errors, semantic links landing on earlier nodes, the scalar
+appended nodes / calls / errors, semantic links and routing-row repairs on earlier nodes, the scalar
 fields whose value changed (timing spans, stop condition, rewards, ...), and the
 `pending` preview — the messages of the request in flight that no node holds yet, so a
 watcher sees a tool result before the model has answered it. The `Trace` is
-append-only at turn granularity (a turn's nodes are committed complete, with their
-tokens), so apart from the preview, which a committed turn repeats, every byte of the
+append-only at turn granularity except for links and the last routing row of a node,
+which the next prefill can repair. Apart from these and the preview, every byte of the
 episode crosses the wire once and the stream costs about what a single reply would; the
 reply that ends the run carries only the episode head and per-trace counts the client
 checks its assembly against. A cursor advances only once its delta is on the wire, so a
@@ -29,8 +29,10 @@ from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any, Self
 
 import msgpack
+import numpy as np
 from pydantic import BaseModel
 
+from verifiers.v1.graph import _decode_ndarray, _encode_ndarray
 from verifiers.v1.serve.encoding import msgpack_encoder
 
 if TYPE_CHECKING:
@@ -73,7 +75,7 @@ def pack(payload: Any) -> bytes:
 
 
 def unpack(data: bytes) -> Any:
-    # `links` is keyed by node index (int).
+    # Node updates are keyed by node index (int).
     return msgpack.unpackb(data, raw=False, strict_map_key=False)
 
 
@@ -90,6 +92,8 @@ class TraceCursor:
         self.sent = dict.fromkeys(LIST_FIELDS, 0)
         self.links: list[int] = []
         """Per sent node, how many of its semantic links went out with or after it."""
+        self.final_rows: dict[int, bytes] = {}
+        """Per node that carries routing, its final row as packed when last sent."""
         self.scalars: dict[str, bytes] = {}
         self.pending: bytes = pack([])
 
@@ -157,6 +161,31 @@ class DeltaStreamer:
                 else:
                     self.cursors[trace_id] = cursor
 
+    def _maybe_add_routing_repairs(
+        self,
+        delta: dict[str, Any],
+        trace: Trace,
+        cursor: TraceCursor,
+        sent_nodes: int,
+    ) -> None:
+        """Add final rows repaired since they were sent, keyed by node index.
+
+        Record every node's current row on the cursor. `sent_nodes` is the pre-flush
+        count, so a node first sent in this delta is never reported as a repair.
+        """
+        repairs: dict[int, dict] = {}
+        for index, node in enumerate(trace.nodes):
+            if node.routed_experts is None:
+                continue
+            row = _encode_ndarray(node.routed_experts[-1:])
+            packed = pack(row)
+            if cursor.final_rows.get(index) != packed:
+                cursor.final_rows[index] = packed
+                if index < sent_nodes:
+                    repairs[index] = row
+        if repairs:
+            delta["routing_repairs"] = repairs
+
     def diff(self) -> list[tuple[str, dict, TraceCursor | None]]:
         """Each trace's delta against its sent cursor, with the cursor as it stands once
         that delta is sent (None for a discard). Nothing here is committed: `flush`
@@ -183,6 +212,7 @@ class DeltaStreamer:
                     cursor.links[index] = len(node_links)
             if links:
                 delta["links"] = links
+            self._maybe_add_routing_repairs(delta, trace, cursor, cursor.sent["nodes"])
             for field in LIST_FIELDS:
                 items = getattr(trace, field)
                 sent = cursor.sent[field]
@@ -220,6 +250,20 @@ class EpisodeAssembly:
     def __init__(self) -> None:
         self.traces: dict[str, dict] = {}
 
+    def _maybe_apply_routing_repairs(self, delta: dict[str, Any], trace: dict) -> None:
+        """Replace repaired final rows in nodes the client already holds.
+
+        Rebuild each array: a repair can widen its dtype, and decoded rows alias
+        the original delta's bytes, which must remain unchanged for consumers.
+        """
+        for index, row in (delta.get("routing_repairs") or {}).items():
+            node = trace["nodes"][int(index)]
+            node["routed_experts"] = _encode_ndarray(
+                np.concatenate(
+                    [_decode_ndarray(node["routed_experts"])[:-1], _decode_ndarray(row)]
+                )
+            )
+
     def apply(self, delta: dict) -> None:
         trace_id = delta["trace"]
         if delta.get("discard"):
@@ -234,6 +278,7 @@ class EpisodeAssembly:
             }
         for index, links in (delta.get("links") or {}).items():
             trace["nodes"][int(index)]["semantic_parents"].extend(links)
+        self._maybe_apply_routing_repairs(delta, trace)
         # a later `links` delta grows a node's semantic_parents in place, so the node
         # is copied: the delta stays as it was when the caller received it
         if "nodes" in delta: