verifiers 0.3.2.dev123__tar.gz → 0.3.2.dev125__tar.gz

{verifiers-0.3.2.dev123 → verifiers-0.3.2.dev125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev123
+Version: 0.3.2.dev125
 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.dev123 → verifiers-0.3.2.dev125}/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.dev123 → verifiers-0.3.2.dev125}/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.dev123 → verifiers-0.3.2.dev125}/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.dev123 → verifiers-0.3.2.dev125}/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.dev123 → verifiers-0.3.2.dev125}/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.dev123 → verifiers-0.3.2.dev125}/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.dev123 → verifiers-0.3.2.dev125}/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)
@@ -713,6 +735,7 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
         item = raw["output"][0]
         part = item["content"][0]
         common = {"output_index": 0, "item_id": item["id"], "content_index": 0}
+        logprobs = part.get("logprobs") or []
         head = {
             **raw,
             "status": "in_progress",
@@ -729,8 +752,15 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
                 "response.content_part.added",
                 {**common, "part": {**part, "text": ""}},
             ),
-            ("response.output_text.delta", {**common, "delta": part["text"]}),
-            ("response.output_text.done", {**common, "text": part["text"]}),
+            # `logprobs` is required on both text events; carry the part's own.
+            (
+                "response.output_text.delta",
+                {**common, "delta": part["text"], "logprobs": logprobs},
+            ),
+            (
+                "response.output_text.done",
+                {**common, "text": part["text"], "logprobs": logprobs},
+            ),
             ("response.content_part.done", {**common, "part": part}),
             ("response.output_item.done", {"output_index": 0, "item": item}),
             ("response.completed", {"response": raw}),

{verifiers-0.3.2.dev123 → verifiers-0.3.2.dev125}/verifiers/v1/graph.py

@@ -340,6 +340,7 @@ def message_hash(message: Message) -> str:
             add(tc.type)
             add(tc.id)
             add(tc.name)
+            add(tc.namespace or "")
             add(
                 tc.arguments
                 if tc.type == "custom"
@@ -547,7 +548,13 @@ class PendingTurn:
     def commit(self, response: Response) -> int:
         """Add this turn to the graph; returns the committed assistant node's id."""
         assistant_id = _commit_turn(self, response)
-        self.trace.tools = self.tools
+        if self.tools:
+            self.trace.tools = list(
+                {
+                    (tool.namespace, tool.name, tool.type): tool
+                    for tool in [*self.trace.tools, *self.tools]
+                }.values()
+            )
         self.trace.clear_preview(self)
         return assistant_id
 
@@ -574,7 +581,13 @@ class PendingTurn:
             )
             parent = len(self.trace.nodes) - 1
             index[_node_key(previous, message, self.tools)] = parent
-        self.trace.tools = self.tools
+        if self.tools:
+            self.trace.tools = list(
+                {
+                    (tool.namespace, tool.name, tool.type): tool
+                    for tool in [*self.trace.tools, *self.tools]
+                }.values()
+            )
         self.trace.clear_preview(self)
 
 

{verifiers-0.3.2.dev123 → verifiers-0.3.2.dev125}/verifiers/v1/tasksets/nemo_gym/response.py

@@ -70,6 +70,7 @@ def trace_to_nemo_response(
                     else "function_call",
                     "call_id": call.id,
                     "name": call.name,
+                    **({"namespace": call.namespace} if call.namespace else {}),
                     ("input" if call.type == "custom" else "arguments"): call.arguments,
                 }
                 for call in message.tool_calls or []

{verifiers-0.3.2.dev123 → verifiers-0.3.2.dev125}/verifiers/v1/trace.py

@@ -408,7 +408,7 @@ class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
     agent: AgentInfo[AgentConfigT]
     """The agent (harness x model x runtime) that produced this trace."""
     tools: list[Tool] = Field(default_factory=list)
-    """The tools advertised to the agent, automatically recorded from last intercepted turn."""
+    """Tools observed across requests; the latest definition wins for each identity."""
 
     nodes: list[MessageNode] = Field(default_factory=list)
     """The message graph, including physical and semantic parent links."""
@@ -709,7 +709,8 @@ class Trace(BaseModel, Generic[DataT, StateT, AgentConfigT]):
                 if message.content:
                     lines.append(message.content)
                 lines.extend(
-                    f"[tool_call {call.name}({call.arguments})]"
+                    f"[tool_call {call.namespace + '.' if call.namespace else ''}"
+                    f"{call.name}({call.arguments})]"
                     for call in message.tool_calls or []
                 )
             else:

{verifiers-0.3.2.dev123 → verifiers-0.3.2.dev125}/verifiers/v1/types.py

@@ -68,6 +68,8 @@ class ToolCall(BaseModel):
     id: str
     type: Literal["function", "custom"] = "function"
     name: str
+    namespace: str | None = None
+    """Provider namespace qualifying the tool name, when sent separately."""
     arguments: str
     """Raw function arguments or custom-tool input, exactly as the model emitted it."""
 
@@ -97,9 +99,14 @@ Messages = list[Message]
 
 
 class Tool(BaseModel):
+    # Native declarations carry format, discovery, and provider-specific settings.
+    model_config = ConfigDict(extra="allow")
+
+    type: str = "function"
     name: str
-    description: str
-    parameters: dict[str, Any]
+    namespace: str | None = None
+    description: str = ""
+    parameters: dict[str, Any] = Field(default_factory=dict)
     strict: bool | None = None