verifiers 0.3.2.dev92__tar.gz → 0.3.2.dev94__tar.gz

{verifiers-0.3.2.dev92 → verifiers-0.3.2.dev94}/PKG-INFO

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

@@ -69,7 +69,7 @@ def test_eval(taskset: str):
         "uv", "run", "--no-sync", "eval", taskset,
         *model,
         "-n", "1", "-r", "1", *caps,
-        "--sampling.max-tokens", "512", "--no-rich",
+        "--sampling.max-tokens", "512", "--no-rich", "--no-push",
     ]  # fmt: skip
     try:
         proc = subprocess.run(

{verifiers-0.3.2.dev92 → verifiers-0.3.2.dev94}/verifiers/v1/clients/train.py

@@ -16,7 +16,7 @@ from renderers.base import ToolCallParseStatus, is_multimodal
 from verifiers.v1.clients.base import build_async_openai
 from verifiers.v1.clients.client import SESSION_ID_HEADER, Client
 from verifiers.v1.configs.client import TrainClientConfig
-from verifiers.v1.dialects import FINISH_REASONS, ChatDialect, Dialect, parse_tools
+from verifiers.v1.dialects import FINISH_REASONS, ChatDialect, Dialect
 from verifiers.v1.dialects.chat import message_to_wire
 from verifiers.v1.errors import ProviderError, model_error
 from verifiers.v1.graph import PendingTurn
@@ -343,10 +343,9 @@ class TrainClient(Client):
                 f"{type(dialect).__name__}. Use the proxy client for this dialect, or add "
                 f"renderer support for it."
             )
-        # Intercepted turns already own the typed prompt, so only their tools need parsing here.
         if turn is not None:
             prompt = turn.prompt
-            tools = parse_tools(body.get("tools"))
+            tools = turn.tools
         else:
             request = dialect.parse_request(body)
             prompt = request.messages

{verifiers-0.3.2.dev92 → verifiers-0.3.2.dev94}/verifiers/v1/graph.py

@@ -87,6 +87,8 @@ class MessageNode(BaseModel):
 
     parent: int | None = None
     """Index into `Trace.nodes` of the predecessor message; None for a root."""
+    tools: list[Tool] = Field(default_factory=list, exclude_if=lambda tools: not tools)
+    """Tools rendered into this branch's prompt. Populated only on root nodes."""
     semantic_parents: list[ParentLink] = Field(default_factory=list)
     """Additional harness-declared parents in the semantic execution graph.
 
@@ -277,9 +279,8 @@ def message_hash(message: Message) -> str:
     """Stable content hash on the fields that round-trip through a prompt — role, content
     (None and "" equal), assistant reasoning content when present, assistant tool calls,
     opaque continuation state, tool call id. Two messages hash equal iff they're the same
-    conversational message, so a re-stated prefix message dedups to one node. The dedup key
-    for sharing a prefix across turns/branches; salt-free so it is identical across processes
-    and after deserialization."""
+    conversational message, so a re-stated prefix message dedups to one node. The message part
+    of the prefix key; salt-free so it is identical across processes and after deserialization."""
     digest = hashlib.blake2b(digest_size=16)
 
     def add(value: str) -> None:
@@ -350,21 +351,60 @@ def message_hash(message: Message) -> str:
     return digest.hexdigest()
 
 
-def _head_index(trace: Trace) -> dict[tuple[int | None, str], int]:
-    """`(parent, msg_hash) -> node_id`, rebuilt lazily from `nodes` after deserialization."""
+def _tools_hash(tools: list[Tool] | None) -> str:
+    payload = [tool.model_dump(mode="json", exclude_none=True) for tool in tools or []]
+    data = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
+    return hashlib.blake2b(data, digest_size=16).hexdigest()
+
+
+def _node_key(
+    parent: int | None, message: Message, tools: list[Tool] | None = None
+) -> tuple[int | None, str | None, str]:
+    return (
+        parent,
+        _tools_hash(tools) if parent is None else None,
+        message_hash(message),
+    )
+
+
+def _head_index(trace: Trace) -> dict[tuple[int | None, str | None, str], int]:
+    """Physical node key -> id, rebuilt lazily after deserialization."""
     if not trace._head_index and trace.nodes:
         trace._head_index = {
-            (node.parent, message_hash(node.message)): nid
+            _node_key(node.parent, node.message, node.tools): nid
             for nid, node in enumerate(trace.nodes)
         }
     return trace._head_index
 
 
