Interview Bank

From Frontend Engineer to Agent Engineer in 30 Days

D2 How Tool Calling Works: JSON Schema, the tool_use Loop; Hand-Writing an Agent Loop With No Framework

• Walk me through the complete function calling flow.function calling 的完整流程是怎样的？

  Common in ChinaCommon overseasBasic#tool-calling#agent-loop

  How to reason about it · think before answering

  1. The word 'complete' is the hinge. Most candidates stop at 'the model returns a tool_call, I run it, I hand back the result' and drop both ends: how the tool definitions get into the request, and what makes the loop continue after the result goes back. They want a closed loop, not a one-way call.
  2. Walk the lifecycle in five steps: send tools (name, description, JSON Schema parameters) with every request, since they are not remembered; the model replies with tool_calls and a finish reason of tool_calls; you parse arguments — a JSON string, not an object — and execute; you append the assistant message verbatim plus one tool-role message per tool call with matching tool_call_id; you send the now-longer messages again until the finish reason is no longer tool_calls.
  3. Land on the sentence that draws the security boundary: the model executes nothing. It emits a structured request, and execution, validation, authorization and auditing all live in your code. Since that request ultimately derives from user input, permissions and quotas can never be delegated to the model's good behavior.
  4. Volunteer the three most common 400s — dropping the assistant message that carried the tool_calls, answering only one of several parallel calls, and treating arguments as an object. Naming them shows you have shipped this.
  5. Expect the follow-up: do tools cost tokens forever? Yes — the tool list is re-sent every turn, so ten tools is one to two thousand tokens multiplied by the number of steps. Trim the tool set per scenario instead of registering everything.
  6. Second follow-up: what if the model calls a tool that does not exist? Do not throw. Return 'no such tool, pick one from the list' as an ordinary tool message and the model usually corrects itself on the next turn.

  分析过程 · 先想清楚再作答

  1. 题眼在「完整」两个字。大多数人答到「模型返回一个 tool_call、我执行、把结果给它」就停了，漏掉了两头——工具定义是怎么进到请求里的，以及结果回填之后循环凭什么继续。判据是你能不能把它讲成一个闭环，而不是一次单向调用。
  2. 顺着一次请求的生命周期走五步：第一步把 tools（name、description、JSON Schema 参数）一起放进请求，注意它每一轮都要重发；第二步模型返回 tool_calls，同时停止原因是 tool_calls；第三步你解析 arguments 并执行——arguments 是一段 JSON 文本而不是对象，要再解析一次；第四步把模型那条 assistant 消息原样追加回历史，再为每一个 tool_call 追加一条 role 为 tool 的消息，tool_call_id 逐个对上；第五步带着变长的 messages 再发一次，直到停止原因不再是 tool_calls。
  3. 结论要落到一句能划安全边界的话：模型不执行任何东西，它只输出一个结构化的「请求」，真正执行、校验、鉴权、审计的全是你的代码。而这个请求的内容归根结底来自用户输入，所以权限和额度绝不能指望模型自觉。
  4. 主动说三个最高频的 400，能立刻证明你真写过：漏掉模型那条带 tool_calls 的 assistant 消息、并行调用只回了一条 tool 消息、把 arguments 当对象直接取字段。
  5. 可以预期的追问：工具会不会一直占 token？会——tools 每一轮都要重发，十个工具一两千 token 再乘以循环步数，所以工具集要按场景动态裁剪，不是接得越多越好。
  6. 第二个追问：模型请求了一个不存在的工具怎么办？不要抛异常，把「没有这个工具，请从工具列表里重新选」当成一条正常的 tool 消息回传，模型通常下一轮就自己纠正了。

  Key points

  • Send the tool definitions (name, description, JSON Schema parameters) on every request — they are not remembered
  • The model returns tool_calls with a finish reason of tool_calls; arguments is a JSON string that needs a second parse
  • Append the assistant message verbatim, then one tool-role message per call with a matching tool_call_id
  • Send the longer message list again until the finish reason changes — that loop is what makes it an agent
  • The model only requests; execution, validation, authorization and auditing stay in your code

  答题要点

  • 请求里带上 tools 定义（name、description、JSON Schema 参数），每一轮都要重发
  • 模型返回 tool_calls，停止原因为 tool_calls；arguments 是 JSON 字符串，需要再解析一次
  • 先把模型那条 assistant 消息原样追加回 messages，再为每个 tool_call 追加一条 role 为 tool 的消息，tool_call_id 一一对应
  • 带着变长的 messages 继续下一轮，直到停止原因不再是 tool_calls，这才构成闭环
  • 模型只发出请求，执行、校验、鉴权、审计全在你的代码里
