verifiers 0.3.2.dev124__tar.gz → 0.3.2.dev126__tar.gz

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/PKG-INFO

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

@@ -373,14 +373,21 @@ async def test_acp_resume_with_tool(run_v1, harness, harness_runtime, tmp_path):
     # Kimi Code is broken upstream: its Responses adapter drops message `phase` on replay.
     if harness.id != "kimi-code":
         assert trace.num_branches == 1
-    # Native MCP tools need not appear in the intercepted model request that
-    # populates trace.tools; the ACP transcript is the source of truth for use.
     assert "tool" in segments[1]["roles"]
     assert segments[1]["tool_outputs"]
     if harness.id == "pi":
         recall = next(tool for tool in trace.tools if tool.name == "resume_recall")
         assert recall.parameters["properties"]["codeword"]["type"] == "string"
         assert "codeword" in recall.parameters["required"]
+    if harness.id == "codex":
+        recall = next(tool for tool in trace.tools if tool.name.endswith("recall"))
+        assert recall.namespace
+        assert "codeword" in recall.parameters["properties"]
+        assert any(
+            call.namespace == recall.namespace and call.name == recall.name
+            for message in trace.assistant_messages
+            for call in message.tool_calls or []
+        )
     if harness.id == "rlm":
         assert "turns_since_last_compaction" in trace.metrics
         assert all(call.acp is not None for call in trace.calls)

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/tests/v1/test_graph.py

@@ -1,6 +1,7 @@
 import base64
 
 import numpy as np
+import pytest
 
 import verifiers.v1 as vf
 from verifiers.v1 import graph
@@ -203,6 +204,31 @@ def test_tool_call_hash_matches_v0_content_and_arguments_normalization():
 
     assert graph.message_hash(left) == graph.message_hash(right)
 
+    # Identical call IDs and short names can occur in different agent branches.
+    trace = vf.Trace(
+        agent=vf.AgentInfo(config=vf.AgentConfig()),
+        task=vf.TraceTask(type="Task", data=vf.TaskData(idx=0, prompt="lookup")),
+    )
+    user = vf.UserMessage(content="lookup")
+    calls = [
+        vf.AssistantMessage(
+            tool_calls=[
+                vf.ToolCall(id="call_0", name="lookup", namespace=ns, arguments="{}")
+            ]
+        )
+        for ns in (None, "alpha", "beta")
+    ]
+    node_ids = [
+        graph.prepare_turn(trace, [user]).commit(_response(message))
+        for message in calls
+    ]
+    for message, node_id in zip(calls, node_ids, strict=True):
+        turn = graph.prepare_turn(
+            trace,
+            [user, message, vf.ToolMessage(content="result", tool_call_id="call_0")],
+        )
+        assert turn.prefix_node_ids == [0, node_id]
+
 
 def test_reasoning_content_participates_in_graph_prefix_matching():
     task = vf.TaskData(idx=0, prompt="use a tool")
@@ -243,7 +269,8 @@ def test_reasoning_content_participates_in_graph_prefix_matching():
     assert len(tool_call_nodes) == 2
 
 
-def test_parallel_commits_reconcile_shared_prompt_prefix():
+@pytest.mark.parametrize("same_tools", [False, True])
+def test_parallel_commits_reconcile_shared_prompt_prefix(same_tools):
     """Two requests prepared from the same graph snapshot share any common prompt prefix that
     the first response commits while the second is in flight. A later turn must keep following
     its original child path rather than re-rooting through the sibling and stranding an orphan."""
@@ -257,10 +284,13 @@ def test_parallel_commits_reconcile_shared_prompt_prefix():
     assistant_a = vf.AssistantMessage(content="A1")
 
     # Both model requests leave before either response has committed its prompt.
