Skip to content

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. 模型只负责提出调用意图,应用负责执行和安全边界。
  2. “格式合法”与“业务正确”是两件事,要分层校验。
  3. 错误要反馈给模型,但重试必须有边界、分类和成本控制。
  4. 有副作用的调用必须具备确认、幂等和审计能力。

1. Function Calling 到底是什么 ​

1.1 它不是“模型会调用 API” ​

更准确的定义是:模型输出一个符合协议的调用请求,应用程序执行真实函数,再把结果作为下一轮上下文交给模型。

模型通常看不到数据库连接、API 密钥或内网地址,也没有权限直接执行函数。典型链路如下:

text
用户问题
   │
   ▼
应用把 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 工具定义是给模型看的“接口文档” ​

一个函数工具至少包含:

json
{
  "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 从模型视角看,它是在做下一段输出的选择 ​

模型是自回归生成器。应用提供工具后,模型上下文中会出现一套经过训练的工具描述和调用协议。面对用户消息,模型要在候选输出之间做选择:

text
输出 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 通常把它们合并在一次响应里,但我们在日志和评测中应分开统计,否则“工具选对了但参数错了”和“根本不该调用工具”会被混成一个指标。

可以把它抽象成:

text
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 版本为准。

工程上的经验是:

  1. 能由代码确定的路由,不要让模型重新猜。例如页面已经选中了订单号,就不要再把 order_id 作为模型参数。
  2. 需要模型理解自然语言的路由,才使用 auto。
  3. 高风险工具不要因为模型说要调用就直接执行,应增加确认态和权限态。
  4. 工具很多时,先做领域路由或延迟加载,再把少量相关工具暴露给模型。

2.3 模型“需要工具”不等于工具一定成功 ​

至少要区分三种结果:

text
模型不调用工具       → 它认为能直接回答,或信息不足需要追问
模型调用工具但参数错 → 路由大致正确,参数生成失败
模型调用工具且参数对 → 还要看权限、网络、业务状态和副作用是否成功

所以线上不要只统计“有没有 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 序列;这能消除许多类型错误和缺字段问题,但同样不能保证业务事实、权限或下游服务一定正确。

严格约束的正确理解是:

text
strict schema
    ≈ 输出结构/类型/枚举符合约定
    ≠ 参数代表真实存在的订单
    ≠ 当前用户有权限操作该订单
    ≠ 工具执行一定成功

3.3 可选参数的推荐写法 ​

如果供应商要求 strict 下所有字段都 required,可以这样表达:

json
{
  "type": "object",
  "properties": {
    "location": {"type": "string"},
    "unit": {"type": ["string", "null"], "enum": ["celsius", "fahrenheit", null]}
  },
  "required": ["location", "unit"],
  "additionalProperties": false
}

应用层再把 null 转换为默认单位。这样既保持 strict 约束,又不会让模型凭空编造一个用户没有提供的值。

3.4 Schema 设计原则 ​

json
{
  "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 格式错乱 ​

常见输入包括:

text
{"location":"Shanghai"                 // 少了 }
```json
{"location":"Shanghai"}
```                                      // 混入 Markdown 围栏
{"location":"Shanghai",}              // 尾逗号
{"location": 123}                       // JSON 合法,但类型错

处理顺序建议是:

  1. 先判断是否仍在流式生成。 流式 function call 的参数可能被拆成多个 delta,不能收到第一段就 json.loads;应按 call_id 缓冲,直到 provider 的完成事件。
  2. 只做协议允许的最小归一化。 例如去掉首尾空白;是否剥离代码围栏要看协议,不要用宽松正则“猜”模型意图。
  3. 先 json.loads,再 Schema 校验。 不要把 JSON 解析和业务校验混成一个异常。
  4. 读工具类型。 只读工具可以在错误信息中要求模型重新生成参数;支付、删除、发邮件等副作用工具,不应自动使用不确定的“修复后参数”执行。

还要区分模型响应的终止原因:达到输出上限导致的截断、内容安全拒答、模型服务错误,都不是普通的 JSON 解析错误。截断应增加预算或重新请求;拒答应走安全兜底;服务错误应走传输层重试。

还要区分模型响应的终止原因:达到输出上限导致的截断、内容安全拒答、模型服务错误,都不是普通的 JSON 解析错误。截断应增加预算或重新请求;拒答应走安全兜底;服务错误应走传输层重试。

不建议默认使用“万能 JSON 修复器”:它可能把错误的金额、日期或收件人修成一个看似合法但实际危险的值。若确实要使用 repair library,应只对低风险、无副作用的工具启用,并保留原始输入、修复结果和审计记录。

4.2 必填参数缺失 ​

缺字段有两种完全不同的原因:

  • 用户没有提供信息:例如“帮我查订单”没有订单号;正确动作是追问用户。
  • 用户提供了信息,但模型没有填入:例如历史里已有订单号,工具 Schema 或 prompt 写得不清;可以把校验错误回传给模型,让它从上下文补齐。

应用不要替模型猜关键参数。可以把错误返回成:

json
{
  "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 工具执行失败 ​

工具错误要有机器可读的分类,不要只返回一段“失败了”:

json
{
  "ok": false,
  "error": {
    "code": "UPSTREAM_RATE_LIMITED",
    "message": "天气服务暂时限流,请稍后重试",
    "retryable": true,
    "retry_after_ms": 800
  }
}

模型可以据此决定等待、换工具、降低范围或告诉用户;真正的重试计时和次数仍由应用控制,不能交给模型自由循环。

5. 一套可落地的 Agent 状态机 ​

把 Function Calling 看成状态机,比把它写成递归 prompt 更容易控制:

text
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回传:

text
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 指数退避与抖动 ​

常用等待时间:

text
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、幂等读请求。

一个好的错误对象会同时告诉应用和模型不同的信息:

json
{
  "ok": false,
  "error": {
    "code": "TIMEOUT",
    "message": "上游响应超时",
    "retryable": true,
    "safe_to_retry": false,
    "user_action": "稍后重试"
  }
}

retryable=true 表示“错误类别理论上可恢复”;safe_to_retry=false 表示“本次请求是否可能已经在下游生效尚不确定”,这时应先查询结果或使用幂等键,不能直接重复扣款。

6.4 防止无限循环 ​

不能只依赖 prompt 中的“不要无限调用”。应用必须硬编码终止条件,并检测下面的模式:

python
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,而在边界顺序。

python
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_use block,后续用 tool_result;失败时设置 is_error: true。
  • Gemini:按 SDK 的 functionCall / functionResponse 结构回传。

8. 生产落地的五个关键组件 ​

8.1 Provider Adapter:统一协议,不统一细节 ​

建议内部定义一个中间模型:

python
@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 | None

Adapter 负责处理字段差异、流式 delta 拼接、finish reason、拒答和原始响应保存;dispatcher 只依赖 NormalizedToolCall,不在业务代码里到处写 if provider == ...。

8.2 Tool Registry:工具不是一张函数字典 ​

每个工具注册项至少应包含:

text
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 都是不可信的。应用应从登录态、会话和服务端上下文注入这些信息;工具的真实签名可以不把它们暴露给模型:

text
模型只提供:order_id
应用执行:get_order_status(order_id, user_id=current_user, tenant=current_tenant)

危险工具采用两阶段:

text
plan / preview → 展示影响范围与参数 → 用户确认 → apply / commit

8.4 Retry Budget:重试是预算,不是 while True ​

为每个请求分配:

  • LLM 重试次数;
  • 参数修复次数;
  • 单工具网络重试次数;
  • 总墙钟时间;
  • 最大 token / 费用;
  • 最大副作用次数。

预算要在 trace 中可见,超过预算的降级原因也要可观测。

8.5 Fallback:降级要有层次 ​

一个可用的降级链路通常是:

text
主工具实时查询
  → 同域备用工具/缓存
  → 只读知识库或最近一次成功结果(标注时间)
  → 明确告知暂不可用
  → 高风险场景转人工

不要在实时工具失败后让模型凭训练记忆“估一个答案”,尤其是库存、余额、价格、权限和医疗信息。

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 副作用的幂等与审计 ​

对创建订单、退款、发邮件等动作:

  1. 应用生成稳定的幂等键(同一逻辑操作重试保持不变);
  2. 下游先查询幂等键是否已完成;
  3. 用户确认的内容和最终执行参数做哈希并记录;
  4. 记录操作者、工具版本、参数摘要、结果、时间和 trace_id;
  5. 对部分成功使用 outbox、事务消息或补偿流程。

10. 评测与可观测性:不要只看最终答案 ​

10.1 离线评测集 ​

至少覆盖这些样本:

  • 应该直接回答,不应调用工具;
  • 应该调用工具,且只有一个工具匹配;
  • 多个工具都可能匹配,需要看描述边界;
  • 缺少必填信息,必须追问;
  • 同义词、中文日期、单位、枚举和边界值;
  • 恶意 prompt injection、越权和高风险动作;
  • 工具返回错误、超时、空结果和部分结果。

10.2 推荐指标 ​

指标含义
Tool selection accuracy工具是否选对
Argument validity rateJSON + Schema 是否通过
Semantic argument accuracyID、日期、单位等业务值是否正确
Tool execution success下游是否成功
Error recovery rate发生错误后最终完成的比例
Clarification precision该追问时是否追问,能否避免猜测
Side-effect safety rate未确认/越权/重复副作用的拦截率
Loop rounds / repeated-call rate是否出现无效循环
TTFT、p95、token、cost性能和成本

10.3 一条请求应留下什么 trace ​

json
{
  "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。

参考资料(以官方文档为主) ​

供应商字段和模型能力会持续演进。面试时讲清楚协议和工程原则;项目上线前再按所选模型、SDK 版本和数据合规要求核对最新文档。