verifiers 0.3.2.dev51__tar.gz → 0.3.2.dev53__tar.gz

{verifiers-0.3.2.dev51 → verifiers-0.3.2.dev53}/PKG-INFO

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

@@ -5,6 +5,9 @@ combinations a test runs — every axis value at least once plus the cross-bound
 with distinct networking — instead of fanning the full cross product. prime/modal rows
 are local-only (their marks are excluded in CI)."""
 
+import subprocess
+import sys
+
 import pytest
 
 mark = pytest.mark
@@ -675,6 +678,37 @@ async def test_multi_agent_env_server(run_v1_server, tmp_path):
         assert trace.metrics["duet"] == 1.0
 
 
+# `_request` parks a cancelled run's fire-and-forget cancel in `_cancel_tasks` with a
+# `discard` done-callback. One loop turn later the sends have finished but the callbacks
+# are still queued behind us, so `close()` meets a set of finished tasks.
+CLOSE_WITH_FINISHED_CANCELS = """
+import asyncio, uuid
+from verifiers.v1.serve.client import EnvClient
+
+async def main():
+    client = EnvClient("tcp://127.0.0.1:1")
+    for _ in range(3):
+        task = asyncio.get_running_loop().create_task(client._send_cancel(uuid.uuid4().hex))
+        client._cancel_tasks.add(task)
+        task.add_done_callback(client._cancel_tasks.discard)
+    await asyncio.sleep(0)
+    assert all(task.done() for task in client._cancel_tasks) and client._cancel_tasks
+    await client.close()
+
+asyncio.run(main())
+"""
+
+
+def test_env_client_close_drains_finished_cancels():
+    """`close()` returns once every fire-and-forget cancel has run, also when all of them
+    finished before it looked: the state Ctrl-C leaves behind in served mode. A child
+    process bounds the check, since a `close()` that never yields to the loop never lets
+    an in-loop timeout fire either."""
+    subprocess.run(
+        [sys.executable, "-c", CLOSE_WITH_FINISHED_CANCELS], check=True, timeout=30
+    )
+
+
 @pytest.mark.e2e
 async def test_replay_round_trip(run_v1, tmp_path):
     """eval -> replay -> replay-the-replay. Offline re-scoring must preserve the saved

{verifiers-0.3.2.dev51 → verifiers-0.3.2.dev53}/tests/v1/test_trace.py

@@ -434,6 +434,134 @@ def test_acp_semantic_edge_metadata_is_optional():
     assert all(not node.semantic_parents for node in trace.nodes)
 
 