• What is the ReAct pattern, and how does it relate to a hand-rolled tool-calling loop?什么是 ReAct 模式？它和你手写的工具调用循环是什么关系？

  Common in ChinaCommon overseasIntermediate#react#agent-loop#tool-calling

  How to reason about it · think before answering

  1. The trap is answering with a definition. What separates candidates is whether you can say that ReAct and the while loop you wrote are the same thing rather than two parallel technologies.
  2. Give the history first: when ReAct appeared, model APIs had no tool field. The trick was a prompt-level convention — the model emitted Thought, Action and Action Input as plain text, you regex-extracted the action, ran it, and pasted the Observation back into the prompt.
  3. Then map it, which is where the points are: function calling froze that convention into the protocol. Thought became message.content, Action became structured tool_calls, Observation became the tool-role message you append. ReAct is the name of your loop, not an alternative to it.
  4. State the trade-off: the text version is brittle at the parsing layer — a missing newline, JSON where plain text was expected, or a reordered Thought and Action all break the regex. Structured tool calls hand that problem to the server, which is why they are the default today. The text version is still alive though: local small models and older endpoints without a tools field leave you no other option, and you own the parse failure rate.
  5. Expect: should the model write its Thought out loud? It costs tokens, but accuracy on multi-step tasks usually improves and your logs finally become readable. Treat it as a dial, not a requirement.
  6. Second follow-up: ReAct versus plan-and-execute? ReAct re-decides at every step, which suits environments that change or information you have to gather as you go; plan-and-execute commits to a full plan up front, giving predictable step counts and cost but reacting poorly to surprises. Production systems often nest them: a coarse plan on the outside, a ReAct loop inside each step.

  分析过程 · 先想清楚再作答

  1. 这题最容易答成名词解释。区分度在于你能不能指出 ReAct 和那个 while 循环是同一个东西，而不是两套并列的技术——把它们说成两样，面试官会认为你只读过博客没写过代码。
  2. 先给历史脉络：ReAct 出现时模型接口还没有工具字段，做法是在提示词里跟模型约定一套纯文本格式，让它交替吐出 Thought、Action、Action Input，你用正则把动作抠出来执行，再把 Observation 拼回提示词里继续。
  3. 再做映射，这是拿分的一步：今天的 function calling 把这套口头约定固化成了协议——Thought 对应 message.content，Action 对应结构化的 tool_calls，Observation 对应你追加回去的那条 role 为 tool 的消息。所以 ReAct 是那个循环的名字，不是另一种实现。
  4. 把取舍说出来：文本版脆在解析，模型少写一个换行、把参数写成 JSON、把 Action 和 Thought 换个顺序，正则就崩；结构化版把这个包袱交给了服务端，是今天的默认选择。但文本版没死——本地小模型、老接口不支持 tools 字段时，回退到「提示词约定 + 正则」仍是唯一可行的兜底，代价是解析失败率自己扛。
  5. 可以预期的追问：要不要让模型显式写出 Thought？它多花 token，但复杂任务的准确率通常更好，日志也终于可读。这是一个可调旋钮，不是必选项，按任务复杂度决定。
  6. 第二个追问：ReAct 和先规划后执行（Plan-and-Execute）有什么区别？ReAct 每一步都重新决策，边走边看，适合环境会变、信息要边查边补的任务；先规划后执行一次性出完整计划，步数和成本更可控，但对中途出现的意外不敏感。真实系统常常混用：先出一个粗计划，每一步内部再走 ReAct。

  Key points

  • ReAct is Reasoning plus Acting: the model alternates thinking and acting, observing each result before deciding the next step
  • The original form was a prompt convention parsed by regex; function calling froze that convention into the API protocol
  • The three words map to code: Thought is message.content, Action is tool_calls, Observation is the tool-role message you append
  • Structured calls remove the parsing burden but require model support; without it you fall back to text ReAct and own the failure rate
  • Versus plan-and-execute, ReAct adapts better to change but has less predictable step count and cost

  答题要点

  • ReAct 是 Reasoning 加 Acting，让模型交替进行推理与行动，观察结果后再决定下一步
  • 原始形态靠提示词约定纯文本格式加正则解析；function calling 把这套约定固化进了 API 协议
  • 三步一一对应代码：Thought 是 message.content，Action 是 tool_calls，Observation 是回填的 role 为 tool 的消息
  • 结构化调用的好处是不用自己解析，代价是依赖模型支持 tools 字段；不支持时只能回退到文本版并自担解析失败率
  • 与先规划后执行相比，ReAct 每步重新决策、更适应变化，但步数与成本不如前者可控