-    pending_a = graph.prepare_turn(trace, [system, user_a])
-    pending_b = graph.prepare_turn(trace, [system, user_b])
+    tool_a = vf.Tool(name="echo", namespace="a")
+    tool_b = vf.Tool(name="echo", namespace="a" if same_tools else "b")
+    pending_a = graph.prepare_turn(trace, [system, user_a], [tool_a])
+    pending_b = graph.prepare_turn(trace, [system, user_b], [tool_b])
     assistant_a_id = pending_a.commit(_response(assistant_a))
     pending_b.commit(_response(vf.AssistantMessage(content="B1")))
+    assert trace.tools == ([tool_a] if same_tools else [tool_a, tool_b])
 
     graph.prepare_turn(
         trace,
@@ -270,16 +300,23 @@ def test_parallel_commits_reconcile_shared_prompt_prefix():
             assistant_a,
             vf.ToolMessage(content="tool A", tool_call_id="call_a"),
         ],
+        [tool_a],
     ).commit(_response(vf.AssistantMessage(content="A2")))
 
     roots = [node for node in trace.nodes if node.parent is None]
     identities = [
-        (node.parent, graph.message_hash(node.message)) for node in trace.nodes
+        (
+            node.parent,
+            tuple(tool.namespace for tool in node.tools),
+            graph.message_hash(node.message),
+        )
+        for node in trace.nodes
     ]
-    assert len(roots) == 1
+    assert len(roots) == (1 if same_tools else 2)
     assert len(identities) == len(set(identities))
     assert trace.num_branches == 2
     assert assistant_a_id not in graph.leaves(trace)
+    assert [branch.tools for branch in trace.branches] == [[tool_b], [tool_a]]
 
 
 def test_parallel_commit_reconciles_only_token_identical_prefixes():

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/tests/v1/test_trace.py

@@ -11,7 +11,9 @@ import pytest
 import verifiers.v1 as vf
 from verifiers.v1.agent import Interaction
 from verifiers.v1.cli.output import write_episode