+def test_acp_derives_compaction_attempt_branch_trainability():
+    trace = vf.Trace(
+        agent=vf.AgentInfo(config=vf.AgentConfig()),
+        task=vf.TraceTask(type="Task", data=vf.TaskData(idx=0, prompt="q")),
+        nodes=[
+            MessageNode(parent=None, message=UserMessage(content="work")),
+            MessageNode(
+                parent=0,
+                message=AssistantMessage(content="working"),
+                sampled=True,
+                token_ids=[1],
+                mask=[True],
+                logprobs=[-0.1],
+            ),
+            MessageNode(parent=1, message=UserMessage(content="summarize")),
+            MessageNode(
+                parent=2,
+                message=AssistantMessage(content="bad tool call"),
+                sampled=True,
+                token_ids=[2, 3],
+                mask=[True, True],
+                logprobs=[-0.2, -0.3],
+            ),
+            MessageNode(
+                parent=2,
+                message=AssistantMessage(content="accepted summary"),
+                sampled=True,
+                token_ids=[4, 5],
+                mask=[True, True],
+                logprobs=[-0.4, -0.5],
+            ),
+            MessageNode(parent=0, message=UserMessage(content="compacted context")),
+            MessageNode(
+                parent=5,
+                message=AssistantMessage(content="answer"),
+                sampled=True,
+                token_ids=[6],
+                mask=[True],
+                logprobs=[-0.6],
+            ),
+        ],
+        calls=[
+            vf.ModelCall(node=1, acp=vf.ACPInfo(request_id="work")),
+            vf.ModelCall(node=3, acp=vf.ACPInfo(request_id="rejected")),
+            vf.ModelCall(node=4, acp=vf.ACPInfo(request_id="accepted")),
+            vf.ModelCall(node=6, acp=vf.ACPInfo(request_id="resumed")),
+        ],
+    )
+    harness = RLMHarness(RLMHarnessConfig(id="rlm"))
+    harness._consume_protocol_metadata(
+        trace,
+        {
+            ACP_SEMANTIC_EDGES_METADATA_KEY: {
+                "edges": [
+                    {
+                        "source_request_id": "work",
+                        "target_request_id": "rejected",
+                        "type": "compaction_attempt",
+                    },
+                    {
+                        "source_request_id": "work",
+                        "target_request_id": "accepted",
+                        "type": "compaction_attempt",
+                    },
+                ]
+            },
+        },
+    )
+
+    attempts = {branch.nodes[-1].message.content: branch for branch in trace.branches}
+    assert attempts["bad tool call"].trainable is False
+    assert attempts["accepted summary"].trainable is False
+
+    harness._consume_protocol_metadata(
+        trace,
+        {
+            ACP_SEMANTIC_EDGES_METADATA_KEY: {
+                "edges": [
+                    {
+                        "source_request_id": "work",
+                        "target_request_id": "rejected",
+                        "type": "compaction_attempt",
+                    },
+                    {
+                        "source_request_id": "work",
+                        "target_request_id": "accepted",
+                        "type": "compaction_attempt",
+                    },
+                    {
+                        "source_request_id": "accepted",
+                        "target_request_id": "resumed",
+                        "type": "compaction",
+                    },
+                ]
+            },
+        },
+    )
+
+    assert trace.nodes[3].sampled is True
+    assert trace.nodes[3].mask == [True, True]
+    assert trace.nodes[4].mask == [True, True]
+    assert trace.nodes[6].mask == [True]
+    assert trace.nodes[3].semantic_parents == [
+        vf.ParentLink(node=1, type="compaction_attempt")
+    ]
+    assert trace.nodes[4].semantic_parents == [
+        vf.ParentLink(node=1, type="compaction_attempt")
+    ]
+    assert trace.nodes[6].semantic_parents == [vf.ParentLink(node=4, type="compaction")]
+    assert trace.num_branches == 3
+    branches = {branch.nodes[-1].message.content: branch for branch in trace.branches}
+    assert branches["bad tool call"].trainable is False
+    assert branches["accepted summary"].trainable is True
+    assert branches["answer"].trainable is True
+    assert branches["bad tool call"].nodes[-2] is trace.nodes[2]
+    assert branches["accepted summary"].nodes[-2] is trace.nodes[2]
+
+    restored = vf.WireTrace.model_validate_json(trace.model_dump_json())
+    assert restored.nodes[3].sampled is True
+    assert restored.nodes[3].mask == [True, True]
+    assert restored.nodes[4].mask == [True, True]
+    restored_branches = {
+        branch.nodes[-1].message.content: branch for branch in restored.branches
+    }
+    assert restored_branches["bad tool call"].trainable is False
+    assert restored_branches["accepted summary"].trainable is True
+
+
 def test_semantic_edge_set_rejects_duplicate_self_and_cyclic_edges():
     edge_set = _semantic_edge_set().model_dump(mode="json")
     edge_set["edges"].append(edge_set["edges"][0])

{verifiers-0.3.2.dev51 → verifiers-0.3.2.dev53}/verifiers/v1/acp/__init__.py

@@ -78,12 +78,11 @@ class ACPHarness(Harness[ConfigT]):
         self, trace: Trace, response_metadata: dict[str, Any]
     ) -> None:
         """Attach optional protocol extensions understood by every ACP harness."""