• When a tool fails, how should the error reach the model — and what must never reach it?工具执行报错时，应该怎么把错误信息传给模型？有没有不该传的？

  Common in ChinaCommon overseasIntermediate#tool-calling#error-handling

  How to reason about it · think before answering

  1. The second half is the discriminator. 'Catch it, log it, return an error' is ordinary backend thinking; the insight they want is that inside an agent loop an error is feedback to the model, not a failure notification.
  2. Classify first, with one test: can the model fix this? Malformed arguments, a missing required field, a value outside the enum, a unit that should not be there — the model can fix those, so return them, and spell out what correct looks like or it will simply fail differently next time. A database that is down, a 5xx from a downstream service, an expired credential — no amount of re-prompting helps, so code decides whether to retry or abort.
  3. Then the mechanics: a returnable error becomes an ordinary tool-role message with the matching tool_call_id, not an exception that unwinds the loop. Throwing gives the user a 500; returning usually gets the model to correct itself on the very next turn, which is the cheapest reliability you will ever buy.
  4. Now the 'never' half: never hand back a raw stack trace. It carries file paths, internal service names and sometimes connection strings, it enters the next request verbatim, the model may recite it to the user, and it costs a thousand tokens re-sent every turn. Send a sentence you wrote; keep the stack in your logs.
  5. Expect: what if the model never gets it right? Failed calls still count against the step budget, and hitting the cap should end the run with an honest message. Going further, a tool that fails N times in a row can be dropped from the available set for that run, forcing a different route.
  6. Second follow-up: is this the same as provider fallback? Two sides of one judgment. There you ask whether another provider could plausibly succeed; here you ask whether the model could plausibly fix it. Blanket retry is wrong in both places.

  分析过程 · 先想清楚再作答

  1. 题眼在后半句。只答「catch 住、打日志、返回错误」是普通后端思维，答不出「在 Agent 里错误是给模型的反馈」就拿不到区分度分。
  2. 先分类，判据是一句话：这个错误模型改得动吗？参数格式不对、缺了必填项、值不在枚举里、单位没去掉——模型改得动，回传，并且要把「正确的样子」写进错误文案，否则它只会换个花样再错一次。反过来，数据库连不上、下游服务 500、凭证过期，模型改一万遍参数也没用，这类该由代码决定重试还是终止，回传只是让它空转烧钱。
  3. 结论落到形式上：值得回传的错误要变成一条正常的 role 为 tool 的消息，tool_call_id 照样对上，而不是抛异常终止循环。抛了用户看到 500；回传了模型往往下一轮就自己改对，这是 Agent 稳定性最便宜的一份来源。
  4. 接着答「不该传的」：绝不回传原始异常堆栈。堆栈里有文件路径、内部服务名，有时还有连接串，它会原封不动进入下一次请求，也可能被模型复述给用户；而且动辄上千 token，每一轮都跟着历史重发。回给模型的必须是你自己写的一句话，原始堆栈只进日志。
  5. 可以预期的追问：模型一直改不对怎么办？错误也要计入步数，撞上步数上限就终止并给用户一句交代；再进一步，同一个工具连续失败若干次可以直接把它从这一轮的可用工具里摘掉，逼模型换条路。
  6. 第二个追问：这和模型层的 fallback 是一回事吗？是同一套判断的两侧——那边问「换一家 provider 有没有可能变好」，这边问「让模型改一改有没有可能变好」，都是先分类再决定重试，一刀切重试在两边都是错的。

  Key points

  • Classify first: only model-fixable errors (bad arguments, missing fields, enum violations) are worth returning; infrastructure failures are the code's decision
  • Return it as an ordinary tool-role message with the matching tool_call_id, not as an exception that kills the loop
  • Write what correct looks like into the message, otherwise the model just fails a different way
  • Never return raw stack traces: internal paths leak into the next request and to users, and they burn a thousand tokens every turn
  • Failed calls count against the step budget, and a repeatedly failing tool can be removed from the available set

  答题要点

  • 先分类：模型改得动的错误（参数格式、缺字段、枚举越界）才值得回传，外部故障应由代码决定重试或终止
  • 回传的形式是一条正常的 role 为 tool 的消息，tool_call_id 照常对应，而不是抛异常中断循环
  • 错误文案里要写清「正确的样子」，模型才知道该怎么改，否则它只会换个花样再错一次
  • 绝不回传原始异常堆栈：内部路径与服务名会进入下一次请求、可能被复述给用户，还白白吃掉上千 token
  • 报错同样计入步数上限；同一工具连续失败可以临时摘掉，避免模型在原地打转

