verifiers 0.4.1.dev35__tar.gz → 0.4.1.dev37__tar.gz

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.4.1.dev35
+Version: 0.4.1.dev37
 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.4.1.dev35 → verifiers-0.4.1.dev37}/tests/integration/grid.py

@@ -32,6 +32,7 @@ prime cannot pull) stay outside the grid.
 
 import shutil
 from collections.abc import Sequence
+from typing import get_args
 
 import pytest
 from pydantic import TypeAdapter
@@ -40,7 +41,7 @@ import verifiers.v1 as vf
 from verifiers.v1.configs.runtime import NetworkPolicyConfig
 from verifiers.v1.harness import Harness
 from verifiers.v1.runtimes import RuntimeConfig, _backend_cls
-from verifiers.v1.utils.loaders import harness_class
+from verifiers.v1.utils.loaders import harness_class, harness_config_type
 
 HARNESSES: list[str | dict] = [
     "null",
@@ -191,6 +192,36 @@ def grid(
     return cells
 
 
+def transports(harness: str) -> tuple[str, ...]:
+    """The wire formats the harness config can select (`transport`) besides its
+    default. Empty when the program speaks one format or picks its own."""
+    field = harness_config_type(harness).model_fields.get("transport")
+    if field is None:
+        return ()
+    return tuple(t for t in get_args(field.annotation) if t != field.default)
+
+
+def transport_grid(
+    runtimes: Sequence[str] = ("prime",), *, needs: tuple[str, ...] = ()
+) -> list:
+    """`grid` cells for every non-default `transport` each harness config can select."""
+    cells = []
+    for harness in HARNESSES:
+        name = harness_id(harness)
+        for transport in transports(name):
+            for cell in grid(
+                [{"id": name, "transport": transport}], runtimes, needs=needs
+            ):
+                cells.append(
+                    pytest.param(
+                        *cell.values,
+                        marks=cell.marks,
+                        id=cell.id.replace(f"{name}-in-", f"{name}-{transport}-in-"),
+                    )
+                )
+    return cells
+
+
 def skip_harness(cells: list, harness: str, reason: str) -> list:
     """Skip one harness's cells for a limit no capability flag declares. Each use names
     why, so a reader sees the gap and when it can go."""

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/tests/integration/test_multi_turn.py

@@ -1,11 +1,14 @@
 """One task, many turns: the model completes a shell task (echo-agentic-v1: write a phrase
-to a file, checked in the runtime) across the harness x runtime grid."""
+to a file, checked in the runtime) across the harness x runtime grid, and on prime over
+every other `transport` a harness config can select. A turn the harness re-sends
+differently, beyond what its `replay_view` declares, forks the trace."""
 
 import pytest
-from grid import grid, mark
+from grid import grid, mark, transport_grid
 
 MULTI_TURN = [
     *grid(needs=("shell",)),
+    *transport_grid(needs=("shell",)),
     pytest.param(
         "bash",
         {"type": "modal", "allow": []},

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/tests/integration/test_multi_turn_tool.py

@@ -28,7 +28,11 @@ async def test_tool(run, harness, harness_runtime):
     # Reward 1.0 is the proof the tool ran. How a program surfaces an MCP tool to the
     # model is its own business (rlm calls it from code; chat loops advertise it), so
     # the advertised schema is checked on the chat loop in `test_tool_placement`.
-    assert trace.reward == 1.0
+    assert trace.reward == 1.0, "\n".join(
+        message.model_dump_json(exclude_none=True)
+        for message in trace.messages
+        if message.role in {"assistant", "tool"}
+    )
 
 
 @pytest.mark.parametrize(

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/tests/unit/test_graph.py

@@ -270,6 +270,30 @@ def test_reasoning_content_participates_in_graph_prefix_matching():
     assert len(tool_call_nodes) == 2
 
 
+def _replayed_trace(replay_view, sampled, replayed, dialect=None):
+    """One tool turn sampled as `sampled` and re-sent as `replayed` on the next turn."""
+    trace = vf.Trace(
+        agent=vf.AgentInfo(config=vf.AgentConfig()),
+        task=vf.TraceTask(type="Task", data=vf.TaskData(idx=0, prompt="go")),
+    )
+    trace._replay_view = replay_view
+    user = vf.UserMessage(content="go")
+    call = vf.ToolCall(id="call_0", name="lookup", arguments="{}")
+    graph.prepare_turn(trace, [user], dialect=dialect).commit(
+        _response(vf.AssistantMessage(tool_calls=[call], **sampled))
+    )
+    graph.prepare_turn(
+        trace,
+        [
+            user,
+            vf.AssistantMessage(tool_calls=[call], **replayed),
+            vf.ToolMessage(content="result", tool_call_id="call_0"),
+        ],
+        dialect=dialect,
+    ).commit(_response(vf.AssistantMessage(content="done")))
+    return trace
+
+
 @pytest.mark.parametrize(
     "view,sampled,replayed",
     [
@@ -284,29 +308,48 @@ def test_reasoning_content_participates_in_graph_prefix_matching():
     ],
 )
 def test_replay_view_matches_cosmetically_rewritten_turns(view, sampled, replayed):
-    def run(replay_view):
-        trace = vf.Trace(
-            agent=vf.AgentInfo(config=vf.AgentConfig()),
-            task=vf.TraceTask(type="Task", data=vf.TaskData(idx=0, prompt="go")),
-        )
-        trace._replay_view = replay_view
-        user = vf.UserMessage(content="go")
-        call = vf.ToolCall(id="call_0", name="lookup", arguments="{}")
-        graph.prepare_turn(trace, [user]).commit(
-            _response(vf.AssistantMessage(tool_calls=[call], **sampled))
-        )
-        graph.prepare_turn(
-            trace,
-            [
-                user,
-                vf.AssistantMessage(tool_calls=[call], **replayed),
-                vf.ToolMessage(content="result", tool_call_id="call_0"),
-            ],
-        ).commit(_response(vf.AssistantMessage(content="done")))
-        return trace
-
-    assert run(None).num_branches == 2
-    assert run(view).num_branches == 1
+    assert _replayed_trace(None, sampled, replayed).num_branches == 2
+    trace = _replayed_trace(lambda message, _: view(message), sampled, replayed)
+    assert trace.num_branches == 1
+
+
+@pytest.mark.parametrize(
+    "dialect,branches", [("chat_completions", 1), ("responses", 2)]
+)
+def test_replay_view_receives_the_request_dialect(dialect, branches):
+    def view(message, dialect):
+        return drop_blank_text(message) if dialect == "chat_completions" else message
+
+    trace = _replayed_trace(view, {"content": "\n\n"}, {"content": None}, dialect)
+    assert trace.num_branches == branches
+
+
+def test_overlapping_requests_keep_their_own_dialect():
+    trace = vf.Trace(
+        agent=vf.AgentInfo(config=vf.AgentConfig()),
+        task=vf.TraceTask(type="Task", data=vf.TaskData(idx=0, prompt="go")),
+    )
+    trace._replay_view = lambda message, dialect: (
+        drop_blank_text(message) if dialect == "chat_completions" else message
+    )
+    user = vf.UserMessage(content="go")
+    call = vf.ToolCall(id="call_0", name="lookup", arguments="{}")
+    graph.prepare_turn(trace, [user], dialect="chat_completions").commit(
+        _response(vf.AssistantMessage(content="\n\n", tool_calls=[call]))
+    )
+    replay = [
+        user,
+        vf.AssistantMessage(tool_calls=[call]),
+        vf.ToolMessage(content="result", tool_call_id="call_0"),
+    ]
+    chat = graph.prepare_turn(trace, replay, dialect="chat_completions")
+    responses = graph.prepare_turn(trace, replay, dialect="responses")
+    responses.commit(_response(vf.AssistantMessage(content="other")))
+    done = chat.commit(_response(vf.AssistantMessage(content="done")))
+
+    assert chat.prefix_node_ids == [0, 1]
+    assert responses.prefix_node_ids == [0]
+    assert graph.path(trace, done)[1] == trace.nodes[1].message
 
 
 @pytest.mark.parametrize("same_tools", [False, True])

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/dialects/anthropic.py

@@ -437,6 +437,7 @@ class ModdedAnthropicMessage(AnthropicMessage):
 
 
 class AnthropicDialect(Dialect[AnthropicMessage]):
+    name = "anthropic_messages"
     sampling_fields = frozenset(
         {
             "temperature",

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/dialects/base.py

@@ -27,7 +27,13 @@ from verifiers.v1.configs.runtime import (
     intersect_network_hosts,
     parse_network_rule,
 )
-from verifiers.v1.types import Request, Response, Sampling, SamplingConfig
+from verifiers.v1.types import (
+    DialectName,
+    Request,
+    Response,
+    Sampling,
+    SamplingConfig,
+)
 
 RespT = TypeVar("RespT", bound=BaseModel)
 RawRequest = dict[str, Any]
@@ -263,6 +269,9 @@ class Dialect(ABC, Generic[RespT]):
     rewriting them. Implement a `Dialect` + register it in `dialects.DIALECTS` and a harness
     speaking that format works end-to-end."""
 
+    name: ClassVar[DialectName]
+    """The wire format's name, passed to `Harness.replay_view`."""
+
     sampling_fields: ClassVar[frozenset[str]] = frozenset()
     """Request keys that are call settings — what shapes generation given the same
     conversation: decoding knobs, budgets/stops, reasoning effort, output contract.

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/dialects/chat.py

@@ -397,6 +397,7 @@ class ChatStreamParser(StreamParser):
 
 
 class ChatDialect(Dialect[ChatCompletion]):
+    name = "chat_completions"
     sampling_fields = frozenset(
         {
             "temperature",

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/dialects/responses.py

@@ -354,6 +354,7 @@ class ResponsesStreamParser(StreamParser):
 
 
 class ResponsesDialect(Dialect[OpenAIResponse]):
+    name = "responses"
     sampling_fields = frozenset(
         {
             "temperature",

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/graph.py

@@ -42,6 +42,7 @@ from renderers.base import RenderedTokens
 from verifiers.v1.semantic import ParentLink
 from verifiers.v1.types import (
     AssistantMessage,
+    DialectName,
     Message,
     Response,
     SamplingMask,
@@ -321,11 +322,12 @@ def _tools_hash(tools: list[Tool] | None) -> str:
     return hashlib.blake2b(data, digest_size=16).hexdigest()
 
 
-def _message_key(trace: Trace, message: Message) -> str:
-    """`message_hash` of the message as the trace's harness replays it, so a turn the
-    harness re-sends with cosmetic rewrites still matches the node it came from."""
+def _message_key(trace: Trace, message: Message, dialect: DialectName | None) -> str:
+    """`message_hash` of the message as the trace's harness replays it over `dialect`,
+    so a turn the harness re-sends with cosmetic rewrites still matches the node it
+    came from."""
     view = trace._replay_view
-    return message_hash(view(message) if view is not None else message)
+    return message_hash(view(message, dialect) if view is not None else message)
 
 
 def _node_key(
@@ -333,25 +335,43 @@ def _node_key(
     parent: int | None,
     message: Message,
     tools: list[Tool] | None = None,
+    *,
+    dialect: DialectName | None,
 ) -> tuple[int | None, str | None, str]:
     return (
         parent,
         _tools_hash(tools) if parent is None else None,
-        _message_key(trace, message),
+        _message_key(trace, message, dialect),
     )
 
 
-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_key(trace, node.parent, node.message, node.tools): nid
+def _head_index(
+    trace: Trace, dialect: DialectName | None
+) -> dict[tuple[int | None, str | None, str], int]:
+    """Physical node key -> id under `dialect`'s replay view, built lazily per dialect
+    (and after deserialization)."""
+    index = trace._head_index.get(dialect)
+    if index is None:
+        index = trace._head_index[dialect] = {
+            _node_key(
+                trace, node.parent, node.message, node.tools, dialect=dialect
+            ): nid
             for nid, node in enumerate(trace.nodes)
         }
-    return trace._head_index
+    return index
 
 
-def message_prefix_len(trace: Trace, prompt: list[Message]) -> int:
+def _index_node(trace: Trace, node_id: int) -> None:
+    """Point every built dialect index at a new node."""
+    node = trace.nodes[node_id]
+    for dialect, index in trace._head_index.items():
+        key = _node_key(trace, node.parent, node.message, node.tools, dialect=dialect)
+        index[key] = node_id
+
+
+def message_prefix_len(
+    trace: Trace, prompt: list[Message], dialect: DialectName | None = None
+) -> 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):
@@ -360,12 +380,12 @@ def message_prefix_len(trace: Trace, prompt: list[Message]) -> int:
     parents: list[int | None] = [None]
     matched = 0
     for message in prompt:
-        key = _message_key(trace, message)
+        key = _message_key(trace, message, dialect)
         parents = [
             node_id
             for parent in parents
             for node_id in children.get(parent, [])
-            if _message_key(trace, trace.nodes[node_id].message) == key
+            if _message_key(trace, trace.nodes[node_id].message, dialect) == key
         ]
         if not parents:
             break
@@ -380,6 +400,8 @@ def _matching_node(
     token_ids: list[int] | None = None,
     renderer_token_ids: list[int] | None = None,
     tools: list[Tool] | None = None,
+    *,
+    dialect: DialectName | None,
 ) -> int | None:
     """Find an existing child, optionally requiring its exact token spans.
 
@@ -387,8 +409,8 @@ 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 = _node_key(trace, parent, message, tools)
-    indexed = _head_index(trace).get(key)
+    key = _node_key(trace, parent, message, tools, dialect=dialect)
+    indexed = _head_index(trace, dialect).get(key)
     if (
         indexed is not None
         and (token_ids is None or trace.nodes[indexed].token_ids == token_ids)
@@ -407,7 +429,8 @@ def _matching_node(
         if (
             (token_ids is None or node.token_ids == token_ids)
             and (renderer_token_ids is None or node.logical_ids == renderer_token_ids)
-            and _node_key(trace, node.parent, node.message, node.tools) == key
+            and _node_key(trace, node.parent, node.message, node.tools, dialect=dialect)
+            == key
         ):
             return node_id
     return None
@@ -424,6 +447,8 @@ def _matching_prefix_node(
     renderer_start: int,
     renderer_stop: int,
     tools: list[Tool] | None = None,
+    *,
+    dialect: DialectName | None,
 ) -> int | None:
     """Find the longest content-equivalent child matching inside `[start, stop]`.
 
@@ -432,8 +457,8 @@ 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 = _node_key(trace, parent, message, tools)
-    indexed = _head_index(trace).get(key)
+    key = _node_key(trace, parent, message, tools, dialect=dialect)
+    indexed = _head_index(trace, dialect).get(key)
     candidates: list[int] = []
     if indexed is not None:
         candidates.append(indexed)
@@ -446,6 +471,7 @@ def _matching_prefix_node(
             trace.nodes[node_id].parent,
             trace.nodes[node_id].message,
             trace.nodes[node_id].tools,
+            dialect=dialect,
         )
         == key
     )
@@ -480,6 +506,8 @@ class PendingTurn:
     tools: list[Tool]
     prefix_node_ids: list[int]
     path_len: int
+    dialect: DialectName | None = None
+    """The wire format of the request, whose replay view matches its prompt."""
 
     @property
     def tail_start(self) -> int:
@@ -558,13 +586,14 @@ class PendingTurn:
     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)
+        _head_index(self.trace, self.dialect)
         for message in self.tail:
-            existing = _matching_node(self.trace, parent, message, tools=self.tools)
+            existing = _matching_node(
+                self.trace, parent, message, tools=self.tools, dialect=self.dialect
+            )
             if existing is not None:
                 parent = existing
                 continue
-            previous = parent
             self.trace.nodes.append(
                 MessageNode(
                     parent=parent,
@@ -573,7 +602,7 @@ class PendingTurn:
                 )
             )
             parent = len(self.trace.nodes) - 1
-            index[_node_key(self.trace, previous, message, self.tools)] = parent
+            _index_node(self.trace, parent)
         if self.tools:
             self.trace.tools = list(
                 {
@@ -588,9 +617,11 @@ def prepare_turn(
     trace: Trace,
     prompt: list[Message],
     tools: list[Tool] | None = None,
+    dialect: DialectName | None = None,
 ) -> PendingTurn:
-    """Resolve a physical message-and-tools prefix without mutating the trace."""
-    idx = _head_index(trace)
+    """Resolve a physical message-and-tools prefix without mutating the trace. `dialect`
+    is the request's wire format, whose replay view matches the prompt to stored nodes."""
+    idx = _head_index(trace, dialect)
     tools = list(tools or [])
     tools_hash = _tools_hash(tools)
     parent: int | None = None
@@ -614,7 +645,7 @@ def prepare_turn(
             if len(children) == 1 and trace.nodes[children[0]].message == msg:
                 existing = children[0]
         if existing is None:
-            message_key = _message_key(trace, msg)
+            message_key = _message_key(trace, msg, dialect)
             existing = idx.get(
                 (parent, tools_hash if parent is None else None, message_key)
             )
@@ -629,6 +660,7 @@ def prepare_turn(
         tools=tools,
         prefix_node_ids=prefix_node_ids,
         path_len=path_len,
+        dialect=dialect,
     )
 
 
@@ -801,7 +833,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
     )
     renderer_spans = tokens.message_spans if tokens else None
     renderer_is_content = tokens.is_content if tokens else None
-    idx = _head_index(trace)
+    _head_index(trace, turn.dialect)
 
     prefix = turn.prefix_node_ids
     path_len = turn.path_len
@@ -886,6 +918,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
                 renderer_path_len,
                 next_renderer_start,
                 tools=turn.tools,
+                dialect=turn.dialect,
             )
             if existing is not None:
                 end += len(trace.nodes[existing].token_ids)
@@ -900,6 +933,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
                 node_tokens if tokens is not None else None,
                 renderer_node_tokens if tokens is not None else None,
                 tools=turn.tools,
+                dialect=turn.dialect,
             )
         if existing is None:
             break
@@ -914,7 +948,6 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
     # Track new nodes separately so routed-expert attribution needs only node ids, not this path.
     new_node_ids: list[int] = []
     for i, msg in enumerate(prompt[num_reused:], start=num_reused):
-        key = _node_key(trace, 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
@@ -938,7 +971,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
             )
         )
         parent = len(trace.nodes) - 1