-from verifiers.v1.graph import MessageNode
+from verifiers.v1.dialects.chat import ChatDialect
+from verifiers.v1.dialects.responses import ResponsesDialect, fold_assistant
+from verifiers.v1.graph import MessageNode, prepare_turn
 from verifiers.v1.harnesses.rlm.harness import (
     RLM_SESSION_METADATA_KEY,
     RLMHarness,
@@ -174,16 +176,71 @@ def test_custom_task_state_round_trip(tmp_path):
     assert tr.state.artifacts["/artifact.bin"] == b"\xff\x00\xfe"
 
 
-def test_wire_trace_round_trip():
+@pytest.mark.parametrize("history_type", ["additional_tools", "tool_search_output"])
+def test_wire_trace_round_trip(history_type):
+    mcp = {
+        "type": "mcp",
+        "server_label": "alpha",
+        "server_url": "https://example.invalid/mcp",
+        "authorization": "trace-test-oauth-token",
+        "headers": {"Authorization": "Bearer trace-test-header-token"},
+        "Authorization": "trace-test-case-oauth-token",
+        "Headers": {"X-Api-Key": "trace-test-case-header-token"},
+    }
+    function = {
+        "type": "function",
+        "name": "echo",
+        "description": "Echo the supplied text.",
+        "parameters": {"type": "object", "properties": {"text": {"type": "string"}}},
+        "strict": False,
+    }
+    stale = function | {"parameters": {"type": "object"}, "strict": True}
+    request = ResponsesDialect().parse_request(
+        {
+            "input": [
+                {
+                    "type": history_type,
+                    "call_id": "search",
+                    "tools": [
+                        stale,
+                        {"type": "namespace", "name": "mcp__world", "tools": [stale]},
+                    ],
+                }
+            ],
+            "tools": [
+                function,
+                {"type": "namespace", "name": "mcp__world", "tools": [function]},
+                {"type": "namespace", "name": "mcp__other", "tools": [function]},
+                {"type": "custom", "name": "patch", "format": {"type": "text"}},
+                {"type": "web_search", "search_context_size": "low"},
+                mcp,
+                mcp | {"server_label": "beta"},
+            ],
+        }
+    )
+    assert request.tools is not None and len(request.tools) == 7
+    assert all(tool.parameters == function["parameters"] for tool in request.tools[:3])
+    assert all(tool.strict is False for tool in request.tools[:3])
+    assistant = fold_assistant(
+        [
+            {
+                "type": "function_call",
+                "call_id": "call_0",
+                "name": "echo",
+                "namespace": "mcp__world",
+                "arguments": '{"text":"hello"}',
+            }
+        ]
+    )
     # Two leaves off one root → 2 branches (a compaction-shaped trace), so the round-trip has to
     # carry node `parent` links for `num_branches` to survive.
     tr = vf.Trace[MyTask, vf.State](
         agent=vf.AgentInfo(config=vf.AgentConfig()),
         task=vf.TraceTask(type="MyTask", data=MyTask(idx=0, prompt="q", answer="a")),
-        tools=[vf.Tool(name="echo", description="", parameters={"type": "object"})],
+        tools=request.tools,
         nodes=[
             MessageNode(parent=None, message=UserMessage(content="q"), sampled=False),
-            MessageNode(parent=0, message=AssistantMessage(content="a1"), sampled=True),
+            MessageNode(parent=0, message=assistant, sampled=True),
             MessageNode(parent=0, message=AssistantMessage(content="a2"), sampled=True),
         ],
     )
@@ -193,9 +250,26 @@ def test_wire_trace_round_trip():
     tr.info = {"build": "ok"}
     tr.root_reply = "root answer"
     tr.stop("done")
+    prepare_turn(tr, [], request.tools).commit_prompt()
 
     # the dump is plain pydantic — derived values are properties, so they're not serialized
     data = json.loads(tr.model_dump_json(exclude_none=True))
+    assert "trace-test-" not in json.dumps(data)
+    assert mcp["authorization"] == "trace-test-oauth-token"
+    assert mcp["headers"] == {"Authorization": "Bearer trace-test-header-token"}
+    assert mcp["Authorization"] == "trace-test-case-oauth-token"
+    assert mcp["Headers"] == {"X-Api-Key": "trace-test-case-header-token"}
+    chat_request = ChatDialect().parse_request(
+        {"tools": [mcp, mcp | {"server_label": "beta"}]}
+    )
+    chat_trace = tr.model_copy(update={"tools": []})
+    prepare_turn(chat_trace, [], chat_request.tools).commit_prompt()
+    assert [tool.name for tool in chat_trace.tools] == ["alpha", "beta"]
+    assert "trace-test-" not in chat_trace.model_dump_json()
+    assert (
+        vf.WireTrace.model_validate_json(chat_trace.model_dump_json()).tools
+        == chat_request.tools
+    )
     assert "reward" not in data and "is_truncated" not in data
     # exclude_none drops None FIELDS, not None dict values — unscored seeds survive
     assert data["rewards"]["solved"] is None and data["metrics"]["acc"] is None
@@ -214,6 +288,19 @@ def test_wire_trace_round_trip():
     assert (
         rt.tools == tr.tools
     )  # the advertised tools persist (tool-use SFT reads them)
+    assert [tool.namespace for tool in rt.tools[:3]] == [
+        None,
+        "mcp__world",
+        "mcp__other",
+    ]
+    assert all(tool.parameters == function["parameters"] for tool in rt.tools[:3])
+    assert all(tool.strict is False for tool in rt.tools[:3])
+    assert rt.tools[3].type == "custom"
+    assert rt.tools[3].model_extra == {"format": {"type": "text"}}
+    assert rt.tools[4].type == "web_search"
+    assert rt.tools[4].model_extra == {"search_context_size": "low"}
+    assert [tool.name for tool in rt.tools[5:]] == ["alpha", "beta"]
+    assert rt.nodes[1].message.tool_calls[0].namespace == "mcp__world"
     assert rt.task.data.model_extra == {
         "answer": "a"
     }  # taskset extras preserved on WireTaskData

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/verifiers/v1/acp/__init__.py

@@ -85,6 +85,13 @@ class ACPHarness(Harness[ConfigT]):
             )
             trace.add_semantic_edges(edge_set)
 