D5 The Tool System and Event-Driven Design: Parameter Validation, Feeding Errors Back for Self-Correction, Event Subscription (dg P05/P06/M05/M07)

• When a tool call fails validation or errors out, how do you get the model to correct itself instead of failing the whole turn?工具调用报错或参数非法时，你怎么让模型自己纠正而不是直接失败？

  Common in ChinaCommon overseasIntermediate#tool-calling#error-handling

  How to reason about it · think before answering

  1. This checks whether you have actually built a tool loop. 'Tell the model about the error' is the passing grade; the discriminators are what the error text looks like and whether you put brakes on the loop.
  2. State the mechanism in one line: an error is data, not an exception. On success you append the result as a tool message and continue the loop; on failure you take the same path with error text as the content. Throwing all the way out and killing the turn is the common mistake.
  3. Give the quality bar: a good error names the field, states the expectation, and shows one valid example. Compare three tiers — 'tool failed' leaves the model to retry blindly or give up; 'order_id has the wrong format' tells it where but not what, so it may invent a new wrong form; 'order_id must be SO plus 8 digits, e.g. SO20260901, you sent the number 12345' usually gets fixed in one shot. Also report every validation error at once; returning on the first one costs extra round trips.
  4. Volunteer the cost, which is what they are waiting for: one self-correction adds two messages and a full model call, doubling latency and tokens. Worse is the infinite loop when the error text is vague. So set three brakes — stop after two consecutive failures of the same tool and hand off to a human, cap total tool calls per turn, and cap the token budget per turn.
  5. Draw the boundary, which shares its logic with the D4 fallback rule: the test is whether changing arguments could plausibly help. Validation failures, 'order not found', 'date out of range' — feed back. Database unreachable, downstream 503, expired key — no argument change will help, so fail loudly and alert instead of letting the model flail.
  6. Expect the follow-up: what may go into the error text? Field names, expected formats and examples only. Stack traces, SQL, internal paths and real table names must never reach the model, because it will repeat them to the user.

  分析过程 · 先想清楚再作答

  1. 这题在考你有没有真的做过工具循环。只答「把错误告诉模型」是及格线，区分度在两个地方：错误信息长什么样，以及你有没有给它设刹车。
  2. 先给机制，一句话就能说清：错误不是异常，是数据。工具成功时你把结果包成一条 tool 消息追加进 messages 再继续循环，失败时走同一条路，只是内容换成错误描述。异常一路抛出、终止这一轮，是最常见的错误做法。
  3. 再给判据：好错误信息有三个要素——错在哪个字段、期望是什么、一个合法示例。对比三档就很清楚：「工具执行失败」模型只能原样重试或放弃；「order_id 格式不正确」它知道错在哪却不知道对的长什么样，可能试出一个新错法；「参数 order_id 需要 SO 开头加 8 位数字，例如 SO20260901，你传的是数字 12345」基本一次改对。另外校验要一次报全部错误，报了第一条就返回会让模型多跑好几轮。
  4. 然后主动说代价，这是面试官等的：一次自纠错等于多两条消息加一次完整的模型调用，延迟和 token 都翻倍；更凶的是死循环——错误信息含糊时模型会以近乎相同的方式反复重试。所以必须设三道闸：单工具连续失败 2 次就停手转人工、整轮工具调用总次数上限、整轮 token 预算，哪个先到都终止。
  5. 最后划一条边界，它和 D4 的 fallback 判据同源：判断依据是「模型改参数有没有可能变好」。校验失败、订单不存在、日期超范围——回传。数据库连不上、下游 503、密钥过期——模型改一百遍参数也没用，应该直接失败并告警，回传只会让它朝错误方向瞎试。
  6. 可以预期的追问：回传的错误信息里能放什么？只能放字段名、期望格式和示例；栈信息、SQL、内部路径、真实表名一律不能进，因为模型会把它复述给用户。

  Key points

  • An error is data: append it as a tool message on the same path as a successful result so the model sees it next turn
  • A good error names the field, states the expectation and shows a valid example; report all validation errors at once
  • Self-correction is not free — two extra messages plus a full model call double latency and tokens
  • Set three brakes: hand off after two consecutive failures of one tool, cap tool calls per turn, cap the token budget
  • The test is whether changing arguments could help: feed back validation errors, but fail loudly on unreachable databases or downstream 503s
  • Never put stack traces, SQL or internal paths into text the model will read

  答题要点

  • 错误不是异常是数据：把它包成一条 tool 消息追加进 messages，和成功结果走同一条路，模型下一轮就能看到
  • 好错误信息三要素：错在哪个字段、期望是什么、给一个合法示例；校验要一次报全部错误
  • 自纠错不免费：多两条消息加一次模型调用，延迟和 token 翻倍
  • 必须设三道闸：单工具连续失败 2 次转人工、整轮工具调用总次数上限、整轮 token 预算
  • 判据是「模型改参数有没有可能变好」：校验失败该回传，数据库连不上、下游 503 该直接失败并告警
  • 回传文本只能有字段名、期望格式和示例，不能带栈信息、SQL 和内部路径