-        if ACP_SEMANTIC_EDGES_METADATA_KEY not in response_metadata:
-            return
-        edge_set = SemanticEdgeSet.model_validate(
-            response_metadata[ACP_SEMANTIC_EDGES_METADATA_KEY]
-        )
-        trace.add_semantic_edges(edge_set)
+        if ACP_SEMANTIC_EDGES_METADATA_KEY in response_metadata:
+            edge_set = SemanticEdgeSet.model_validate(
+                response_metadata[ACP_SEMANTIC_EDGES_METADATA_KEY]
+            )
+            trace.add_semantic_edges(edge_set)
 
     @abstractmethod
     async def prepare_acp(

{verifiers-0.3.2.dev51 → verifiers-0.3.2.dev53}/verifiers/v1/harnesses/rlm/harness.py

@@ -51,10 +51,13 @@ class CompactionConfig(BaseConfig):
     max_compactions: PositiveInt | None = None
     """Compactions per session before the engine stops compacting; `None` =
     nano-rlm's default."""
+    max_attempts: PositiveInt | None = None
+    """Summary-generation attempts within one compaction cycle; `None` =
+    nano-rlm's default (5)."""
 
 
 class RLMHarnessConfig(HarnessConfig):
-    version: str = Field(default="dd2c04f", min_length=1)
+    version: str = Field(default="e384006", min_length=1)
     """Git ref (branch, tag, or commit) of nano-rlm to install. Must know every
     field this harness puts on the wire, i.e. be at least the default ref."""
     max_depth: NonNegativeInt | None = None
@@ -170,6 +173,7 @@ class RLMHarness(ACPHarness[RLMHarnessConfig]):
             policy_knobs["compaction"] = True
             policy_knobs["summarize_at_tokens"] = compaction.summarize_at_tokens
             policy_knobs["max_compactions"] = compaction.max_compactions
+            policy_knobs["max_compaction_attempts"] = compaction.max_attempts
         appends = [
             text
             for text in (system_prompt, self.config.append_to_system_prompt)

{verifiers-0.3.2.dev51 → verifiers-0.3.2.dev53}/verifiers/v1/semantic.py

@@ -63,8 +63,8 @@ class SemanticEdgeSet(BaseModel):
     """A harness-published set of semantic edges over logical request IDs.
 
     Edge labels are intentionally extensible. Initial harnesses use ``continuation``,
-    ``compaction``, ``subagent_call``, and ``subagent_return``; consumers must preserve
-    unknown labels.
+    ``compaction_attempt``, ``compaction``, ``subagent_call``, and ``subagent_return``;
+    consumers must preserve unknown labels.
     """
 
     model_config = ConfigDict(extra="forbid", strict=True)

{verifiers-0.3.2.dev51 → verifiers-0.3.2.dev53}/verifiers/v1/serve/client.py

@@ -187,8 +187,12 @@ class EnvClient:
             self._receiver = None
         # Let scheduled fire-and-forget cancels reach the socket first, or a
         # run cancelled right before close() leaves its server-side rollout
-        # running. Loop: awaiting one wave can schedule another
+        # running. Pop before awaiting: awaiting finished tasks never yields
+        # (since CPython 3.12 a gather of them completes eagerly), so their
+        # queued `discard` callbacks cannot be what empties the set
         while self._cancel_tasks:
-            await asyncio.gather(*list(self._cancel_tasks), return_exceptions=True)
+            task = self._cancel_tasks.pop()
+            with contextlib.suppress(asyncio.CancelledError):
+                await task
         self.socket.close()
         self.ctx.term()

{verifiers-0.3.2.dev51 → verifiers-0.3.2.dev53}/verifiers/v1/trace.py

@@ -20,11 +20,7 @@ from verifiers.v1.configs.agent import AgentConfig, WireAgentConfig
 from verifiers.v1.errors import ProviderError
 from verifiers.v1.graph import RECORD_FLOAT_DECIMALS, MessageNode
 from verifiers.v1.runtimes import RuntimeInfo
-from verifiers.v1.semantic import (
-    ACPInfo,
-    ParentLink,
-    SemanticEdgeSet,
-)
+from verifiers.v1.semantic import ACPInfo, ParentLink, SemanticEdgeSet
 from verifiers.v1.state import State, StateT
 from verifiers.v1.task import DataT, WireTaskData
 from verifiers.v1.types import (
@@ -201,6 +197,8 @@ class Branch(BaseModel):
     index: int
     nodes: list[MessageNode]
     calls: list[ModelCall] = Field(default_factory=list)
+    trainable: bool = True
+    """Whether this physical path contributes a training sample."""
     mm_token_type_id_map: dict[int, int] = Field(default_factory=dict)
     """The trace's `mm_token_type_id_map`, carried so `mm_token_type_ids` is self-contained."""
 
@@ -492,8 +490,18 @@ class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
 
     @property
     def branches(self) -> list[Branch]:
-        """One root-to-leaf path per graph leaf, its calls attached in path order."""
+        """One root-to-leaf view per graph leaf, with no duplicated node storage.
+
+        A compaction attempt is a dangling physical leaf. It is trainable only when
+        the final semantic graph shows that the harness resumed from it.
+        """
         by_node = {c.node: c for c in self.calls if c.node is not None}
+        accepted_compaction_attempts = {
+            link.node
+            for node in self.nodes
+            for link in node.semantic_parents
+            if link.type == "compaction"
+        }
         branches: list[Branch] = []
         for i, leaf in enumerate(graph.leaves(self)):
             path: list[int] = []
@@ -502,11 +510,19 @@ class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
                 path.append(nid)
                 nid = self.nodes[nid].parent
             path.reverse()
+            is_compaction_attempt = any(
+                link.type == "compaction_attempt"
+                for link in self.nodes[leaf].semantic_parents
+            )
             branches.append(
                 Branch(
                     index=i,
                     nodes=[self.nodes[n] for n in path],
                     calls=[by_node[n] for n in path if n in by_node],
+                    trainable=(
+                        not is_compaction_attempt
+                        or leaf in accepted_compaction_attempts
+                    ),
                     mm_token_type_id_map=self.mm_token_type_id_map,
                 )
             )