verifiers 0.3.2.dev50__tar.gz → 0.3.2.dev52__tar.gz

{verifiers-0.3.2.dev50 → verifiers-0.3.2.dev52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev50
+Version: 0.3.2.dev52
 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.dev50 → verifiers-0.3.2.dev52}/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.dev50 → verifiers-0.3.2.dev52}/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.dev50 → verifiers-0.3.2.dev52}/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.dev50 → verifiers-0.3.2.dev52}/verifiers/v1/runtimes/modal.py

@@ -27,6 +27,7 @@ from verifiers.v1.runtimes.base import (
     RuntimeProcess,
 )
 from verifiers.v1.runtimes.limiters import creation_limiter
+from verifiers.v1.utils.aio import run_shielded
 
 logger = logging.getLogger(__name__)
 
@@ -128,25 +129,7 @@ class ModalRuntime(Runtime):
                 creation_limiter(self.config.creates_per_sec, "modal-sandbox")
                 or contextlib.nullcontext()
             ):
-                self._sandbox = await modal.Sandbox.create.aio(
-                    "sleep",
-                    "infinity",  # keep-alive entrypoint; the harness runs via `exec`
-                    app=app,
-                    name=self.name,
-                    # Clear the image's ENTRYPOINT so `sleep infinity` runs as the command
-                    # rather than as args to it — otherwise an image with its own entrypoint
-                    # (e.g. SWE task images) never starts the keep-alive and the sandbox dies.
-                    image=modal.Image.from_registry(self.config.image).entrypoint([]),
-                    workdir=self.config.workdir,
-                    env=self.env,
-                    cpu=self.config.cpu,
-                    memory=int(self.config.memory * 1024),  # Modal memory is MB
-                    gpu=self.config.gpu,
-                    region=self.config.region,
-                    block_network=not self.config.network_access,
-                    timeout=24 * 60 * 60,  # Maximum lifetime of any sandbox.
-                    encrypted_ports=[SERVICE_PORT],
-                )
+                await run_shielded(self._create_sandbox(app))
             self.info.id = self._sandbox.object_id
             logger.info(
                 "modal: sandbox %s up (image=%s)", self.info.id, self.config.image
@@ -157,6 +140,37 @@ class ModalRuntime(Runtime):
         ) as e:  # provisioning failure is one rollout's problem, not the eval's
             raise SandboxError(f"modal sandbox provisioning failed: {e}") from e
 
+    async def _create_sandbox(self, app) -> None:
+        """Create the sandbox and take ownership of the handle, as one shielded step.
+
+        Modal schedules the sandbox before `Sandbox.create` returns, so a cancellation
+        landing between those two points leaves a sandbox that boots and bills with
+        `_sandbox` still unset — invisible to both `teardown` and the atexit backstop, and
+        alive until its 24h maximum lifetime. Assigning inside the coroutine that
+        `run_shielded` owns keeps the cancellation pending until the handle is ours.
+        """
+        import modal
+
+        self._sandbox = await modal.Sandbox.create.aio(
+            "sleep",
+            "infinity",  # keep-alive entrypoint; the harness runs via `exec`
+            app=app,
+            name=self.name,
+            # Clear the image's ENTRYPOINT so `sleep infinity` runs as the command rather
+            # than as args to it — otherwise an image with its own entrypoint (e.g. SWE
+            # task images) never starts the keep-alive and the sandbox dies.
+            image=modal.Image.from_registry(self.config.image).entrypoint([]),
+            workdir=self.config.workdir,
+            env=self.env,
+            cpu=self.config.cpu,
+            memory=int(self.config.memory * 1024),  # Modal memory is MB
+            gpu=self.config.gpu,
+            region=self.config.region,
+            block_network=not self.config.network_access,
+            timeout=24 * 60 * 60,  # Maximum lifetime of any sandbox.
+            encrypted_ports=[SERVICE_PORT],
+        )
+
     async def expose(self, port: int) -> str | None:
         # Publish a server hosted IN the sandbox: Modal forwards `port` (named via
         # `encrypted_ports` at creation) to a public URL, read back from `sandbox.tunnels()`.

{verifiers-0.3.2.dev50 → verifiers-0.3.2.dev52}/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.dev50 → verifiers-0.3.2.dev52}/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,
                 )
             )