D23 MCP and Skills: the Protocol, Server/Client, How It Differs From Function Calling; a Tour of the Claude Agent SDK

• What problem does MCP solve, and how is it different from function calling?MCP 协议解决了什么问题？它和 function calling 有什么区别？

  Common in ChinaCommon overseasBasic#mcp#tool-calling#protocol

  How to reason about it · think before answering

  1. This question has a canonical wrong answer that interviewers screen on: calling MCP 'function calling v2' or saying you no longer need function calling. Say that and the rest of your answer cannot recover the points.
  2. Put each one back on its own hop and the confusion disappears: function calling is the contract between the model and your program; MCP is the contract between your program and a capability provider. Different hops, so they stack — they do not replace each other.
  3. Offer a one-line proof: every tool returned by an MCP server's tools/list carries an inputSchema that is already plain JSON Schema, and all you do is copy it into the parameters field of a function-calling tool definition. The model never learns MCP exists, and adopting MCP removes not a single line of your function-calling code.
  4. Then answer what it actually solves: integration cost goes from multiplication to addition. N hosts times M capabilities means N times M integrations; a shared protocol makes it N plus M. It also draws a responsibility boundary — a third-party capability failing is no longer something you must first reproduce inside your own service.
  5. Volunteer the Skills distinction, since it is the natural follow-up: MCP extends what the agent can do (new callable actions), Skills extend how well it does it (a bundle of prompt, scripts and reference material, loaded on demand). One adds capability, the other adds method.
  6. Expect the follow-up: then where is MCP's value? In standardizing discovery and invocation, so capabilities can be owned by another team, reused by several hosts, and added or removed without a code change — while the hop to the model stays function calling.

  分析过程 · 先想清楚再作答

  1. 这题有一个标准的错误答案，面试官就是靠它筛人：把 MCP 说成「function calling 的升级版」「以后不用写 function calling 了」。说出这句，后面讲得再多也已经扣完分了。
  2. 把两者放回各自的链路上就不会混：function calling 是「模型 ↔ 你的程序」之间的约定，MCP 是「你的程序 ↔ 能力提供方」之间的约定。它们不在同一段线上，所以是上下游，不是替代。
  3. 给一个能一句话验证的证据：MCP server 通过 tools/list 返回的每个工具，它的 inputSchema 本身就是 JSON Schema，你要做的只是把它搬进 function calling 的 parameters 字段发给模型。模型自始至终不知道 MCP 存在。接了 MCP 之后 function calling 那段代码一行都不会少。
  4. 再答「解决了什么问题」：接入成本从乘法变加法。N 个宿主乘 M 个能力等于 N 乘 M 份接入代码，有了协议就变成 N 加 M；顺带把责任边界划清楚了，第三方能力出问题不用先在你的服务里复现。
  5. 顺手把 Skills 也区分掉，这是很自然的追问：MCP 扩展的是「能做什么」（新增可调用的动作），Skills 扩展的是「怎么做得好」（一组提示词、脚本和参考资料打成的按需加载包）。一个给能力，一个给方法论。
  6. 可以预期的追问：那 MCP 的价值到底在哪？答案是它把「能力的发现与调用」标准化了，所以能力可以由别人维护、被多个宿主复用、不改代码就增删——但发给模型的那一段，永远还是 function calling。

  Key points

  • Function calling is the model-to-your-program contract; MCP is the your-program-to-provider contract — they stack rather than replace
  • Every MCP tool still gets translated into a function-calling JSON Schema before it reaches the model, which never learns MCP exists
  • It solves integration cost: N hosts times M capabilities becomes N plus M, and the process boundary becomes the ownership boundary
  • Calling MCP an upgraded function calling is the classic wrong answer — naming that yourself scores points
  • Distinguish Skills too: MCP extends what the agent can do, Skills extend how well it does it

  答题要点

  • function calling 是「模型和你的程序」之间的约定，MCP 是「你的程序和能力提供方」之间的约定，两者是上下游不是替代
  • MCP server 列出的每个工具最终仍要翻译成 function calling 的 JSON Schema 发给模型，模型不知道 MCP 存在
  • 它解决的是接入成本：N 个宿主乘 M 个能力的乘法，变成 N 加 M 的加法，同时把责任边界划到进程边界上
  • 把 MCP 说成 function calling 的升级版是最常见的错误答案，主动点破这一点会加分
  • 顺带区分 Skills：MCP 扩展「能做什么」，Skills 扩展「怎么做得好」