+def message_prefix_len(trace: Trace, prompt: list[Message]) -> int:
+    """Length of the longest message-only graph prefix matching `prompt`."""
+    children: dict[int | None, list[int]] = {}
+    for node_id, node in enumerate(trace.nodes):
+        children.setdefault(node.parent, []).append(node_id)
+
+    parents: list[int | None] = [None]
+    matched = 0
+    for message in prompt:
+        key = message_hash(message)
+        parents = [
+            node_id
+            for parent in parents
+            for node_id in children.get(parent, [])
+            if message_hash(trace.nodes[node_id].message) == key
+        ]
+        if not parents:
+            break
+        matched += 1
+    return matched
+
+
 def _matching_node(
     trace: Trace,
     parent: int | None,
     message: Message,
     token_ids: list[int] | None = None,
+    tools: list[Tool] | None = None,
 ) -> int | None:
     """Find an existing child, optionally requiring its exact physical token span.
 
@@ -372,7 +412,7 @@ def _matching_node(
     prefix breaks can leave older physical variants under the same key, so a token mismatch falls
     back to a reverse scan rather than materializing a duplicate of an already-existing variant.
     """
-    key = (parent, message_hash(message))
+    key = _node_key(parent, message, tools)
     indexed = _head_index(trace).get(key)
     if indexed is not None and (
         token_ids is None or trace.nodes[indexed].token_ids == token_ids
@@ -387,7 +427,7 @@ def _matching_node(
         if (
             node.parent == parent
             and node.token_ids == token_ids
-            and message_hash(node.message) == key[1]
+            and _node_key(node.parent, node.message, node.tools) == key
         ):
             return node_id
     return None
@@ -400,6 +440,7 @@ def _matching_prefix_node(
     prompt_ids: list[int],
     start: int,
     stop: int,
+    tools: list[Tool] | None = None,
 ) -> int | None:
     """Find the longest content-equivalent child matching inside `[start, stop]`.
 
@@ -408,7 +449,7 @@ def _matching_prefix_node(
     otherwise-missing message boundary. The next attributed message's start bounds the match:
     a sampled variant must never consume tokens that the renderer assigned to that message.
     """
-    key = (parent, message_hash(message))
+    key = _node_key(parent, message, tools)
     indexed = _head_index(trace).get(key)
     candidates: list[int] = []
     if indexed is not None:
@@ -417,8 +458,12 @@ def _matching_prefix_node(
         node_id
         for node_id in range(len(trace.nodes) - 1, -1, -1)
         if node_id != indexed
-        and trace.nodes[node_id].parent == parent
-        and message_hash(trace.nodes[node_id].message) == key[1]
+        and _node_key(
+            trace.nodes[node_id].parent,
+            trace.nodes[node_id].message,
+            trace.nodes[node_id].tools,
+        )
+        == key
     )
     matches = [
         node_id
@@ -443,6 +488,7 @@ class PendingTurn:
 
     trace: Trace
     prompt: list[Message]
+    tools: list[Tool]
     prefix_node_ids: list[int]
     path_len: int
 
@@ -498,33 +544,43 @@ class PendingTurn:
             for span in tail_spans
         ]
 
-    def commit(self, response: Response, tools: list[Tool] | None = None) -> int:
+    def commit(self, response: Response) -> int:
         """Add this turn to the graph; returns the committed assistant node's id."""
         assistant_id = _commit_turn(self, response)
-        if tools:
-            self.trace.tools = tools
+        self.trace.tools = self.tools
         return assistant_id
 
-    def commit_prompt(self, tools: list[Tool] | None = None) -> None:
+    def commit_prompt(self) -> None:
         """Record an input that terminated before model inference."""
         parent = self.prefix_node_ids[-1] if self.prefix_node_ids else None
         index = _head_index(self.trace)
         for message in self.tail:
-            existing = _matching_node(self.trace, parent, message)
+            existing = _matching_node(self.trace, parent, message, tools=self.tools)
             if existing is not None:
                 parent = existing
                 continue
             previous = parent
-            self.trace.nodes.append(MessageNode(parent=parent, message=message))
+            self.trace.nodes.append(
+                MessageNode(
+                    parent=parent,
+                    message=message,
+                    tools=self.tools if parent is None else [],
+                )
+            )
             parent = len(self.trace.nodes) - 1
-            index[(previous, message_hash(message))] = parent
-        if tools:
-            self.trace.tools = tools
+            index[_node_key(previous, message, self.tools)] = parent
+        self.trace.tools = self.tools
 
 
-def prepare_turn(trace: Trace, prompt: list[Message]) -> PendingTurn:
-    """Resolve `prompt` against the trace graph without mutating it."""
+def prepare_turn(
+    trace: Trace,
+    prompt: list[Message],
+    tools: list[Tool] | None = None,
+) -> PendingTurn:
+    """Resolve a physical message-and-tools prefix without mutating the trace."""
     idx = _head_index(trace)
+    tools = list(tools or [])
+    tools_hash = _tools_hash(tools)
     parent: int | None = None
     path_len = 0
     prefix_node_ids: list[int] = []
@@ -537,15 +593,19 @@ def prepare_turn(trace: Trace, prompt: list[Message]) -> PendingTurn:
         ):
             children = [
                 node_id
-                for (node_parent, _), node_id in idx.items()
+                for (node_parent, node_tools_hash, _), node_id in idx.items()
                 if node_parent == parent
+                and (parent is not None or node_tools_hash == tools_hash)
             ]
             # Repeated image URLs are cheaper to compare than to encode and hash again.
             # Only scan short, unambiguous parents; all other cases use the stable index.
             if len(children) == 1 and trace.nodes[children[0]].message == msg:
                 existing = children[0]
         if existing is None:
-            existing = idx.get((parent, message_hash(msg)))
+            message_key = message_hash(msg)
+            existing = idx.get(
+                (parent, tools_hash if parent is None else None, message_key)
+            )
         if existing is None:
             break
         prefix_node_ids.append(existing)
@@ -554,6 +614,7 @@ def prepare_turn(trace: Trace, prompt: list[Message]) -> PendingTurn:
     return PendingTurn(
         trace=trace,
         prompt=prompt,
+        tools=tools,
         prefix_node_ids=prefix_node_ids,
         path_len=path_len,
     )
@@ -718,7 +779,13 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
                 len(prompt_ids),
             )
             existing = _matching_prefix_node(
-                trace, parent, prompt[i], prompt_ids, path_len, next_start
+                trace,
+                parent,
+                prompt[i],
+                prompt_ids,
+                path_len,
+                next_start,
+                turn.tools,
             )
             if existing is not None:
                 end += len(trace.nodes[existing].token_ids)
