为什么 ZCP 比 MCP 更强

官方 MCP server 路径会先把函数元数据变成 Pydantic 模型，再变成 JSON Schema，这个 schema 之后自然成为工具合同的一部分。

class Tool(BaseModel):
    fn: Callable[..., Any] = Field(exclude=True)
    name: str = Field(description="Name of the tool")
    parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
    fn_metadata: FuncMetadata = Field(...)

    @classmethod
    def from_function(cls, fn: Callable[..., Any], ...):
        func_arg_metadata = func_metadata(fn, ...)
        parameters = func_arg_metadata.arg_model.model_json_schema(by_alias=True)
        return cls(
            fn=fn,
            name=func_name,
            parameters=parameters,
            fn_metadata=func_arg_metadata,
        )

默认调用路径把结果包装进 `CallToolResult(content, structured_content)`。这对兼容很自然，但也意味着大结果更容易继续进入后续 prompt。

async def _handle_call_tool(self, ctx, params) -> CallToolResult:
    result = await self.call_tool(params.name, params.arguments or {}, context)

    if isinstance(result, CallToolResult):
        return result
    if isinstance(result, tuple) and len(result) == 2:
        unstructured_content, structured_content = result
        return CallToolResult(
            content=list(unstructured_content),
            structured_content=structured_content,
        )
    return CallToolResult(content=list(result))

ZCP 没有让 schema 消失，而是让 schema 变成更大 runtime contract 里的一个字段。真正居中的，是子集、handles、output mode 和 session state。

@dataclass
class ToolDefinition:
    tool_id: str
    alias: str
    description_short: str
    input_schema: dict[str, Any]
    output_schema: dict[str, Any] | None = None
    output_mode: Literal["handle", "scalar"] = "handle"
    handle_kind: str = "generic"
    defaults: dict[str, Any] = field(default_factory=dict)
    flags: frozenset[str] = field(default_factory=frozenset)
    metadata: dict[str, Any] = field(default_factory=dict)

@dataclass
class SessionState:
    session_id: str
    registry_hash: str = ""
    tool_subset: tuple[str, ...] = ()
    handles: dict[str, HandleRef] = field(default_factory=dict)

profile 和 stage 过滤是 runtime 规则，不是 prompt 工程；模型在第一轮之前就被限制在更小搜索空间里。

def _select_tools(app: FastZCP, params: dict[str, Any]) -> list[Any]:
    tools = app.tool_registry.subset().tools
    profile = _effective_tool_profile(app, params)
    include_groups = _normalize_filter_values(params.get("groups"))
    stages = _normalize_filter_values(params.get("stages"))

    if profile == app.semantic_workflow_profile:
        workflow_tools = [tool for tool in tools if app.semantic_group in _tool_groups(tool)]
        if workflow_tools:
            tools = workflow_tools

    if include_groups:
        tools = [tool for tool in tools if _tool_groups(tool) & include_groups]
    if stages:
        tools = [tool for tool in tools if _tool_stages(tool) & stages]
    return tools

strict JSON Schema 仍然保留，但它是从当前 `RegistryView` 现编出来的 provider artifact，而不是 runtime 的中心对象。

def compile_openai_tools(self, session: SessionState, *, tool_subset=None, strict_mode=True):
    subset_tuple = tuple(tool_subset or ())
    registry_view = self.registry.subset(list(subset_tuple) if subset_tuple else None, limit=self.tool_limit)
    session.registry_hash = registry_view.hash
    session.tool_subset = subset_tuple

    if key not in self._tool_cache:
        tools = self.compiler.compile_registry(registry_view)
        self._tool_cache[key] = tools
    return self._tool_cache[key]

这段代码最直接地体现了“去中心化 JSON Schema”：原生 planner 只需要工具 id、别名、紧凑类型和 output mode。

def format_registry(tools: list[ToolDefinition]) -> str:
    entries = []
    for tool in tools:
        params = ",".join(
            f"{name}:{_compact_type(schema)}"
            for name, schema in tool.input_schema.get("properties", {}).items()
        )
        entries.append(f"TOOL @{tool.tool_id} {tool.alias}({params}) -> {tool.output_mode}")
    return "\n".join(entries)

这是 discovery 之后第二重要的 token 节约机制。大对象不再每轮原样回到 prompt，而是通过 handle 延迟展开。

if tool.output_mode == "scalar" and (tool.inline_ok or is_scalar_value(value)):
    return CallResult(
        cid=request.cid,
        status="ok",
        scalar=value,
        summary=summary,
        meta=meta,
    )

handle = self.handle_store.create(
    kind=handle_kind,
    data=value,
    summary=summary,
    meta=meta,
)
return CallResult(
    cid=request.cid,
    status="ok",
    handle=handle,
    summary=handle.summary,
    meta=meta,
)

小优势是预期内的

单次工具调用本来就没有多少规划浪费可以削掉，所以这个 tier 只能证明 ZCP 没有退化，不应该承担 headline。

语义链路开始起作用

当模型本来需要在多个强耦合 primitive 调用之间规划时，semantic chain tools 和 discovery 收窄会立刻降低内部决策点数量。

workflow 压缩开始主导结果

这说明优势不是 wire format 的小修小补，而是模型不再被迫规划每一个底层单步操作，token 下降因此是结构性的。

自主规划才是真压力测试

Tier D 最容易出现 repair loop、重复 readback 和状态噪声。native ZCP 能赢，是因为 runtime 在这些噪声进入 prompt 之前就先把它们压住了。