-        idx[key] = parent
+        _index_node(trace, parent)
         new_node_ids.append(parent)
         cursor = end
         renderer_cursor = renderer_end
@@ -967,7 +1000,7 @@ def _commit_turn(turn: PendingTurn, response: Response) -> int:
         )
     )
     assistant_id = len(trace.nodes) - 1
-    idx[_node_key(trace, parent, response.message, turn.tools)] = assistant_id
+    _index_node(trace, assistant_id)
     new_node_ids.append(assistant_id)
 
     # Attribute this turn's expert-routing array onto the nodes created this turn (new input

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/harness.py

@@ -18,7 +18,7 @@ from verifiers.v1.errors import (
 )
 from verifiers.v1.runtimes import ProgramResult, Runtime
 from verifiers.v1.task import TaskData
-from verifiers.v1.types import Message, Messages
+from verifiers.v1.types import DialectName, Message, Messages
 from verifiers.v1.utils.decorators import (
     discover_decorated,
     invoke_all,
@@ -67,8 +67,9 @@ class Harness(ABC, Generic[ConfigT]):
     def __init__(self, config: ConfigT) -> None:
         self.config = config
 
-    def replay_view(self, message: Message) -> Message:
-        """`message` as this harness re-sends it on later requests. Override only for
+    def replay_view(self, message: Message, dialect: DialectName | None) -> Message:
+        """`message` as this harness re-sends it on later requests over `dialect` (None
+        before the first intercepted request). Override only for
         deterministic cosmetic rewrites (e.g. dropped whitespace-only text), never for
         content changes, so a replayed turn matches the turn it came from in the trace
         graph instead of forking it."""

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/harnesses/claude_code/harness.py

@@ -11,7 +11,7 @@ from verifiers.v1.harnesses.utils.replay import drop_blank_text
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
-from verifiers.v1.types import Message
+from verifiers.v1.types import DialectName, Message
 
 CLAUDE_ACP_DIR = "/var/tmp/vf-claude-agent-acp-{version}-{acp_version}"
 PACKAGES_DIR = f"{CLAUDE_ACP_DIR}/packages"
@@ -44,7 +44,7 @@ class ClaudeCodeHarness(ACPHarness[ClaudeCodeHarnessConfig]):
 
     # Claude Code drops whitespace-only text blocks on replay. Closed source: observed
     # with 2.1.278, recheck on version bumps.
-    def replay_view(self, message: Message) -> Message:
+    def replay_view(self, message: Message, dialect: DialectName | None) -> Message:
         return drop_blank_text(message)
 
     async def setup(self, runtime: Runtime) -> None:

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/harnesses/hermes_agent/harness.py

@@ -12,7 +12,7 @@ from verifiers.v1.runtimes import Runtime
 from verifiers.v1.runtimes.base import _ENSURE_UV
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
-from verifiers.v1.types import Message
+from verifiers.v1.types import DialectName, Message
 
 PROGRAM_SOURCE = (Path(__file__).resolve().parent / "program.py").read_text()
 HERMES_DIR = "/var/tmp/vf-hermes-agent-{version}"
@@ -43,7 +43,7 @@ class HermesAgentHarness(ACPHarness[HermesAgentHarnessConfig]):
     # replay. Recheck on version bumps:
     # https://github.com/NousResearch/hermes-agent/blob/v2026.9.14/agent/chat_completion_helpers.py#L1444
     # https://github.com/NousResearch/hermes-agent/blob/v2026.9.14/agent/message_sanitization.py#L545
-    def replay_view(self, message: Message) -> Message:
+    def replay_view(self, message: Message, dialect: DialectName | None) -> Message:
         return strip_text(message)
 
     async def setup(self, runtime: Runtime) -> None:

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/harnesses/kimi_code/harness.py

@@ -2,7 +2,6 @@
 
 import logging
 import tomllib
-from typing import Literal
 
 import tomli_w
 
@@ -11,9 +10,11 @@ from verifiers.v1.clients import ModelContext
 from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
 from verifiers.v1.harnesses.node import NODE_BIN_DIR, ensure_node
 from verifiers.v1.harnesses.utils.install import ensure_installed, remove_dir
+from verifiers.v1.harnesses.utils.replay import drop_blank_text
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
+from verifiers.v1.types import DialectName, Message
 
 logger = logging.getLogger(__name__)
 
@@ -39,9 +40,7 @@ fi
 class KimiCodeHarnessConfig(HarnessConfig):
     version: PinnedVersion = "2.0.2"
     """Kimi Code release to install, pinned for reproducibility."""
-    transport: Literal["chat_completions", "responses", "anthropic_messages"] = (
-        "chat_completions"
-    )
+    transport: DialectName = "chat_completions"
     """Model API transport."""
 
 
@@ -51,6 +50,12 @@ class KimiCodeHarness(ACPHarness[KimiCodeHarnessConfig]):
     SUPPORTS_SKILLS = True
     SUPPORTS_TOOL_INTERCEPTION = True
 
+    # Kimi Code drops whitespace-only assistant text when it stores a step, so every
+    # transport replays it without. Recheck on version bumps:
+    # https://github.com/MoonshotAI/kimi-code/blob/@moonshot-ai/kimi-code@2.0.2/packages/agent-core-v2/src/agent/loop/loopService.ts#L1723
+    def replay_view(self, message: Message, dialect: DialectName | None) -> Message:
+        return drop_blank_text(message)
+
     async def setup(self, runtime: Runtime) -> None:
         await ensure_node(runtime)
         logger.info(

{verifiers-0.4.1.dev35 → verifiers-0.4.1.dev37}/verifiers/v1/harnesses/opencode/harness.py

@@ -2,16 +2,17 @@
 
 import json
 from pathlib import Path
-from typing import Literal
 
 from verifiers.v1.acp import ACPConfig, ACPHarness
 from verifiers.v1.clients import ModelContext
 from verifiers.v1.configs.harness import HarnessConfig, PinnedVersion
 from verifiers.v1.harnesses.node import ensure_node
 from verifiers.v1.harnesses.utils.install import ensure_installed, remove_dir
+from verifiers.v1.harnesses.utils.replay import drop_blank_text
 from verifiers.v1.runtimes import Runtime
 from verifiers.v1.task import TaskData
 from verifiers.v1.trace import Trace
+from verifiers.v1.types import DialectName, Message
 
 OPENCODE_DIR = "/var/tmp/vf-opencode"
 STATE_ROOT = "/tmp/vf-opencode-runs"
@@ -29,9 +30,7 @@ npm install --prefix "$VF_OPENCODE_DIR" --no-audit --no-fund --omit=dev \
 class OpenCodeHarnessConfig(HarnessConfig):
     version: PinnedVersion = "2.0.26"
     """OpenCode 2 release to install, pinned for reproducibility."""
-    transport: Literal["chat_completions", "responses", "anthropic_messages"] = (
-        "chat_completions"
-    )
+    transport: DialectName = "chat_completions"
     """Model API transport."""
     disabled_tools: list[str] | None = None
     """OpenCode permission actions to deny, such as shell, read, or edit."""
@@ -42,6 +41,14 @@ class OpenCodeHarness(ACPHarness[OpenCodeHarnessConfig]):
     SUPPORTS_MCP = True
     SUPPORTS_SKILLS = True
 
+    # OpenCode drops whitespace-only assistant text on replay over Anthropic messages.
+    # Recheck on version bumps:
+    # https://github.com/anomalyco/opencode/blob/v2.0.26/packages/ai/src/protocols/anthropic-messages.ts#L929
+    def replay_view(self, message: Message, dialect: DialectName | None) -> Message:
+        if dialect == "anthropic_messages":
+            return drop_blank_text(message)
+        return message
+
     async def setup(self, runtime: Runtime) -> None:
         await ensure_node(runtime)
         directory = f"{OPENCODE_DIR}/{self.config.version}"