《AI Agent 高级编程》4.3 三框架同题对照：同评测集比分数与成本

# adapt_minagent.py
import json
from dataclasses import dataclass, field
from typing import Any, Literal

Role = Literal["system", "user", "assistant", "tool"]


@dataclass
class ToolCall:
    id: str
    name: str
    arguments: dict[str, Any]


@dataclass
class Message:
    role: Role
    content: str = ""
    tool_calls: list[ToolCall] = field(default_factory=list)
    tool_call_id: str | None = None


@dataclass
class ModelResponse:
    message: Message
    stop_reason: str = "end_turn"
    usage: dict[str, int] = field(default_factory=dict)


class FakeModel:
    def __init__(self, script):
        self.script = list(script)
        self.calls = []
        self.n = 0

    def complete(self, messages, tools):
        self.calls.append((list(messages), list(tools)))
        step = self.script[min(self.n, len(self.script) - 1)]
        self.n += 1
        if isinstance(step, str):
            return ModelResponse(Message("assistant", step))
        return ModelResponse(Message("assistant", tool_calls=step), stop_reason="tool_use")


class ToolRegistry:
    def __init__(self):
        self._tools = {}
        self.n_calls = 0

    def add(self, name, func):
        self._tools[name] = func

    def schemas(self):
        return [{"name": n} for n in self._tools]

    def call(self, tc):
        self.n_calls += 1
        try:
            return str(self._tools[tc.name](**tc.arguments))
        except Exception as e:
            return json.dumps({"error": f"{type(e).__name__}: {e}"}, ensure_ascii=False)


def run_task():
    reg = ToolRegistry()
    reg.add("search", lambda query: f"[hit] {query} => 本地知识库命中 3 条")
    model = FakeModel([
        [ToolCall("c1", "search", {"query": "smolagents"})],
        "结论：smolagents 用 CodeAgent 把动作写成代码。",
    ])
    messages = [Message("user", "查 smolagents 并给结论")]
    steps = 0
    for i in range(8):
        steps += 1
        resp = model.complete(messages, reg.schemas())
        messages.append(resp.message)
        if not resp.message.tool_calls:
            return {"output": resp.message.content, "steps": steps,
                    "tool_calls": reg.n_calls, "msgs": len(messages)}
        for tc in resp.message.tool_calls:
            messages.append(Message("tool", reg.call(tc), tool_call_id=tc.id))
    raise RuntimeError("未收敛")

# adapt_pydanticai.py
from pydantic_ai import Agent
from pydantic_ai.models.function import FunctionModel, AgentInfo
from pydantic_ai.messages import ModelResponse, TextPart, ToolCallPart

TOOL_CALLS = {"n": 0}


def script_fn(messages, info: AgentInfo):
    done = sum(1 for m in messages for p in getattr(m, "parts", [])
               if type(p).__name__ == "ToolReturnPart")
    if done == 0:
        return ModelResponse(parts=[ToolCallPart("search", {"query": "smolagents"})])
    return ModelResponse(parts=[TextPart("结论：smolagents 用 CodeAgent 把动作写成代码。")])


def run_task():
    agent = Agent(FunctionModel(script_fn), instructions="查资料再给结论")

    @agent.tool_plain
    def search(query: str) -> str:
        """检索本地知识库。"""
        TOOL_CALLS["n"] += 1
        return f"[hit] {query} => 本地知识库命中 3 条"

    r = agent.run_sync("查 smolagents 并给结论")
    msgs = r.all_messages()
    n_model_calls = sum(1 for m in msgs if type(m).__name__ == "ModelResponse")
    return {"output": r.output, "steps": n_model_calls,
            "tool_calls": TOOL_CALLS["n"], "msgs": len(msgs)}

# adapt_smolagents.py
from smolagents.models import Model, ChatMessage
from smolagents import CodeAgent, tool

SCRIPT = [
    'res = search("smolagents")\nprint(res)',
    'final_answer("结论：smolagents 用 CodeAgent 把动作写成代码。")',
]


class ScriptedModel(Model):
    def __init__(self, script):
        super().__init__(model_id="scripted-local")
        self.script = list(script)
        self.calls = []
        self.n = 0

    def generate(self, messages, stop_sequences=None, response_format=None,
                 tools_to_call_from=None, **kwargs):
        self.calls.append((len(messages), [t.name for t in (tools_to_call_from or [])]))
        code = self.script[min(self.n, len(self.script) - 1)]
        self.n += 1
        return ChatMessage(role="assistant", content=f"Thought: 第 {self.n} 步\n<code>\n{code}\n</code>")


def run_task():
    model = ScriptedModel(SCRIPT)
    calls = {"n": 0}

    @tool
    def search(query: str) -> str:
        """检索本地知识库。
        Args:
            query: 查询词。
        """
        calls["n"] += 1
        return f"[hit] {query} => 本地知识库命中 3 条"

    agent = CodeAgent(tools=[search], model=model, max_steps=5)
    out = agent.run("查 smolagents 并给结论")
    return {"output": out, "steps": len(model.calls),
            "tool_calls": calls["n"], "msgs": model.calls[-1][0]}

框架             步数    工具调用    消息数    有效行    总行
minagent        2       1      4     64    85
pydantic-ai     2       1      4     20    30
smolagents      2       1      5     28    42

# minagent：calls 是二元组，断言工具 schema 直达
assert len(model.calls[0][0]) == 2
assert [t["name"] for t in model.calls[0][1]] == ["search"]
assert result["tool_calls"] == 1

# pydantic-ai：断言消息流里的 part 类型
assert sum(1 for m in msgs if type(m).__name__ == "ModelResponse") == 2
assert any(type(p).__name__ == "ToolReturnPart" for m in msgs for p in m.parts)

# smolagents：断言 model.calls 的消息条数与可见工具名
assert model.calls[0] == (2, [])          # CodeAgent 不向模型传工具 schema
assert len(model.calls) == 2