@@ -729,6 +796,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
                 parent,
                 prompt[i],
                 node_tokens if tokens is not None else None,
+                turn.tools,
             )
         if existing is None:
             break
@@ -746,7 +814,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
     if multi_modal_data is not None:
         mm_path = [(nid, prompt[i]) for i, nid in enumerate(prefix)]
     for i, msg in enumerate(prompt[num_reused:], start=num_reused):
-        key = (parent, message_hash(msg))
+        key = _node_key(parent, msg, turn.tools)
         start = path_len if cursor is None else cursor
         span = spans[i] if spans and i < len(spans) else None
         end = span[1] if span else start
@@ -756,6 +824,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
             # potentially huge token slices a second time.
             MessageNode.model_construct(
                 parent=parent,
+                tools=turn.tools if parent is None else [],
                 message=msg,
                 token_ids=node_tokens,
                 mask=[False] * len(node_tokens),
@@ -776,6 +845,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
     trace.nodes.append(
         MessageNode.model_construct(
             parent=parent,
+            tools=turn.tools if parent is None else [],
             message=response.message,
             sampled=True,
             token_ids=[*gen_prompt, *comp_ids],
@@ -789,7 +859,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
     )
     # Register the assistant so the next turn's prompt (which restates it) reuses this node.
     assistant_id = len(trace.nodes) - 1
-    idx[(parent, message_hash(response.message))] = assistant_id
+    idx[_node_key(parent, response.message, turn.tools)] = assistant_id
     new_node_ids.append(assistant_id)
 
     # Attribute this turn's images onto the input nodes that introduced them (by content part).

{verifiers-0.3.2.dev92 → verifiers-0.3.2.dev94}/verifiers/v1/interception/server.py

@@ -638,8 +638,10 @@ class InterceptionServer(Interception):
         except BaseException:
             raise
         if stopped is not None:
-            turn = graph.prepare_turn(session.trace, model_request.messages)
-            turn.commit_prompt(model_request.tools)
+            turn = graph.prepare_turn(
+                session.trace, model_request.messages, model_request.tools
+            )
+            turn.commit_prompt()
             session.trace.stop(stopped)
             return web.json_response(
                 dialect.error_body(f"rollout stopped: {stopped}"),
@@ -651,7 +653,9 @@ class InterceptionServer(Interception):
             # Restricted mediation can mutate the body without reporting policy paths.
             if request_rewrites or session.network_policy.network_restricted:
                 model_request = dialect.parse_request(body)
-            turn = graph.prepare_turn(session.trace, model_request.messages)
+            turn = graph.prepare_turn(
+                session.trace, model_request.messages, model_request.tools
+            )
         except ValueError as error:
             return web.json_response(dialect.error_body(str(error)), status=400)
         except RolloutError as error:
@@ -739,7 +743,7 @@ class InterceptionServer(Interception):
                             ),
                             status=400,
                         )
-                    node = turn.commit(call_response, model_request.tools)
+                    node = turn.commit(call_response)
                     session.consume_prepared(turn.tail)
                     session.trace.response_rewrites.extend(response_rewrites)
                     if stopped is not None:
@@ -905,7 +909,7 @@ class InterceptionServer(Interception):
                         ),
                         status=409 if session.released else 400,
                     )
