Function Calling 面试与生产落地全攻略
面试题:大模型如何自主判断是否需要调用工具?遇到 JSON 格式错乱、必填参数缺失等异常,如何捕获、兜底、重试?
本文的目标不是背 API 字段,而是把这道题拆成一条可解释、可观测、可恢复的工程链路。读完后,你应该能回答面试官的追问,也能把方案落到真实项目。
资料核验时间:2026-09-03。文末列出 OpenAI、Anthropic、Google Gemini、JSON Schema 等一手资料。
0. 先给面试官一个 90 秒答案
可以先这样回答,再根据追问展开:
Function Calling 不是模型直接执行函数,而是应用把工具名称、用途和 JSON Schema 放进模型上下文。模型根据用户意图、工具描述、参数约束和当前对话状态,决定返回普通文本,还是返回一个结构化的 tool call。
tool_choice=auto时这是概率决策,不是绝对规则;也可以用required、强制某个函数或none约束它。应用收到 tool call 后,必须把它当成不可信输入处理:先校验调用 ID 和工具白名单,再做 JSON 解析、Schema 校验、业务校验和权限校验,最后才执行函数。执行结果不能直接拼成下一轮 prompt,而要按协议带着对应的
call_id回传给模型。异常要分层处理。网络超时、限流等瞬时错误在工具层用指数退避加抖动重试;JSON 解析失败或参数校验失败,生成结构化的错误 tool result 回传给模型,让模型在有限次数内修正;缺少用户信息时应该追问用户,而不是猜;权限不足、业务冲突等不可重试错误要如实结束。所有循环都要有最大轮数、总超时、单次工具超时和重复调用检测。副作用工具还要做用户确认、幂等键、审计和最小权限。
生产上我会用 provider adapter 统一不同厂商的消息格式,用 Pydantic/Zod 做二次校验,记录每次工具选择、参数合法率、执行成功率、恢复率、循环轮数、延迟和成本。这样 Function Calling 才是一个可控的状态机,而不是“让模型自由发挥”。
这段话里有四个关键判断:
- 模型只负责提出调用意图,应用负责执行和安全边界。
- “格式合法”与“业务正确”是两件事,要分层校验。
- 错误要反馈给模型,但重试必须有边界、分类和成本控制。
- 有副作用的调用必须具备确认、幂等和审计能力。
1. Function Calling 到底是什么
1.1 它不是“模型会调用 API”
更准确的定义是:模型输出一个符合协议的调用请求,应用程序执行真实函数,再把结果作为下一轮上下文交给模型。
模型通常看不到数据库连接、API 密钥或内网地址,也没有权限直接执行函数。典型链路如下:
用户问题
│
▼
应用把 tools + prompt 发给模型
│
├── 普通回答 ───────────────────────► 返回用户
│
└── tool_call(name, arguments, call_id)
│
▼
应用解析 + Schema 校验 + 权限校验
│
├── 校验失败:构造 tool_error,回传模型
└── 校验通过:执行真实函数
│
▼
tool_result(call_id, output)
│
▼
模型生成最终回答
(也可能继续提出新的 tool_call)OpenAI 把这个过程概括为五步:带工具请求模型、接收工具调用、应用侧执行、回传工具结果、得到最终响应或继续调用。Responses API 允许循环多次;Chat Completions、Anthropic Messages、Gemini API 的名字不同,但本质都是同一个闭环。
1.2 工具定义是给模型看的“接口文档”
一个函数工具至少包含:
{
"type": "function",
"name": "get_order_status",
"description": "查询当前登录用户的订单状态。只有用户明确询问订单进度时使用;不要用于创建、取消或退款。",
"parameters": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "订单号,格式为 8~32 位大写字母、数字或短横线"
}
},
"required": ["order_id"],
"additionalProperties": false
},
"strict": true
}description 不是给开发者看的注释,而是模型决策依据的一部分。它应该回答:
- 这个工具解决什么问题?
- 什么时候必须用,什么时候不要用?
- 和相近工具的边界是什么?
- 参数格式、单位、枚举和缺省行为是什么?
- 返回什么数据,哪些错误可以恢复?
OpenAI 的官方建议还包括:使用枚举和对象结构减少非法状态;不要让模型重复填写应用已经知道的参数;总是连续调用的函数可以合并;初始暴露的工具尽量少于 20 个(这是软建议,不是硬限制)。工具定义本身也占上下文和输入 token,因此“把所有内部 API 原样暴露给模型”通常既贵又不准。
2. 大模型如何“自主判断”要不要调工具
2.1 从模型视角看,它是在做下一段输出的选择
模型是自回归生成器。应用提供工具后,模型上下文中会出现一套经过训练的工具描述和调用协议。面对用户消息,模型要在候选输出之间做选择:
输出 A:普通 assistant message
输出 B:调用 get_order_status,arguments={...}
输出 C:调用 search_knowledge_base,arguments={...}
输出 D:先询问用户缺少的信息因此“自主判断”不是一个独立的 if/else 分类器,也不是模型真的在后台探测 API,而是模型根据训练到的模式和当前上下文,对这些输出序列进行条件概率选择。工具名称、描述、Schema、系统提示、历史 tool result、用户表达和模型能力共同影响结果。
大多数 API 不会给你一个可直接当作“是否调用”的可靠置信度阈值。不要简单地说“概率超过 0.8 就调用”;如果业务需要确定性,应在模型前面增加规则/轻量路由器,在模型后面增加白名单、权限和风险门,而不是把决策完全交给一个分数。
从工程视角可以把这次生成拆成三个隐含步骤:route(选哪个工具)、slot filling(填哪些参数)、observe/re-plan(看工具结果后是否继续调用)。模型 API 通常把它们合并在一次响应里,但我们在日志和评测中应分开统计,否则“工具选对了但参数错了”和“根本不该调用工具”会被混成一个指标。
可以把它抽象成:
P(工具调用 | 用户意图、工具描述、参数约束、上下文、策略)
> P(直接回答 | 同样条件)
→ 生成 tool_call这也解释了为什么下面这些改动会影响调用率和选错率:
- 把“查询天气”和“预报天气”写成几乎一样的描述,模型更容易选错。
- Schema 把
unit写成自由字符串,模型可能输出摄氏、C、celsius三种值。 - 用户只说“查一下订单”,没有订单号,模型可能追问,也可能猜一个参数;系统提示必须明确禁止猜测。
- 同时暴露 50 个工具,模型需要在更大的候选集合中做路由,准确率、上下文长度和成本都会恶化。
2.2 “模型会不会调”与“应用允许不允许调”是两层
模型决定的是意图,API 参数决定的是控制边界。不同供应商的字段名略有不同,语义大致如下:
| 模式 | 含义 | 适合场景 |
|---|---|---|
auto | 模型可调用 0、1 或多个工具,也可以直接回答 | 默认的开放问答 |
required / any | 必须调用一个或多个工具 | 强制走实时数据或动作前置校验 |
| 指定工具 | 强制调用某一个函数 | 已由上游路由确定工具 |
none | 禁止工具调用,只生成文本 | 解释、总结、最终回复阶段 |
| allowed tools | 只允许本轮工具集合中的子集 | 二级路由、权限隔离、Prompt Cache |
OpenAI 的 parallel_tool_calls=false 可以把一次响应限制为零个或一个调用;Anthropic 使用 disable_parallel_tool_use;Gemini 常见的 function calling mode 是 AUTO、ANY、NONE,具体名称要以 SDK 版本为准。
工程上的经验是:
- 能由代码确定的路由,不要让模型重新猜。例如页面已经选中了订单号,就不要再把
order_id作为模型参数。 - 需要模型理解自然语言的路由,才使用
auto。 - 高风险工具不要因为模型说要调用就直接执行,应增加确认态和权限态。
- 工具很多时,先做领域路由或延迟加载,再把少量相关工具暴露给模型。
2.3 模型“需要工具”不等于工具一定成功
至少要区分三种结果:
模型不调用工具 → 它认为能直接回答,或信息不足需要追问
模型调用工具但参数错 → 路由大致正确,参数生成失败
模型调用工具且参数对 → 还要看权限、网络、业务状态和副作用是否成功所以线上不要只统计“有没有 function_call”,而应该拆出:
- 工具选择正确率(选对工具);
- 参数 Schema 合法率(类型、必填、枚举);
- 业务参数正确率(真实 ID、日期范围、租户);
- 工具执行成功率;
- 最终任务成功率。
3. JSON Schema、strict 与“格式正确”的边界
3.1 Schema 的三个常见误解
误解一:写了 required,模型就永远不会缺字段。
required 是校验规则,不是所有模型和所有网关都能强制执行的生成约束。非 strict 模式下,模型仍可能少字段、错类型或多字段;应用端必须再次校验。
误解二:字段在 properties 里,就天然是必填。
JSON Schema 默认允许缺省属性。只有名字出现在 required 数组里,才表示必须存在。
误解三:JSON 能解析,就代表参数正确。
{"order_id": 123} 是合法 JSON,但如果 order_id 应该是字符串,它仍然不符合 Schema;{"date":"2026-99-99"} 可能满足 string,却不满足业务日期。
3.2 strict mode 能保证什么
以 OpenAI 为例,函数工具设置 strict: true 后,模型调用会尽量严格遵守 Schema;官方建议默认开启。strict function calling 通常要求:
- 每个对象设置
additionalProperties: false; properties中的字段全部出现在required;- “可选字段”用
type: ["string", "null"]这类可空类型表达,而不是从required中删除; - 只能使用供应商支持的 JSON Schema 子集。
Anthropic 的 strict tool use 采用 grammar-constrained sampling,把工具输入约束到 Schema 合法的 token 序列;这能消除许多类型错误和缺字段问题,但同样不能保证业务事实、权限或下游服务一定正确。
严格约束的正确理解是:
strict schema
≈ 输出结构/类型/枚举符合约定
≠ 参数代表真实存在的订单
≠ 当前用户有权限操作该订单
≠ 工具执行一定成功3.3 可选参数的推荐写法
如果供应商要求 strict 下所有字段都 required,可以这样表达:
{
"type": "object",
"properties": {
"location": {"type": "string"},
"unit": {"type": ["string", "null"], "enum": ["celsius", "fahrenheit", null]}
},
"required": ["location", "unit"],
"additionalProperties": false
}应用层再把 null 转换为默认单位。这样既保持 strict 约束,又不会让模型凭空编造一个用户没有提供的值。
3.4 Schema 设计原则
{
"type": "object",
"properties": {
"action": {
"type": "string",
"enum": ["preview", "apply"],
"description": "preview 只读预览;apply 会产生真实变更"
},
"amount": {
"type": "number",
"description": "金额,单位为人民币元,必须大于 0"
}
},
"required": ["action", "amount"],
"additionalProperties": false
}比起 toggle(on: bool, off: bool),action 枚举避免了两个布尔值同时为 true 或同时为 false 的非法状态。可执行动作和预览动作也可以拆成两个工具,让高风险操作更容易加确认。
4. 异常不是一种:按边界分层
面试官问“JSON 错了怎么办”,真正想听的是你有没有完整的故障模型。建议按下面六层回答。
| 层次 | 典型问题 | 捕获位置 | 默认动作 |
|---|---|---|---|
| API/协议层 | 请求超时、限流、模型 5xx、Schema 本身不被支持 | LLM client | 指数退避;超过上限切换模型或降级 |
| 解析层 | arguments 不是合法 JSON、流式片段未拼完整、代码围栏混入 | adapter/parser | 先缓冲/重组;失败时有限次修复或回传错误 |
| Schema 层 | 缺必填、类型错、枚举错、多余字段 | validator | 结构化错误回传模型;达到上限就结束 |
| 业务层 | 订单不存在、日期冲突、余额不足、状态不允许 | tool service | 不要盲目重试;反馈可行动错误 |
| 安全/权限层 | 越权、跨租户、SSRF、危险 SQL、敏感字段泄漏 | policy/auth | 直接拒绝并审计;不把内部细节暴露给模型 |
| 执行层 | 下游 429、网络抖动、慢查询、部分成功、副作用重复 | tool runner | 只重试可重试错误;幂等或补偿 |
4.1 JSON 格式错乱
常见输入包括:
{"location":"Shanghai" // 少了 }
```json
{"location":"Shanghai"}
``` // 混入 Markdown 围栏
{"location":"Shanghai",} // 尾逗号
{"location": 123} // JSON 合法,但类型错处理顺序建议是:
- 先判断是否仍在流式生成。 流式 function call 的参数可能被拆成多个 delta,不能收到第一段就
json.loads;应按call_id缓冲,直到 provider 的完成事件。 - 只做协议允许的最小归一化。 例如去掉首尾空白;是否剥离代码围栏要看协议,不要用宽松正则“猜”模型意图。
- 先
json.loads,再 Schema 校验。 不要把 JSON 解析和业务校验混成一个异常。 - 读工具类型。 只读工具可以在错误信息中要求模型重新生成参数;支付、删除、发邮件等副作用工具,不应自动使用不确定的“修复后参数”执行。
还要区分模型响应的终止原因:达到输出上限导致的截断、内容安全拒答、模型服务错误,都不是普通的 JSON 解析错误。截断应增加预算或重新请求;拒答应走安全兜底;服务错误应走传输层重试。
还要区分模型响应的终止原因:达到输出上限导致的截断、内容安全拒答、模型服务错误,都不是普通的 JSON 解析错误。截断应增加预算或重新请求;拒答应走安全兜底;服务错误应走传输层重试。
不建议默认使用“万能 JSON 修复器”:它可能把错误的金额、日期或收件人修成一个看似合法但实际危险的值。若确实要使用 repair library,应只对低风险、无副作用的工具启用,并保留原始输入、修复结果和审计记录。
4.2 必填参数缺失
缺字段有两种完全不同的原因:
- 用户没有提供信息:例如“帮我查订单”没有订单号;正确动作是追问用户。
- 用户提供了信息,但模型没有填入:例如历史里已有订单号,工具 Schema 或 prompt 写得不清;可以把校验错误回传给模型,让它从上下文补齐。
应用不要替模型猜关键参数。可以把错误返回成:
{
"ok": false,
"error": {
"code": "INVALID_ARGUMENT",
"message": "缺少必填字段 order_id",
"fields": ["order_id"],
"retryable": true,
"next_action": "ask_user_or_repair"
}
}工具结果里的错误信息应简短、具体、可行动,不要塞 Python 堆栈、数据库连接串或内部路径。
不要修改历史里的那条 assistant tool call,也不要复用同一个调用结果“覆盖”旧结果。把错误作为原调用的结果追加进去,让模型下一轮产生一个新的 call_id;这样历史可重放、审计可追踪,也避免协议层出现“同一个 call_id 多次返回不同结果”的歧义。
4.3 工具执行失败
工具错误要有机器可读的分类,不要只返回一段“失败了”:
{
"ok": false,
"error": {
"code": "UPSTREAM_RATE_LIMITED",
"message": "天气服务暂时限流,请稍后重试",
"retryable": true,
"retry_after_ms": 800
}
}模型可以据此决定等待、换工具、降低范围或告诉用户;真正的重试计时和次数仍由应用控制,不能交给模型自由循环。
5. 一套可落地的 Agent 状态机
把 Function Calling 看成状态机,比把它写成递归 prompt 更容易控制:
START
│
▼
ASK_MODEL ──普通文本──► DONE
│
└─tool_call
│
▼
NORMALIZE
│
├─协议错误──────► TOOL_ERROR ─► ASK_MODEL(有限次)
├─JSON 错误─────► TOOL_ERROR ─► ASK_MODEL(有限次)
├─Schema 错误───► TOOL_ERROR ─► ASK_MODEL(有限次)
├─权限错误──────► DENY ──────► DONE/人工介入
└─校验通过
│
▼
EXECUTE_TOOL
│
├─瞬时错误──► BACKOFF_RETRY(有上限)
├─业务错误──► TOOL_ERROR ─► ASK_MODEL 或 DONE
└─成功
│
▼
APPEND_RESULT
│
▼
ASK_MODEL(直到终止条件)每一轮都检查:
max_rounds:最多模型—工具往返次数;max_tool_calls:单个请求最多执行多少个工具调用;deadline:整个任务的墙钟时间;tool_timeout:单个工具的超时;token_budget:上下文和输出预算;repeated_call_guard:相同工具和规范化参数重复出现时停止;confirmation_required:副作用工具是否拿到用户确认令牌。
5.1 错误回传为什么比直接抛异常更好
如果应用收到参数错误后直接抛给用户,模型没有机会修复;如果应用吞掉错误,模型会误以为工具成功。正确做法是把错误作为与该次调用对应的 tool result回传:
assistant: tool_call(call_id=call_123, name=get_order_status, ...)
tool: tool_result(call_id=call_123, ok=false, code=INVALID_ARGUMENT, ...)
assistant: “我还缺少订单号,请提供 8~32 位订单号。”OpenAI Responses 使用 function_call_output 和 call_id;Chat Completions 使用 role=tool 与 tool_call_id;Anthropic 使用 tool_result 与 tool_use_id,并可以用 is_error: true 表示失败。协议名称不同,但“结果必须指向具体调用”是共同原则。
5.2 多工具并行调用
模型一次返回多个调用时,先判断它们是否独立:
| 调用关系 | 执行策略 |
|---|---|
| 两个只读查询,互不依赖 | 并行执行,降低延迟 |
| 第二个参数依赖第一个结果 | 顺序执行,或拆成两轮 |
| 都会写共享状态 | 默认顺序执行,必要时加锁/事务 |
| 支付、退款、发邮件等副作用 | 逐个确认、幂等、审计 |
每个调用都必须返回一个结果,且结果 ID 一一匹配。Anthropic 的规则尤其明确:并行调用的所有 tool_result 要放在同一个后续 user message 中,并且文本内容不能插在这些结果前面。OpenAI 也建议假设一次响应可能有零个、一个或多个调用。
6. 重试策略:重试什么、由谁重试
6.1 重试决策矩阵
| 错误 | 是否重试 | 谁来重试 | 关键约束 |
|---|---|---|---|
| LLM 连接超时、429、5xx | 是 | LLM client | 指数退避 + jitter;设置总预算 |
| JSON 不可解析 | 最多 1~2 次 | Agent loop | 回传错误;流式先确认已结束 |
| Schema 缺字段/类型错 | 最多 1~2 次 | Agent loop | 提供字段级错误;禁止无限自我修复 |
| 用户信息缺失/歧义 | 否 | 用户交互 | 追问,不猜关键字段 |
| 订单不存在、余额不足 | 否 | 模型/应用 | 告知原因,必要时换方案 |
| 权限不足、越权 | 否 | 应用策略层 | 直接拒绝并记录审计 |
| 下游网络抖动、限流 | 是 | 工具 runner | 只对幂等读操作自动重试 |
| 创建订单/支付/发邮件 | 谨慎 | 工具服务 | Idempotency-Key、确认、补偿事务 |
6.2 指数退避与抖动
常用等待时间:
delay = min(max_delay, base * 2^attempt) + random(0, jitter)例如 base=200ms、max_delay=3s、jitter=200ms,最多尝试 3 次。退避只解决瞬时故障,不会把权限错误或非法参数变成成功。
6.3 模型重试与工具重试要分开
这是面试里很容易被追问的一点:
- 模型重试:重新请求模型生成 tool call,成本是 token、延迟和可能的不同决策。适用于格式/Schema 错误。
- 工具重试:再次调用下游服务,风险是重复副作用。适用于网络抖动、429、幂等读请求。
一个好的错误对象会同时告诉应用和模型不同的信息:
{
"ok": false,
"error": {
"code": "TIMEOUT",
"message": "上游响应超时",
"retryable": true,
"safe_to_retry": false,
"user_action": "稍后重试"
}
}retryable=true 表示“错误类别理论上可恢复”;safe_to_retry=false 表示“本次请求是否可能已经在下游生效尚不确定”,这时应先查询结果或使用幂等键,不能直接重复扣款。
6.4 防止无限循环
不能只依赖 prompt 中的“不要无限调用”。应用必须硬编码终止条件,并检测下面的模式:
signature = (tool_name, canonical_json(arguments))
if signature in recent_signatures:
# 同一个工具和同一组参数连续重复,说明模型没有获得新信息
return fallback("工具调用没有产生新的进展")还应记录:round_index、tool_call_count、累计 token、累计费用、最早 deadline。达到任一上限都要返回可解释的降级结果。
7. Python 参考实现:解析、校验、错误反馈与执行
下面的代码故意把 provider client 抽象成 model_turn(),便于替换 OpenAI Responses、Chat Completions、Anthropic 或 Gemini。核心不在某个 SDK,而在边界顺序。
from __future__ import annotations
import json
import random
import time
from dataclasses import dataclass
from datetime import date
from typing import Any, Callable
from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_validator
class WeatherArgs(BaseModel):
"""工具参数模型:Schema 校验通过后仍要做业务校验。"""
model_config = ConfigDict(extra="forbid")
location: str = Field(min_length=1, description="城市名,例如 Shanghai")
unit: str | None = Field(default=None, description="celsius 或 fahrenheit")
start_date: date | None = None
@field_validator("unit")
@classmethod
def valid_unit(cls, value: str | None) -> str | None:
if value is not None and value not in {"celsius", "fahrenheit"}:
raise ValueError("unit 必须是 celsius 或 fahrenheit")
return value
def get_weather(location: str, unit: str | None, start_date: date | None) -> dict[str, Any]:
# 真实项目中这里调用有超时和鉴权的下游客户端
return {"location": location, "unit": unit or "celsius", "temperature": 26}
TOOLS: dict[str, tuple[type[BaseModel], Callable[..., Any]]] = {
"get_weather": (WeatherArgs, get_weather),
}
class ToolInputError(Exception):
def __init__(self, code: str, message: str, fields: list[str] | None = None):
self.code = code
self.message = message
self.fields = fields or []
super().__init__(message)
def parse_and_validate(call: dict[str, Any]) -> tuple[str, BaseModel]:
"""把 provider 输出变成可信的内部对象;任何异常都在这里收口。"""
call_id = call.get("call_id") or call.get("id")
name = call.get("name")
if not call_id or not name:
raise ToolInputError("PROTOCOL_ERROR", "tool call 缺少 call_id 或 name")
if name not in TOOLS:
raise ToolInputError("UNKNOWN_TOOL", f"不允许调用工具 {name}")
raw = call.get("arguments", {})
if isinstance(raw, str):
try:
raw = json.loads(raw)
except json.JSONDecodeError as exc:
raise ToolInputError("INVALID_JSON", f"arguments 不是合法 JSON:{exc.msg}") from exc
if not isinstance(raw, dict):
raise ToolInputError("INVALID_ARGUMENT", "arguments 必须是 JSON object")
schema_model, _ = TOOLS[name]
try:
return name, schema_model.model_validate(raw)
except ValidationError as exc:
fields = [".".join(str(x) for x in e["loc"]) for e in exc.errors()]
raise ToolInputError("SCHEMA_VALIDATION_ERROR", "参数不符合工具 Schema", fields) from exc
def tool_error(exc: ToolInputError, *, call_id: str) -> dict[str, Any]:
"""错误对模型可读、对日志可追踪,但不泄漏堆栈和秘密。"""
return {
"call_id": call_id,
"ok": False,
"error": {
"code": exc.code,
"message": exc.message,
"fields": exc.fields,
"retryable": exc.code in {"INVALID_JSON", "SCHEMA_VALIDATION_ERROR"},
},
}
def with_backoff(fn: Callable[[], Any], attempts: int = 3) -> Any:
"""这里只重试已被工具层标记为可重试的瞬时错误。"""
for attempt in range(attempts):
try:
return fn()
except (TimeoutError, ConnectionError):
if attempt == attempts - 1:
raise
delay = min(3.0, 0.2 * (2**attempt)) + random.random() * 0.2
time.sleep(delay)
def execute_call(call: dict[str, Any]) -> dict[str, Any]:
call_id = call.get("call_id") or call.get("id") or "unknown"
try:
name, args = parse_and_validate(call)
_, fn = TOOLS[name]
# 这里还应注入真实用户身份、租户和权限;不要信任模型传来的 user_id。
result = with_backoff(lambda: fn(**args.model_dump()))
return {"call_id": call_id, "ok": True, "data": result}
except ToolInputError as exc:
return tool_error(exc, call_id=call_id)
except PermissionError:
return {
"call_id": call_id,
"ok": False,
"error": {"code": "FORBIDDEN", "message": "当前用户无权执行该操作", "retryable": False},
}
except Exception:
# 真实项目应记录 trace_id 和异常分类,给模型的内容保持稳定、脱敏。
return {
"call_id": call_id,
"ok": False,
"error": {"code": "TOOL_UNAVAILABLE", "message": "工具暂时不可用", "retryable": False},
}
def agent_loop(model_turn: Callable[[list[dict[str, Any]]], dict[str, Any]],
messages: list[dict[str, Any]], max_rounds: int = 5) -> str:
"""model_turn 负责调用供应商 API,返回 {text, tool_calls, raw_output}。"""
recent_signatures: set[str] = set()
for round_index in range(max_rounds):
response = model_turn(messages)
calls = response.get("tool_calls") or []
if not calls:
return response.get("text", "")
# 把 assistant 的原始 tool call 保留到历史,不能只保留自然语言摘要。
messages.append(response["raw_output"])
results = []
for call in calls:
signature = json.dumps(
[call.get("name"), call.get("arguments")],
ensure_ascii=False,
sort_keys=True,
)
if signature in recent_signatures:
return "工具调用重复且没有新进展,请补充信息后重试。"
recent_signatures.add(signature)
results.append(execute_call(call))
# 不同 provider 的包装不同;这里的内部协议统一为 tool_result。
messages.append({"role": "tool", "content": results})
return "本次操作超过最大推理轮数,已停止继续调用工具。"生产代码还需要把 messages.append 适配成具体供应商协议:
- OpenAI Responses:保留
response.output,把每个结果作为function_call_output,通过call_id关联;推理模型的 reasoning item 也要按官方要求带回。 - Chat Completions:保留 assistant 的
tool_calls,每个结果使用role=tool、对应tool_call_id。 - Anthropic:保留 assistant 的
tool_useblock,后续用tool_result;失败时设置is_error: true。 - Gemini:按 SDK 的
functionCall/functionResponse结构回传。
8. 生产落地的五个关键组件
8.1 Provider Adapter:统一协议,不统一细节
建议内部定义一个中间模型:
@dataclass
class NormalizedToolCall:
provider: str
call_id: str
name: str
arguments: str | dict[str, Any]
@dataclass
class NormalizedTurn:
text: str | None
tool_calls: list[NormalizedToolCall]
raw: Any
finish_reason: str | NoneAdapter 负责处理字段差异、流式 delta 拼接、finish reason、拒答和原始响应保存;dispatcher 只依赖 NormalizedToolCall,不在业务代码里到处写 if provider == ...。
8.2 Tool Registry:工具不是一张函数字典
每个工具注册项至少应包含:
name / description / input_schema
handler
auth_scope
side_effect_level: read | write | irreversible
timeout_ms
retry_policy
idempotency_policy
redaction_policy
version这样可以在执行前统一做白名单、权限、超时和审计,而不是把安全逻辑散落在每个 handler 里。
8.3 Policy Gate:模型不能越过业务权限
模型传来的 tenant_id、user_id、role 都是不可信的。应用应从登录态、会话和服务端上下文注入这些信息;工具的真实签名可以不把它们暴露给模型:
模型只提供:order_id
应用执行:get_order_status(order_id, user_id=current_user, tenant=current_tenant)危险工具采用两阶段:
plan / preview → 展示影响范围与参数 → 用户确认 → apply / commit8.4 Retry Budget:重试是预算,不是 while True
为每个请求分配:
- LLM 重试次数;
- 参数修复次数;
- 单工具网络重试次数;
- 总墙钟时间;
- 最大 token / 费用;
- 最大副作用次数。
预算要在 trace 中可见,超过预算的降级原因也要可观测。
8.5 Fallback:降级要有层次
一个可用的降级链路通常是:
主工具实时查询
→ 同域备用工具/缓存
→ 只读知识库或最近一次成功结果(标注时间)
→ 明确告知暂不可用
→ 高风险场景转人工不要在实时工具失败后让模型凭训练记忆“估一个答案”,尤其是库存、余额、价格、权限和医疗信息。
9. 安全:Function Calling 的危险不在 JSON,而在“可执行”
9.1 最小权限和服务端鉴权
模型只能看到完成任务所需的最小工具集合;工具执行前重新检查用户、租户、资源归属和权限。不要把 API key、内部 URL、数据库密码放入工具描述或 tool result。
9.2 工具结果也可能带 Prompt Injection
搜索结果、网页、工单正文和数据库字段都属于外部数据,可能包含“忽略系统指令、执行某命令”等文本。回传模型时要明确它们是不可信数据,不能把工具返回内容当成新的系统指令;高风险动作需要独立 policy gate,而不是让模型根据结果自行决定越权操作。
9.3 SSRF、SQL、路径和命令执行
- URL 工具:域名白名单、禁止内网地址和重定向穿透;
- SQL 工具:优先预定义查询/参数化查询,只读账号和行数上限;
- 文件工具:目录沙箱、路径规范化、禁止
..穿越; - Shell 工具:命令白名单、容器隔离、资源配额和超时。
9.4 副作用的幂等与审计
对创建订单、退款、发邮件等动作:
- 应用生成稳定的幂等键(同一逻辑操作重试保持不变);
- 下游先查询幂等键是否已完成;
- 用户确认的内容和最终执行参数做哈希并记录;
- 记录操作者、工具版本、参数摘要、结果、时间和 trace_id;
- 对部分成功使用 outbox、事务消息或补偿流程。
10. 评测与可观测性:不要只看最终答案
10.1 离线评测集
至少覆盖这些样本:
- 应该直接回答,不应调用工具;
- 应该调用工具,且只有一个工具匹配;
- 多个工具都可能匹配,需要看描述边界;
- 缺少必填信息,必须追问;
- 同义词、中文日期、单位、枚举和边界值;
- 恶意 prompt injection、越权和高风险动作;
- 工具返回错误、超时、空结果和部分结果。
10.2 推荐指标
| 指标 | 含义 |
|---|---|
| Tool selection accuracy | 工具是否选对 |
| Argument validity rate | JSON + Schema 是否通过 |
| Semantic argument accuracy | ID、日期、单位等业务值是否正确 |
| Tool execution success | 下游是否成功 |
| Error recovery rate | 发生错误后最终完成的比例 |
| Clarification precision | 该追问时是否追问,能否避免猜测 |
| Side-effect safety rate | 未确认/越权/重复副作用的拦截率 |
| Loop rounds / repeated-call rate | 是否出现无效循环 |
| TTFT、p95、token、cost | 性能和成本 |
10.3 一条请求应留下什么 trace
{
"trace_id": "tr_001",
"model": "…",
"tool_surface": ["get_weather", "search_docs"],
"rounds": [
{
"round": 0,
"finish_reason": "tool_call",
"calls": [
{"call_id": "call_1", "name": "get_weather", "args_hash": "…", "schema_ok": true}
]
},
{
"round": 1,
"finish_reason": "stop",
"tool_result": {"ok": true, "latency_ms": 183}
}
],
"budgets": {"max_rounds": 5, "used_rounds": 2, "input_tokens": 1200},
"final_status": "success"
}日志中对邮箱、手机号、订单号、地址等字段做脱敏;参数原文是否可存取决于合规要求,必要时只保留哈希和字段级错误。
11. 面试官高频追问与标准回答
Q1:模型真的“知道”什么时候要调用工具吗?
答:它不是一个确定性规则引擎,而是基于工具描述和上下文生成 tool call 的概率决策。我们通过清晰描述、Schema、系统提示和 tool_choice 调整边界;最终是否执行由应用白名单、权限和校验决定。模型提出调用不代表调用一定会被执行。
Q2:打开 strict 后,还需要 Pydantic 校验吗?
答:需要。strict 主要保证模型输出符合供应商支持的 Schema 子集;它不保证订单存在、用户有权限、日期业务有效或下游成功。应用端仍要做协议、Schema、业务和安全四层校验。
Q3:缺必填参数时,应该让模型补,还是直接报错?
答:先判断信息是否在上下文中。如果用户没有提供,追问用户;如果历史中已有且只是模型漏填,把字段级错误作为 tool result 回传,最多修复一两次。订单号、金额、收件人等关键字段不能猜。
Q4:JSON 解析失败能不能用正则修复?
答:低风险只读工具可以在严格边界内做最小归一化或专门 repair;副作用工具不建议自动猜测修复。先处理流式拼接,再 json.loads,再 Schema 校验;修复次数和工具风险绑定,并保留审计记录。
Q5:工具调用失败后,为什么不直接重新问用户?
答:要先分类。网络超时或限流是应用可自动重试的瞬时错误;参数错误适合回传模型修复;缺用户信息才追问;权限和业务冲突直接解释。所有错误都重新问用户,会让体验变差,也无法体现系统的自恢复能力。
Q6:如何避免模型一直调用同一个工具?
答:应用侧设置最大轮数、最大工具次数、总超时、token/费用预算,并对“工具名 + 规范化参数”做重复签名检测。重复调用且没有新结果就停止,返回降级信息或转人工。
Q7:多个工具调用可以并行吗?
答:可以,但只对相互独立、最好是只读的调用并行;有依赖关系或共享状态时顺序执行。每个 call 都要返回对应 call_id 的 result;副作用操作还要考虑幂等、锁和确认。
Q8:为什么不把所有内部函数都注册给模型?
答:工具定义占上下文 token,工具越多选择空间越大,描述冲突也越多。按领域做二级路由、权限过滤或延迟加载,保持本轮可见工具集小而清晰。工具注册表也应该是版本化、可审计的接口目录。
Q9:Function Calling 和 JSON Mode / Structured Outputs 有什么区别?
答:JSON Mode 主要保证“是合法 JSON”,不保证符合业务 Schema;Structured Outputs 约束模型输出符合 JSON Schema;Function Calling 则是在此基础上多了一层“调用哪个工具”和“应用执行后回传结果”的交互协议。三者都不能替代业务校验和权限控制。
Q10:重试副作用接口会不会重复扣款?
答:会,所以不能只写一个通用 retry 装饰器。副作用工具需要稳定 Idempotency-Key、下游幂等支持、执行前确认、执行后查询和审计;网络超时但结果未知时,先查询幂等键状态,再决定是否补偿。
Q11:怎么证明优化真的有效?
答:固定评测集,单变量 A/B,分别测工具选择、参数合法、业务正确、工具成功、错误恢复和端到端成功率;线上保留每一轮的工具集合、调用参数摘要、错误分类、延迟和成本,而不是只看最终文本满意度。
Q12:把 temperature 调到 0,是不是就不会选错工具?
答:不是。低 temperature 只能减少采样随机性,不能修复工具描述冲突、上下文歧义、Schema 设计错误或模型能力边界;不同模型版本、服务端批处理和并行执行仍可能有差异。需要可控性时,应该减少工具面、明确路由、启用 strict、做服务端校验,并用固定评测集验证,而不是把“temperature=0”当作可靠性方案。
12. 一份可以直接带进项目的检查清单
设计阶段
- [ ] 每个工具有清晰的 name、用途、何时使用/不使用、参数描述和返回格式。
- [ ] Schema 使用 enum、边界、
required、additionalProperties: false,并符合供应商支持子集。 - [ ] 工具按领域和权限裁剪,不把所有函数一次暴露。
- [ ] 已知的用户、租户、权限信息由应用注入,不让模型填写。
- [ ] 副作用工具区分 preview/apply,并需要确认和幂等键。
运行阶段
- [ ] 校验 call_id、工具白名单、JSON、Schema、业务和权限。
- [ ] 流式参数按 call_id 缓冲,完成后再解析。
- [ ] 错误使用稳定的 code、message、retryable、fields 返回给模型。
- [ ] LLM 重试、参数修复、工具重试分开计数。
- [ ] 所有循环都有轮数、工具数、超时、token 和费用上限。
- [ ] 并行调用按依赖和副作用等级决定是否并行。
- [ ] tool result 与 call_id 一一对应,保存必要的原始响应。
生产阶段
- [ ] 有 fallback、缓存、备用工具或人工介入路径。
- [ ] 有 tool selection、argument validity、execution、recovery、safety 指标。
- [ ] 日志脱敏,trace 可重放,参数和工具版本可追溯。
- [ ] 防 SSRF、SQL 注入、路径穿越、命令执行和 tool output prompt injection。
- [ ] 高风险动作具备审计、限流、幂等和补偿流程。
13. 最后的面试收束句
如果面试官继续追问,可以用这句话收尾:
Function Calling 的核心不是“模型会不会输出一段 JSON”,而是把模型的概率性决策包在一个确定性的执行边界里:模型负责选择和提出参数,应用负责校验、授权、执行、反馈、重试、降级和审计。真正的工程能力体现在失败时仍然可解释、可恢复、可控,而不是只展示一次成功 demo。
参考资料(以官方文档为主)
- OpenAI — Function calling:五步调用链、工具定义、
tool_choice、并行调用、strict mode、工具描述最佳实践。 - OpenAI — Structured Outputs:Schema 约束、拒答检测、JSON Mode 对比与支持范围。
- OpenAI Cookbook — How to call functions with chat models:Chat Completions、强制/禁止工具、并行函数调用示例。
- Anthropic — Tool use overview:
tool_use/tool_result往返、stop_reason和工具选择。 - Anthropic — Strict tool use:grammar-constrained sampling 与 strict 输入保证。
- Anthropic — Parallel tool use:并行执行、结果配对、
is_error与禁用并行。 - Google — Function calling with the Gemini API:函数声明、function call/response 与调用模式。
- JSON Schema — Object reference:
properties、required、additionalProperties的标准语义。
供应商字段和模型能力会持续演进。面试时讲清楚协议和工程原则;项目上线前再按所选模型、SDK 版本和数据合规要求核对最新文档。