+    async def gate_tools(
+        self, config: ACPConfig, runtime: Runtime, url: str, secret: str
+    ) -> None:
+        """Configure the agent to ask before every tool call, so each request reaches the
+        runner's gate (`/tool` at `url`, keyed by `secret`). A harness that advertises
+        `SUPPORTS_TOOL_INTERCEPTION` implements this with the agent's own config."""
+
     @abstractmethod
     async def prepare_acp(
         self,
@@ -116,6 +123,8 @@ class ACPHarness(Harness[ConfigT]):
         config = await self.prepare_acp(
             ctx, trace, runtime, endpoint, secret, mcp_urls, data
         )
+        if tool_interception_url is not None:
+            await self.gate_tools(config, runtime, tool_interception_url, secret)
         return ACPHarnessSession(
             self,
             ctx,
@@ -268,6 +277,12 @@ class ACPHarnessSession(HarnessSession):
             "system_prompt": self.config.system_prompt or "",
             "session_meta": self.config.session_meta or {},
             "client_capabilities": self.config.client_capabilities or {},
+            "tool_interception": {
+                "url": self.tool_interception_url,
+                "secret": self.secret,
+            }
+            if self.tool_interception_url
+            else None,
         }
         async with self._lock:
             if self._closed:

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/verifiers/v1/acp/runner.py

@@ -1,6 +1,6 @@
 # /// script
 # requires-python = ">=3.10,<3.15"
-# dependencies = ["agent-client-protocol==0.12.1"]
+# dependencies = ["agent-client-protocol==0.12.1", "httpx"]
 # ///
 """Run harness segments through an ACP agent."""
 
@@ -14,6 +14,7 @@ from contextlib import AsyncExitStack, suppress
 from dataclasses import asdict, dataclass
 from typing import Any
 
+import httpx
 from acp import (
     PROTOCOL_VERSION,
     Client,
@@ -45,8 +46,42 @@ class ACPTurn:
     update_metadata: list[dict[str, Any]]
 
 
+class ToolGate:
+    """The rollout's `/tool` gate, asked before every tool call the agent wants to run."""
+
+    def __init__(self, url: str, secret: str) -> None:
+        self.url = url
+        self.client = httpx.AsyncClient(
+            headers={"Authorization": f"Bearer {secret}"},
+            timeout=httpx.Timeout(120, connect=5),
+        )
+
+    async def decision(self, tool_call_id: str, arguments: Any) -> str:
+        try:
+            # pi-acp wraps extension confirmations in a separate UI permission call.
+            if (
+                tool_call_id.startswith("pi-ui-")
+                and isinstance(arguments, dict)
+                and arguments.get("method") == "confirm"
+            ):
+                tool_call_id, arguments = (
+                    arguments["title"],
+                    json.loads(arguments["message"]),
+                )
+            response = await self.client.post(
+                self.url, json={"tool_call_id": tool_call_id, "arguments": arguments}
+            )
+            response.raise_for_status()
+            return response.json()["action"]
+        except Exception as error:  # noqa: BLE001 - an unreachable gate lets nothing run
+            print(f"tool gate denied {tool_call_id}: {error}", file=sys.stderr)
+            return "deny"
+
+
 class VerifiersACPClient(Client):
     def __init__(self) -> None:
+        self.gate: ToolGate | None = None
+        self.prompt_task: asyncio.Task | None = None
         self.visible_reply = ""
         self.message_id: str | None = None
         self.stop_reason: str | None = None
@@ -90,9 +125,23 @@ class VerifiersACPClient(Client):
         options: list[PermissionOption],
         **kwargs: Any,
     ) -> RequestPermissionResponse:
+        """Ask the rollout before execution: deny rejects one call; stop cancels the turn."""
+        kinds = ("allow_once", "allow_always")
+        if self.gate is not None:
+            decision = await self.gate.decision(
+                tool_call.tool_call_id, tool_call.raw_input
+            )
+            if decision == "stop":
+                self.stop_reason = "cancelled"
+                if self.prompt_task is not None:
+                    self.prompt_task.cancel()
+                return RequestPermissionResponse(
+                    outcome=DeniedOutcome(outcome="cancelled")
+                )
+            if decision != "allow":
+                kinds = ("reject_once", "reject_always")
         option = next(
-            (item for item in options if item.kind in ("allow_once", "allow_always")),
-            None,
+            (item for kind in kinds for item in options if item.kind == kind), None
         )
         outcome = (
             AllowedOutcome(outcome="selected", option_id=option.option_id)
@@ -165,12 +214,21 @@ async def prompt(
     if not blocks:
         raise ValueError("ACP prompt has no content")
     try:
-        response = await connection.prompt(session_id=session_id, prompt=blocks)
+        client.prompt_task = asyncio.create_task(
+            connection.prompt(session_id=session_id, prompt=blocks)
+        )
+        response = await client.prompt_task
         client.stop_reason = response.stop_reason
         client.response_metadata = dict(response.field_meta or {})
+    except asyncio.CancelledError:
+        if client.stop_reason != "cancelled":
+            raise
+        await connection.cancel(session_id=session_id)
     except RequestError as error:
         detail = error.data.get("details") if isinstance(error.data, dict) else None
         raise RuntimeError(detail or str(error)) from error
+    finally:
+        client.prompt_task = None
     return client.turn_result()
 
 
@@ -222,6 +280,9 @@ class ACPSession:
         self.is_new = True
 
     async def run(self, config: dict) -> ACPTurn:
+        gate = config.get("tool_interception")
+        if gate and self.client.gate is None:
+            self.client.gate = ToolGate(gate["url"], gate["secret"])
         if self.connection is None:
             await self.start(config)
         assert self.session_id is not None
@@ -253,6 +314,9 @@ class ACPSession:
             try:
                 await self.stack.aclose()
             finally:
+                if self.client.gate is not None:
+                    await self.client.gate.client.aclose()
+                    self.client.gate = None
                 self._reset()
         return response_metadata
 

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/verifiers/v1/clients/train.py

@@ -38,6 +38,10 @@ T = TypeVar("T")
 
 
 def tool_to_wire(tool: Tool) -> dict:
+    if tool.type != "function" or tool.namespace:
+        raise NotImplementedError(
+            "The renderer client only supports unnamespaced function tools."
+        )
     function: dict = {
         "name": tool.name,
         "description": tool.description,
@@ -61,6 +65,7 @@ def serialize_completion(response: Response, model: str) -> dict:
                 "type": c.type,
                 c.type: {
                     "name": c.name,
+                    **({"namespace": c.namespace} if c.namespace else {}),
                     "input" if c.type == "custom" else "arguments": c.arguments,
                 },
             }

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/verifiers/v1/dialects/anthropic.py

@@ -52,7 +52,8 @@ STOP_REASONS: dict[str, FinishReason] = {
     "stop_sequence": "stop",
 }
 # Claude may reorder mixed thinking block types between a response and its replay.
-THINKING = ("redacted_thinking", "thinking")
+# Native tool events share the final rank, preserving their relative order.
+THINKING_ORDER = {"redacted_thinking": 0, "thinking": 1}
 # These versioned tool families return calls to the harness; every other typed tool may execute
 # at the provider. Anchoring the pattern keeps new versions client-side without treating an
 # arbitrary dated provider tool as safe.
@@ -259,8 +260,10 @@ def parse_messages(body: dict) -> Messages:
                 if isinstance(content, str)
                 else content or []
             )
-            state = [block for block in blocks if block["type"] in THINKING]
-            state.sort(key=lambda block: THINKING.index(block["type"]))
+            state = [
+                block for block in blocks if block["type"] not in ("text", "tool_use")
+            ]
+            state.sort(key=lambda block: THINKING_ORDER.get(block["type"], 2))
             text = "".join(b.get("text", "") for b in blocks if b.get("type") == "text")
             reasoning = "".join(
                 b.get("thinking", "") for b in blocks if b.get("type") == "thinking"
@@ -269,6 +272,7 @@ def parse_messages(body: dict) -> Messages:
                 ToolCall(
                     id=b.get("id", ""),
                     name=b.get("name", ""),
+                    namespace=b.get("toolset_name"),
                     arguments=json.dumps(b.get("input") or {}),
                 )
                 for b in blocks
@@ -311,8 +315,9 @@ def response_from_wire(message: AnthropicMessage) -> Response:
     reasoning: list[str] = []
     calls: list[ToolCall] = []
     for block in message.content:
-        if block.type in THINKING:
-            state.append(block.model_dump())
+        if block.type not in ("text", "tool_use"):
+            # SDK-inserted defaults are absent when the native response is replayed.
+            state.append(block.model_dump(exclude_unset=True))
         if block.type == "text":
             content.append(block.text)
         elif block.type == "thinking":
@@ -322,10 +327,11 @@ def response_from_wire(message: AnthropicMessage) -> Response:
                 ToolCall(
                     id=block.id,
                     name=block.name,
+                    namespace=block.toolset_name,
                     arguments=json.dumps(block.input or {}),
                 )
             )
-    state.sort(key=lambda block: THINKING.index(block["type"]))
+    state.sort(key=lambda block: THINKING_ORDER.get(block["type"], 2))
     finish = STOP_REASONS.get(message.stop_reason or "")
     provider_usage = message.usage
     output_details = provider_usage.model_dump().get("output_tokens_details")
@@ -580,14 +586,23 @@ class AnthropicDialect(Dialect[AnthropicMessage]):
         }
 
     def parse_request(self, body: RawRequest) -> Request:
+        native_tools = body.get("tools") or []
+        if not isinstance(native_tools, list) or any(
+            not isinstance(tool, dict) for tool in native_tools
+        ):
+            raise ValueError("tools must be an array of objects")
         tools = [
-            Tool(
-                name=t["name"],
-                description=t.get("description", ""),
-                parameters=t.get("input_schema", {}),
+            Tool.model_validate(
+                {k: v for k, v in t.items() if k != "input_schema"}
+                | {
+                    "name": t.get("name") or t.get("mcp_server_name") or t.get("type"),
+                    "type": "function"
+                    if t.get("type") in (None, "custom")
+                    else t["type"],
+                    "parameters": t.get("input_schema") or {},
+                }
             )
-            for t in body.get("tools") or []
-            if "input_schema" in t  # skip server tools (web_search etc.)
+            for t in native_tools
         ] or None
         return Request(messages=parse_messages(body), tools=tools)
 

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/verifiers/v1/dialects/chat.py

@@ -122,6 +122,7 @@ def parse_message(raw: dict) -> Message:
                     id=call["id"],
                     type=kind,
                     name=native["name"],
+                    namespace=native.get("namespace"),
                     arguments=native["input" if kind == "custom" else "arguments"],
                 )
             )
@@ -135,21 +136,26 @@ def parse_message(raw: dict) -> Message:
 
 
 def parse_tools(raw: list[dict] | None) -> list[Tool] | None:
-    # `or None` so a tools array with no function entries (e.g. only `custom`/built-in
-    # tools) parses to None, not [] — the same contract as the anthropic/responses
-    # dialects, and what keeps an empty parse from clearing `Trace.tools`.
-    if not raw:
-        return None
-    return [
-        Tool(
-            name=t["function"]["name"],
-            description=t["function"].get("description", ""),
-            parameters=t["function"].get("parameters", {}),
-            strict=t["function"].get("strict"),
+    tools = []
+    for declaration in raw or []:
+        kind = declaration.get("type", "function")
+        tool = declaration.get(kind, declaration)
+        if kind == "mcp":
+            tool = {
+                key: value
+                for key, value in tool.items()
+                if key.lower() not in ("authorization", "headers")
+            }
+        tools.append(
+            Tool.model_validate(
+                tool
+                | {
+                    "type": kind,
+                    "name": tool.get("name") or tool.get("server_label") or kind,
+                }
+            )
         )
-        for t in raw
-        if t.get("type", "function") == "function"
-    ] or None
+    return tools or None
 
 
 # --- vf -> chat wire ----------------------------------------------------------
@@ -184,6 +190,7 @@ def message_to_wire(message: Message) -> dict:
                     "type": call.type,
                     call.type: {
                         "name": call.name,
+                        **({"namespace": call.namespace} if call.namespace else {}),
                         "input"
                         if call.type == "custom"
                         else "arguments": call.arguments,
@@ -302,8 +309,9 @@ class ChatStreamParser(StreamParser):
                 slot["type"] = kind
                 native = slot.setdefault(kind, {"name": ""})
                 delta_native = tool_call.get(kind) or {}
-                if delta_native.get("name"):
-                    native["name"] = delta_native["name"]
+                for field in ("name", "namespace"):
+                    if delta_native.get(field):
+                        native[field] = delta_native[field]
                 input_field = "input" if kind == "custom" else "arguments"
                 self.tool_inputs.setdefault(index, []).append(
                     delta_native.get(input_field) or ""

{verifiers-0.3.2.dev124 → verifiers-0.3.2.dev126}/verifiers/v1/dialects/responses.py

@@ -303,6 +303,7 @@ def fold_assistant(items: list[dict] | None) -> AssistantMessage:
                     id=item.get("call_id", ""),
                     type="custom" if kind == "custom_tool_call" else "function",
                     name=item.get("name", ""),
+                    namespace=item.get("namespace"),
                     arguments=item.get("arguments", item.get("input", "")),
                 )
             )
@@ -612,17 +613,38 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
                 prompt.append(UserMessage(content=parse_content(item.get("content"))))
         if run:
             prompt.append(fold_assistant(run))
-        tools = [
-            Tool(
-                name=t["name"],
-                description=t.get("description") or "",
-                parameters=t.get("parameters") or {},
-                strict=t.get("strict"),
-            )
-            for t in body.get("tools") or []
-            if t.get("type") == "function"
-        ] or None
-        return Request(messages=prompt, tools=tools)
+        tools = []
+        declarations = []
+        for item in items:
+            if item.get("type") in ("additional_tools", "tool_search_output"):
+                declarations.extend(item.get("tools") or [])
+        # Current declarations take precedence over definitions replayed in history.
+        declarations.extend(body.get("tools") or [])
+        for group in declarations:
+            namespace = group["name"] if group.get("type") == "namespace" else None
+            for tool in group["tools"] if namespace else [group]:
+                if tool.get("type") == "mcp":
+                    # Connection credentials belong in the native request, not the trace.
+                    tool = {
+                        key: value
+                        for key, value in tool.items()
+                        if key.lower() not in ("authorization", "headers")
+                    }
+                tools.append(
+                    Tool.model_validate(
+                        tool
+                        | {
+                            "name": tool.get("name")
+                            or tool.get("server_label")
+                            or tool.get("type"),
+                            "namespace": namespace,
+                            "description": tool.get("description") or "",
+                            "parameters": tool.get("parameters") or {},
+                        }
+                    )
+                )
+        tools = list({(t.namespace, t.name, t.type): t for t in tools}.values())
+        return Request(messages=prompt, tools=tools or None)
 
     def parse_response(self, response: OpenAIResponse) -> Response:
         return response_from_wire(response)