-                node = turn.commit(response, model_request.tools)
+                node = turn.commit(response)
                 session.consume_prepared(turn.tail)
                 session.trace.response_rewrites.extend(response_rewrites)
                 if stopped is not None:
@@ -1013,7 +1017,7 @@ class InterceptionServer(Interception):
                     raise parser_error
                 response = parser.finish()
                 if not session.released and not session.stopped:
-                    node = turn.commit(response, model_request.tools)
+                    node = turn.commit(response)
                     session.consume_prepared(turn.tail)
                     logger.debug("intercept stream turn: id=%s", session.trace.id)
                 elif session.stopped:

{verifiers-0.3.2.dev92 → verifiers-0.3.2.dev94}/verifiers/v1/session.py

@@ -162,9 +162,9 @@ class RolloutSession:
         prepared: set[int] = set()
         candidates: set[int] = set()
         if self.request_interceptors:
-            turn = graph.prepare_turn(self.trace, request.messages)
+            tail_start = graph.message_prefix_len(self.trace, request.messages)
             prepared_users = self.prepared_users.copy()
-            for position in range(turn.tail_start, len(request.messages)):
+            for position in range(tail_start, len(request.messages)):
                 message = request.messages[position]
                 if isinstance(message, UserMessage):
                     candidates.add(position)
@@ -350,7 +350,7 @@ class RolloutSession:
         request, records, stopped = await self.rewrite_request(
             Request(
                 messages=[*branch.messages, *previous, message],
-                tools=self.trace.tools or None,
+                tools=branch.tools or None,
             )
         )
         candidate = request.messages[-1]
@@ -358,7 +358,7 @@ class RolloutSession:
         self.trace.request_rewrites.extend(records)
         if stopped is not None:
             committed = request.messages if phase == "after" else request.messages[:-1]
-            turn = graph.prepare_turn(self.trace, committed)
+            turn = graph.prepare_turn(self.trace, committed, request.tools)
             turn.commit_prompt()
             self.consume_prepared(turn.tail)
             self.trace.stop(stopped)

{verifiers-0.3.2.dev92 → verifiers-0.3.2.dev94}/verifiers/v1/trace.py

@@ -206,6 +206,10 @@ class Branch(BaseModel):
     def messages(self) -> Messages:
         return [n.message for n in self.nodes]
 
+    @property
+    def tools(self) -> list[Tool]:
+        return self.nodes[0].tools if self.nodes else []
+
     @property
     def token_ids(self) -> list[int]:
         """Training input IDs formed by concatenating node token spans."""
@@ -442,7 +446,7 @@ class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
     timing: Timing = Field(default_factory=Timing)
 
     _head_index: dict = PrivateAttr(default_factory=dict)
-    """`(parent, msg_hash) -> node_id` for the graph builder."""
+    """Physical node key -> node id for the graph builder."""
 
     @field_serializer("mm_token_type_id_map")
     def serialize_mm_token_type_id_map(self, mapping: dict[int, int]) -> dict[str, int]: