verifiers 0.3.2.dev165__tar.gz → 0.3.2.dev167__tar.gz

{verifiers-0.3.2.dev165 → verifiers-0.3.2.dev167}/PKG-INFO

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

@@ -487,7 +487,7 @@ def test_semantic_edge_uses_last_committed_retry_node():
     assert tr.nodes[3].semantic_parents == [vf.ParentLink(node=2, type="continuation")]
 
 
-def test_semantic_edge_cycle_is_rejected_without_partial_mutation():
+def test_semantic_edge_loops_attach_and_invalid_sets_do_not_partially_mutate():
     tr = vf.Trace(
         agent=vf.AgentInfo(config=vf.AgentConfig()),
         task=vf.TraceTask(type="Task", data=vf.TaskData(idx=0, prompt="q")),
@@ -507,21 +507,21 @@ def test_semantic_edge_cycle_is_rejected_without_partial_mutation():
         ],
     )
 
-    with pytest.raises(ValueError, match="cycle in the message graph"):
-        tr.add_semantic_edges(
-            vf.SemanticEdgeSet(
-                edges=[
-                    vf.SemanticEdge(
-                        source_request_id="second",
-                        target_request_id="first",
-                        type="custom",
-                    )
-                ]
-            )
-        )
-
+    loop = vf.SemanticEdge(
+        source_request_id="second", target_request_id="first", type="subagent_cancel"
+    )
+    unknown = vf.SemanticEdge(
+        source_request_id="first", target_request_id="missing", type="custom"
+    )
+    with pytest.raises(ValueError, match="has no committed message node"):
+        tr.add_semantic_edges(vf.SemanticEdgeSet(edges=[loop, unknown]))
     assert all(not node.semantic_parents for node in tr.nodes)
 
+    tr.add_semantic_edges(vf.SemanticEdgeSet(edges=[loop]))
+    assert tr.nodes[1].semantic_parents == [
+        vf.ParentLink(node=3, type="subagent_cancel")
+    ]
+
 
 def test_acp_info_is_validated_and_stripped():
     headers = {
@@ -689,7 +689,7 @@ def test_acp_derives_compaction_attempt_branch_trainability():
     assert restored_branches["accepted summary"].trainable is True
 
 
-def test_semantic_edge_set_rejects_duplicate_self_and_cyclic_edges():
+def test_semantic_edge_set_rejects_duplicate_and_self_edges_but_accepts_loops():
     edge_set = _semantic_edge_set().model_dump(mode="json")
     edge_set["edges"].append(edge_set["edges"][0])
     with pytest.raises(ValueError, match="duplicate semantic edge"):
@@ -708,16 +708,18 @@ def test_semantic_edge_set_rejects_duplicate_self_and_cyclic_edges():
             }
         )
 
+    # A parent cancels the child whose report it just read: the cancel lands on that child turn.
     edge_set = _semantic_edge_set().model_dump(mode="json")
     edge_set["edges"].append(
         {
             "source_request_id": "root-after",
-            "target_request_id": "root-turn",
-            "type": "custom",
+            "target_request_id": "child-turn",
+            "type": "subagent_cancel",
         }
     )
-    with pytest.raises(ValueError, match="semantic edge cycle"):
-        vf.SemanticEdgeSet.model_validate(edge_set)
+    assert len(vf.SemanticEdgeSet.model_validate(edge_set).edges) == len(
+        edge_set["edges"]
+    )
 
 
 def test_semantic_edge_set_accepts_deep_acyclic_chain():

{verifiers-0.3.2.dev165 → verifiers-0.3.2.dev167}/verifiers/v1/dialects/responses.py

@@ -393,6 +393,21 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
                     safe_input.append(item)
                     continue
                 kind = item.get("type")
+                if (
+                    kind == "reasoning"
+                    and not item.get("encrypted_content")
+                    and isinstance(content := item.get("content"), list)
+                    and content
+                    and all(
+                        isinstance(part, dict)
+                        and part.get("type") == "reasoning_text"
+                        and isinstance(part.get("text"), str)
+                        for part in content
+                    )
+                    and any(part["text"] for part in content)
+                ):
+                    # Inline reasoning needs no provider-side history lookup.
+                    item.pop("id", None)
                 if kind in ("additional_tools", "tool_search_output"):
                     if blocked := request_filter.blocked(
                         {**item, "tools": []}, item_path

{verifiers-0.3.2.dev165 → verifiers-0.3.2.dev167}/verifiers/v1/graph.py

@@ -90,10 +90,11 @@ class MessageNode(BaseModel):
     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.
+    """Typed incoming edges from other turns, declared by the harness (for example
+    ``subagent_return`` or ``subagent_cancel``).
 
-    Unlike ``parent``, these links do not imply an exact token prefix and therefore do
-    not affect physical branch construction. A list permits multiple parents of the same
+    They record causal links, not ancestry: unlike ``parent`` they imply no token prefix,
+    do not affect physical branch construction, and may form loops. A list permits multiple parents of the same
     type, supports incremental appends, and preserves their advertised wire order; edge
     application prevents duplicate ``(node, type)`` links.
     """

{verifiers-0.3.2.dev165 → verifiers-0.3.2.dev167}/verifiers/v1/harnesses/rlm/harness.py

@@ -69,7 +69,7 @@ class CompactionConfig(BaseConfig):
 
 class RLMHarnessConfig(HarnessConfig):
     version: str = Field(
-        default="f18f10800f86f13913e19ef930abe5fcde4aa90f", min_length=1
+        default="c38e20b60c90bbf625274d3fde2b2a384f390a66", 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."""

{verifiers-0.3.2.dev165 → verifiers-0.3.2.dev167}/verifiers/v1/semantic.py

@@ -60,11 +60,14 @@ class ParentLink(BaseModel):
 
 
 class SemanticEdgeSet(BaseModel):
-    """A harness-published set of semantic edges over logical request IDs.
+    """A harness-published list of typed edges between logical request IDs.
+
+    Each edge records that one turn caused or fed another. They are not ancestry, so
+    they may form loops: a cancel can land on the child turn whose report triggered it.
 
     Edge labels are intentionally extensible. Initial harnesses use ``continuation``,
-    ``compaction_attempt``, ``compaction``, ``subagent_call``, and ``subagent_return``;
-    consumers must preserve unknown labels.
+    ``compaction_attempt``, ``compaction``, ``subagent_call``, ``subagent_return``,
+    ``agent_message``, and ``subagent_cancel``; consumers must preserve unknown labels.
     """
 
     model_config = ConfigDict(extra="forbid", strict=True)
@@ -74,8 +77,6 @@ class SemanticEdgeSet(BaseModel):
     @model_validator(mode="after")
     def validate_edges(self) -> SemanticEdgeSet:
         identities: set[tuple[str, str, str]] = set()
-        children: dict[str, list[str]] = {}
-        nodes: set[str] = set()
         for edge in self.edges:
             identity = (
                 edge.source_request_id,
@@ -85,27 +86,6 @@ class SemanticEdgeSet(BaseModel):
             if identity in identities:
                 raise ValueError(f"duplicate semantic edge: {identity!r}")
             identities.add(identity)
-            children.setdefault(edge.source_request_id, []).append(
-                edge.target_request_id
-            )
-            nodes.update((edge.source_request_id, edge.target_request_id))
-
-        indegree = dict.fromkeys(nodes, 0)
-        for targets in children.values():
-            for target in targets:
-                indegree[target] += 1
-
-        stack = [node for node, degree in indegree.items() if degree == 0]
-        visited = 0
-        while stack:
-            node = stack.pop()
-            visited += 1
-            for child in children.get(node, ()):
-                indegree[child] -= 1
-                if indegree[child] == 0:
-                    stack.append(child)
-        if visited != len(nodes):
-            raise ValueError("semantic edge cycle detected")
         return self
 
 

{verifiers-0.3.2.dev165 → verifiers-0.3.2.dev167}/verifiers/v1/trace.py

@@ -568,7 +568,6 @@ class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
 
         resolved_identities: set[tuple[int, int, str]] = set()
         additions: list[tuple[int, ParentLink]] = []
-        pending_parents: dict[int, list[ParentLink]] = {}
         for edge in edge_set.edges:
             endpoints: list[int] = []
             for request_id in (
@@ -592,28 +591,7 @@ class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
             if link in self.nodes[target].semantic_parents:
                 continue
 
-            # Adding source -> target creates a cycle exactly when target is already an
-            # ancestor of source. Walk parent links directly so existing nodes and links
-            # are never rebuilt as cumulative ACP edge sets arrive.
-            stack = [source]
-            visited: set[int] = set()
-            while stack:
-                node_id = stack.pop()
-                if node_id == target:
-                    raise ValueError(
-                        "semantic edges create a cycle in the message graph"
-                    )
-                if node_id in visited:
-                    continue
-                visited.add(node_id)
-                node = self.nodes[node_id]
-                if node.parent is not None:
-                    stack.append(node.parent)
-                stack.extend(parent.node for parent in node.semantic_parents)
-                stack.extend(parent.node for parent in pending_parents.get(node_id, ()))
-
             additions.append((target, link))
-            pending_parents.setdefault(target, []).append(link)
 
         for target, link in additions:
             self.nodes[target].semantic_parents.append(link)