面试题库

30 天从前端工程师到 Agent 工程师

D1 LLM API 基础：messages/roles、token、流式、temperature；Agent 到底是什么

• 流式回复到一半网络断了，前端和后端各要做什么？EventSource 的自动重连能用上吗？A streaming reply is cut off mid-way. What do the client and server each do, and can EventSource auto-reconnect help?

  国内高频海外高频进阶#streaming#reliability#sse

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

  1. 这题的陷阱在后半句。很多人背过「SSE 自带重连」，就直接答自动重连能救——那是错的，必须先分清两种 SSE 用法。
  2. 浏览器原生 EventSource 确实按规范自动重连：重连时带 Last-Event-ID 请求头，服务器用 id: 打点、用 retry: 设间隔；但它只能发 GET，且要求响应 Content-Type 是 text/event-stream。
  3. 而 LLM chat API 必须 POST（messages 要放在请求体里），所以实际用的是 fetch 加手写 SSE 解析——EventSource 那套自动重连一行都用不上。
  4. 于是前端职责变成：自己判定断流、自己重试、自己保存已收到的部分。后端职责是让重试是安全的——响应可续、副作用幂等。
  5. 给出续写策略并说清边界：把已收到的内容作为上下文构造续写请求；但工具调用块和思考块无法部分恢复，只能从最近的完整文本块续。
  6. 可预期追问：非 200 响应会重连吗？按规范不会——状态码不是 200 或 Content-Type 不对，连接直接判定失败；服务器还可以用 204 主动叫停重连。

  How to reason about it · think before answering

  1. The trap is the second half: people who memorized 'SSE reconnects automatically' answer yes, which is wrong.
  2. Native EventSource does auto-reconnect per spec, sending Last-Event-ID, with the server marking events via id: and setting the interval via retry: — but it only issues GET and requires Content-Type text/event-stream.
  3. LLM chat APIs require POST because messages go in the body, so real clients use fetch plus hand-written SSE parsing, where none of that machinery applies.
  4. So the client owns detection, retry and buffering of what arrived; the server's job is making retries safe — resumable output and idempotent side effects.
  5. Give the continuation strategy and its limits: feed the received prefix back as context, but tool-use and thinking blocks cannot be partially recovered — resume from the last complete text block.
  6. Follow-up to expect: does a non-200 reconnect? Per spec no — a non-200 status or wrong Content-Type fails the connection, and a 204 tells the browser to stop reconnecting.

  答题要点

  • 先区分两种 SSE：浏览器原生 EventSource 自动重连并带 Last-Event-ID，但只能 GET；LLM API 走 POST，用不上这套
  • 所以前端要自己检测断流、自己重试，并保留已收到的部分内容
  • 续写策略：把已收到的内容作为上下文发起新请求，让模型接着写，而不是整轮重来
  • 边界：tool_use 和 thinking 块无法部分恢复，只能从最近的完整文本块续
  • 后端要保证重试安全：响应可续、工具副作用幂等，并对已产生的用量正确计费

  Key points

  • Separate the two SSE modes: native EventSource auto-reconnects with Last-Event-ID but is GET-only; LLM APIs use POST and cannot rely on it
  • The client must therefore detect the break, retry itself, and keep whatever text already arrived
  • Continuation: send the received prefix as context so the model resumes rather than restarting the turn
  • Limits: tool_use and thinking blocks cannot be partially recovered; resume from the last complete text block
  • The server must make retries safe: resumable responses, idempotent tool side effects, correct billing for tokens already produced
• 用户切到后台或者直接关掉网页，回来后怎么恢复那条还在生成的回复？The user backgrounds the app or closes the tab. How do you restore a reply that was still being generated?

  国内高频海外高频深入#streaming#reliability#architecture

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

  1. 先识别这题和「网络断了」不是同一个问题：客户端已经不存在了，任何写在前端的重试逻辑都不会执行。
  2. 由此推出唯一出路：生成过程必须能脱离这个客户端独立存活，也就是把流本身放到服务端持久化。
  3. 落到具体架构：发起请求时给这轮生成分配一个流 id，服务端一边把 token 推给当前连接，一边把同样的内容写进 Redis 之类的存储；会话记录里保存这个 activeStreamId。
  4. 恢复路径是另开一个 GET 端点：客户端带着会话 id 请求，服务端按 activeStreamId 找到那条流并接着推；找不到活跃流就返回 204，让前端知道没有需要恢复的东西。
  5. 说清代价，别只说方案：多了一份存储、一套过期清理、以及「同一条流可能被多个连接消费」的并发问题。
  6. 延伸：这套结构和普通聊天产品的「消息已持久化，重进会话直接读库」不同——区别在于回复还在生成中，需要的是可续的流而不是一条静态记录。

  How to reason about it · think before answering

  1. First separate this from a dropped connection: the client is gone, so no client-side retry will ever run.
  2. That leaves one option — the generation must outlive the client, which means persisting the stream server-side.
  3. Concretely: assign a stream id per generation; the server pushes tokens to the live connection while also writing them to storage such as Redis, and the chat record stores that activeStreamId.
  4. Recovery is a separate GET endpoint: the client asks with the chat id, the server locates the stream by activeStreamId and resumes; with no active stream it returns 204.
  5. Name the costs, not just the design: extra storage, expiry/cleanup, and concurrency when several connections consume the same stream.
  6. Extension: this differs from ordinary message persistence because the reply is still being produced — you need a resumable stream, not a static row.

  答题要点

  • 客户端已经不在了，前端重试无从谈起，必须让生成过程在服务端独立存活
  • 发起生成时分配流 id，服务端边推送边把内容写进 Redis，会话里记录 activeStreamId
  • 恢复走单独的 GET 端点：按会话 id 找到活跃流接着推，没有活跃流就返回 204
  • 代价：额外存储、过期清理，以及同一条流被多个连接消费的并发处理
  • 与「消息持久化后重新读库」的区别在于回复仍在生成中，需要的是可续的流

  Key points

  • The client is gone, so recovery must live server-side: the generation has to outlive the connection
  • Assign a stream id at start; the server writes tokens to Redis while streaming, and the chat stores activeStreamId
  • Resume through a dedicated GET endpoint that replays the active stream, returning 204 when there is none
  • Costs: extra storage, expiry and cleanup, and concurrent consumers of one stream
  • It differs from plain message persistence because the reply is still in flight, so you need a resumable stream
• 断线重试之后，怎么保证不重复计费、也不重复执行已经做过的工具调用？After a retry, how do you avoid double billing and re-executing tool calls that already ran?

  国内高频海外高频深入#reliability#tools#idempotency

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

  1. 先把问题拆成两半：计费是「记录问题」，工具副作用是「执行问题」，两者的解法不同，混在一起答会含糊。
  2. 计费侧：用量应该在服务端按实际收到的 token 记账，而不是按「请求次数」。断在中途已经产生的 token 是真实成本，要照记；重试产生的是新成本，也要照记——关键是别把同一批 token 记两遍。
  3. 为此需要一个稳定的标识：给每轮生成一个 run id，用量记录以 run id + 序号去重，重放同一段不会重复入账。
  4. 工具侧：真正危险的是有副作用的工具（转账、发消息、下单）。解法是幂等键——由调用参数派生一个稳定的 key，执行前先查这个 key 是否已有结果，有就直接返回旧结果。
  5. 补一层状态机视角：把每次工具调用记为「待执行 / 执行中 / 已完成」，重试时只重放未完成的部分，已完成的直接取结果，这也是恢复中断任务的通用做法。
  6. 常见追问：幂等键该谁生成？应由客户端或调度侧生成并随请求传递，服务端自己生成就没法跨重试保持一致。

  How to reason about it · think before answering

  1. Split it in two: billing is a bookkeeping problem, tool side effects are an execution problem, and they have different fixes.
  2. Billing: meter server-side by tokens actually produced, not by request count. Tokens produced before the break are real cost; so are retry tokens. The point is not to count the same batch twice.
  3. That needs a stable identifier: give each generation a run id and dedupe usage records by run id plus sequence.
  4. Tools: the danger is side-effecting tools — transfers, messages, orders. The fix is an idempotency key derived from the call arguments, checked before execution.
  5. Add the state-machine view: record each call as pending / running / done and replay only what is unfinished.
  6. Follow-up: who generates the idempotency key? The caller must, and pass it along — a server-generated key cannot stay stable across retries.

  答题要点

  • 拆成两个问题：计费是记账问题，工具副作用是执行问题，解法不同
  • 计费按服务端实际产生的 token 记，用 run id 加序号去重，避免同一批 token 重复入账
  • 有副作用的工具用幂等键：由调用参数派生稳定 key，执行前先查是否已有结果
  • 把每次工具调用记成待执行/执行中/已完成的状态机，重试只重放未完成的部分
  • 幂等键要由调用方生成并随请求传递，服务端自行生成无法跨重试保持一致

  Key points

  • Separate billing (bookkeeping) from tool side effects (execution); they need different mechanisms
  • Meter by tokens actually produced, deduped by run id plus sequence so one batch is never counted twice
  • Guard side-effecting tools with an idempotency key derived from the call arguments
  • Model each tool call as pending / running / done and replay only unfinished work
  • The caller must generate and pass the idempotency key so it stays stable across retries
• 移动端 App 里的对话，网络频繁抖动，你会怎么设计重连策略？On mobile, connectivity is flaky. How would you design the reconnection strategy for a chat feature?

  国内高频海外高频进阶#reliability#mobile#streaming

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

  1. 先说明移动端和浏览器的差别：网络在 WiFi 与蜂窝之间切换、App 会被系统挂起、后台执行时间受限，所以不能照搬网页那套。
  2. 重试节奏用指数退避加随机抖动。抖动这一条常被忽略，但它是防止大面积断网恢复后所有客户端同时涌上来把服务打垮的关键。
  3. 要设上限：最大重试次数与最大退避间隔，超过就转成显式的「重新加载」按钮交给用户，而不是无限静默重试。
  4. 区分「短暂抖动」和「真的没网」：监听系统的网络状态变化，没网时直接停止重试并进入离线态，等网络恢复事件再立刻重连，比盲目定时重试省电得多。
  5. 结合上一题的服务端持久化：App 被系统杀掉后重进，靠会话 id 请求恢复端点，而不是指望本地缓存拼出完整回复。
  6. 最后补发送侧：用户在离线时发出的消息进本地队列，恢复后按序重发，且每条带幂等键，避免重复发送。

  How to reason about it · think before answering

  1. Start with what makes mobile different: network switches between WiFi and cellular, the OS suspends apps, background time is limited.
  2. Use exponential backoff with jitter; jitter is the commonly missed part that prevents a thundering herd when a wide outage clears.
  3. Set ceilings: max attempts and max interval, then surface an explicit reload action instead of retrying silently forever.
  4. Distinguish a brief blip from being genuinely offline: subscribe to OS connectivity events, stop retrying when offline, and reconnect on the restore event — far cheaper on battery than blind timers.
  5. Combine with server-side persistence: after the OS kills the app, resume by chat id rather than reconstructing from local cache.
  6. Finally the send path: queue outgoing messages while offline and replay them in order, each with an idempotency key.

  答题要点

  • 移动端特殊性：WiFi 与蜂窝切换、App 被挂起、后台执行时间受限，不能照搬网页策略
  • 指数退避加随机抖动，抖动用于避免大面积恢复时的重连风暴
  • 设最大重试次数与最大间隔，超过后转为显式的重新加载入口，不做无限静默重试
  • 监听系统网络状态：离线直接停重试进入离线态，收到恢复事件再重连，比定时轮询省电
  • 回复恢复依赖服务端持久化，靠会话 id 请求恢复端点；发送侧用本地队列加幂等键按序重发

  Key points

  • Mobile differs: network handoffs, OS suspension, limited background time — do not copy the web strategy
  • Exponential backoff with jitter, where jitter prevents a reconnect storm when an outage clears
  • Cap attempts and interval, then hand the user an explicit reload instead of retrying forever
  • Listen to OS connectivity events: stop while offline, reconnect on restore, which saves battery over polling
  • Resume replies via server-side persistence by chat id; queue outgoing messages with idempotency keys
• 用户主动点「停止生成」和网络意外断开，在服务端看起来都是连接没了，怎么区分处理？A user pressing stop and a dropped connection both look like a closed connection server-side. How do you tell them apart?

  国内高频海外高频深入#streaming#reliability#ux

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

  1. 先点破为什么要区分：主动停止是「用户不想要了」，应当立即释放算力并结束这轮；意外断开是「用户还想要」，理应保留结果供恢复。处理反了，用户要么白花钱，要么回来发现内容没了。
  2. 所以不能只靠 TCP 连接状态判断——它对两种情况的表现是一样的。必须有一个显式信号。
  3. 做法是给「停止」单独一个接口：前端点停止时先调这个接口，带上 run id，服务端据此把该轮标记为「用户取消」，再中止上游模型调用。
  4. 而单纯的连接关闭一律按「意外断开」处理：继续把已生成内容落盘、保留可恢复的流，等客户端回来续。
  5. 补一个现实约束：停止请求本身也可能因为断网而发不出去。所以服务端还需要兜底——比如流没有任何消费者超过一定时间就自行结束，避免算力空转。
  6. 延伸到计费：两种情况都要为已经产生的 token 计费，因为上游厂商已经收了钱；区别只在于要不要保留结果和是否继续生成。

  How to reason about it · think before answering

  1. Say why it matters: stop means the user no longer wants the output, so free compute and end the run; a drop means they still want it, so preserve the result for resumption.
  2. Connection state alone cannot distinguish them — it looks identical — so you need an explicit signal.
  3. Give stop its own endpoint: the client calls it with the run id before closing, and the server marks the run as user-cancelled and aborts the upstream call.
  4. Treat a bare connection close as an unexpected drop: keep persisting output and hold the stream for resumption.
  5. Add the real-world caveat: the stop request itself may fail to send when the network is down, so the server needs a fallback — end a stream with no consumer after a timeout.
  6. Extend to billing: both cases still owe for tokens already produced, since the upstream provider has charged; they differ only in whether output is retained.

  答题要点

  • 两者语义相反：主动停止要立即释放算力并结束，意外断开要保留结果等待恢复
  • TCP 连接状态无法区分，必须有显式信号：给停止单独一个接口，带 run id 标记为用户取消
  • 只收到连接关闭一律按意外断开处理，继续落盘并保留可恢复的流
  • 兜底：停止请求本身也可能发不出去，服务端需对长时间无消费者的流自行结束
  • 计费上两者都要为已产生的 token 记账，区别只在于是否保留结果、是否继续生成

  Key points

  • The semantics are opposite: stop frees compute immediately, a drop preserves output for resumption
  • Connection state cannot distinguish them, so add an explicit stop endpoint carrying the run id
  • Treat a bare close as an unexpected drop: keep persisting and hold the stream for resume
  • Fallback: the stop call may itself fail to send, so end streams with no consumer after a timeout
  • Both still bill for tokens already produced; they differ only in retention and whether generation continues

D2 工具调用原理：JSON Schema、tool_use 循环；不用框架手写 Agent Loop

• 怎么防止 Agent 循环停不下来？只加一个最大步数够吗？How do you keep an agent loop from running forever — is a max-step counter enough?

  国内高频海外高频深入#agent-loop#reliability#cost

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

  1. 后半句是明摆着的陷阱。只答「加一个计数器」是及格线，面试官真正想听的是你知道计数器拦不住什么。
  2. 先解释它为什么会停不下来：停止原因一直是 tool_calls，通常是因为工具返回的东西没帮模型前进——结果为空、字段答非所问、错误文案没说清该怎么改，于是它换个参数一试再试。所以第一层其实不是护栏，是把工具的返回值和错误文案写得有信息量。
  3. 再给硬护栏，三条互补：步数上限最直接；token 与成本预算拦的是「步数不多但每步都很贵」；单轮的墙上时钟超时拦的是「一步就卡了两分钟」。只有步数上限的系统，照样会被一次超长上下文的调用打爆预算。
  4. 语义层面再加一条：检测重复调用。同一个工具、同一份参数连续出现两次以上，几乎可以断定它在原地打转，直接截断并把「你已经用完全相同的参数调过这个工具了，换个思路或者告诉用户你做不到」回传给模型，往往比等步数耗尽更快收敛。
  5. 触顶之后必须有交代：不能静默返回空字符串，要给用户一句能理解的话；同时把触顶记成一个指标，触顶率上升通常意味着某个工具的描述或返回值该改了，而不是把上限调大。
  6. 可以预期的追问：上限设多少？没有普适值。聊天类任务 5 到 10 步通常够，需要多轮检索的任务可以更高。正确做法是看线上的步数分布，取 p99 再留一点余量，而不是拍脑袋——上限设得越死，你的系统就越靠近固定流程那一端，越不像一个 Agent。

  How to reason about it · think before answering

  1. The second half is an open trap. 'Add a counter' is the passing grade; what they want is whether you know what a counter cannot catch.
  2. Explain why it runs away first: the finish reason stays tool_calls because the tool results are not moving the model forward — empty results, fields that do not answer the question, error text that never says what correct looks like. So the first line of defense is not a guard rail at all; it is writing tool results and error messages that carry information.
  3. Then three complementary hard limits: a step cap is the obvious one; a token and cost budget catches 'few steps, all of them expensive'; a per-step wall-clock timeout catches 'one call hung for two minutes'. A system with only a step cap can still blow its budget on a single enormous context.
  4. Add a semantic guard: detect repeats. The same tool with identical arguments twice in a row is almost always spinning. Cut it short and tell the model so — 'you already called this tool with exactly these arguments' — which usually converges faster than waiting for the counter to run out.
  5. Hitting the cap needs an honest ending: never return an empty string, give the user a sentence they can act on, and record cap hits as a metric. A rising cap-hit rate usually means a tool's description or return value needs fixing, not that the cap should be raised.
  6. Expect: what number do you pick? There is no universal one. Chat-style tasks usually fit in five to ten steps; retrieval-heavy tasks need more. Read the production distribution, take p99 plus headroom, and remember that the tighter the cap, the closer your system sits to a fixed workflow rather than an agent.

  答题要点

  • 根因通常是工具返回值或错误文案没信息量，模型无法前进只能反复重试，先把这层写好
  • 三条硬护栏互补：最大步数、token 与成本预算、单步墙上时钟超时，只有步数上限并不够
  • 语义护栏：同一工具加同一份参数连续重复调用即判定原地打转，截断并把这个事实回传给模型
  • 触顶要给用户一句交代，不能静默返回空；同时把触顶率当指标，上升说明工具该改而不是把上限调大
  • 上限值按线上步数分布取 p99 加余量；上限越死越接近固定流程，越不像 Agent

  Key points

  • The root cause is usually uninformative tool results or error text, so fix that layer before adding guards
  • Three complementary hard limits: max steps, a token and cost budget, and a per-step wall-clock timeout
  • Add a semantic guard: identical tool plus identical arguments twice in a row means it is spinning — cut it and tell the model
  • Give the user an honest message when the cap is hit, and track the cap-hit rate as a signal that a tool needs fixing
  • Size the cap from the production step distribution, not intuition; a tighter cap makes the system a workflow rather than an agent

D4 模型接入与系统提示词：多 provider 抽象与 fallback、覆盖默认人设（dg P03/P04/M04）

• 为什么生产级 Agent 通常要接入多个模型 provider？Why do production agents usually integrate more than one model provider?

  国内高频海外高频基础#model-routing#reliability

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

  1. 先判断这题问的是「可用性」还是「架构」。只答「防止挂掉」拿不到分，因为面试官想看的是你有没有真的算过账、踩过坑。
  2. 从一条因果链推：模型 API 是外部依赖 → 外部依赖必然有故障率 → 你的可用性上限被它锁死 → 所以要么接受这个上限，要么加冗余。
  3. 把可用性说成数字才有说服力：单家 99.5% 意味着每月约 3.6 小时不可用；三家独立故障时理论不可用时间降到秒级。数量级差异比形容词有力得多。
  4. 第二个理由往往被忽略，但更能体现工程视角：模型的价格和能力每月都在变，接入成本高会让你因为「改起来麻烦」而一直用贵的慢的那个——高耦合真正的代价是剥夺未来的选择权。
  5. 这里有个必须自己先说破的前提：那个数量级是拿「三家故障互不相关」算出来的。如果三家其实都走同一个聚合网关、共用同一把 key（很多人的第一版就是这样），网关一挂三家一起挂，冗余是假的，聚合网关反而成了新的单点。真正的独立要落到不同厂商的直连端点、各自的凭证和计费上。主动点破这一条，比背出 0.005 的三次方更能体现你真的部署过。
  6. 可以预期的追问：多接几家不是更贵吗？答案是不会——正常路径只调一家，多的只是配置和一层抽象；真正贵的是 fallback 被频繁触发，那说明你该查主 provider 而不是砍掉冗余。

  How to reason about it · think before answering

  1. First decide whether this is an availability question or an architecture question; answering only 'so it doesn't go down' reads as inexperienced.
  2. Follow the causal chain: the model API is an external dependency, dependencies have failure rates, your ceiling is capped by theirs, so you either accept the cap or add redundancy.
  3. Quantify it: 99.5% monthly availability is about 3.6 hours of downtime; three independently failing providers push that to seconds. Orders of magnitude beat adjectives.
  4. The second reason shows engineering maturity: model pricing and capability shift monthly, and high switching cost means you stay on the expensive slow one out of inertia — coupling really costs you future optionality.
  5. Say the premise out loud before they ask: that order of magnitude assumes the three providers fail independently. If all three are model ids behind one aggregator gateway on a single key — which is what most first versions look like — the gateway going down takes all three with it, the redundancy is fake, and the aggregator has become the new single point of failure. Real independence means direct endpoints at different vendors, with separate credentials and billing. Naming this yourself signals operational experience far more than reciting 0.005 cubed.
  6. Expect the follow-up: isn't this more expensive? No — the happy path calls one provider; what costs money is fallback firing often, which is a signal to investigate the primary, not to remove redundancy.

  答题要点

  • 模型 API 是外部依赖，厂商故障、限流、模型下线都是每月都会遇到的日常，不是小概率事件
  • 单家 99.5% 可用性等于每月约 3.6 小时不可用；多家冗余能把理论不可用时间降低几个数量级
  • 价格与能力每月都在变，统一抽象层让换模型变成改配置，保住了未来做选择的自由
  • 正常路径只调一家，冗余的成本是一层抽象而不是多倍账单

  Key points

  • The model API is an external dependency; outages, rate limits and model deprecations are monthly realities
  • 99.5% monthly availability is roughly 3.6 hours down; multi-provider redundancy cuts that by orders of magnitude
  • Pricing and capability shift constantly, so an abstraction layer turns model swaps into config changes
  • The happy path still calls one provider — redundancy costs an abstraction, not a multiplied bill
• 设计模型 fallback 策略时要权衡哪些因素？What trade-offs shape a model fallback strategy?

  国内高频海外高频进阶#model-routing#reliability#cost

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

  1. 题眼在「权衡」两个字——面试官不要你背一个 for 循环，他要看你知不知道 fallback 是有代价的。
  2. 先拆出第一个关键判断：不是所有错误都该 fallback，而分类的依据不是状态码的首位数字，是「换一家有没有可能变好」。400 请求体不合法、403 被安全策略拦截，换谁都一样，重试只是把同一个 bug 再犯一遍、白花两倍的钱和时间；408 超时、429 限流、5xx 服务端故障是对方的问题，换一家大概率能成。最容易答错的是 402 余额不足和 404 模型被下线或改名——它们同属 4xx、长得像「你的问题」，其实换一家完全可能成功；401 则要看凭证怎么管，三家共用一把网关 key 时换了也没用，各有各的 key 时 A 被吊销切到 B 完全能救。分类是 fallback 的第一步，不是重试。
  3. 再说成本：切换意味着同一段 prompt 你付了两次钱，三家链路最坏是三倍成本。这条一定要主动说出来，它区分了「写过」和「上过线」。
  4. 然后是延迟：串行 fallback 的总耗时是各家超时值的累加。如果每家给 15 秒、三家串下来用户要等 45 秒，那还不如早点失败。所以超时值必须按 provider 分别设，且要设总预算上限。
  5. 最后是雪崩，这是最容易被追问的点：主 provider 限流时你把全部流量瞬间压到备用上，很可能把备用也压垮。所以要加熔断——连续失败 N 次就暂时摘掉该 provider，过一段时间放少量流量试探。
  6. 可以预期的追问：怎么知道该摘多久？答案是指数退避 + 半开状态试探，和数据库连接池的熔断是同一套思路。

  How to reason about it · think before answering

  1. The word 'trade-offs' is the hinge: they are not asking for a for-loop, they want to know you understand fallback has costs.
  2. First key judgment: not every error deserves a fallback, and the test is not the leading digit of the status code but whether another provider could plausibly succeed. A 400 (malformed body) or 403 (blocked by safety policy) fails everywhere, so retrying repeats your own bug at double the cost and latency; a 408, 429 or 5xx is theirs and usually succeeds elsewhere. The two that people get wrong are 402 (out of credit) and 404 (model retired or renamed): both are 4xx, both look like your fault, and both are fixed by switching. A 401 depends on how credentials are managed — one shared gateway key fails everywhere, but per-provider keys mean a revoked key on A is survivable on B. Classification comes before retry.
  3. Cost: switching means paying for the same prompt twice, up to 3x across a three-provider chain. Volunteering this separates people who shipped from people who only read about it.
  4. Latency: serial fallback accumulates timeouts. Three providers at 15s each means a 45s wait — worse than failing fast. Timeouts must be per-provider with an overall budget.
  5. Thundering herd is the most common follow-up: when the primary rate-limits, shifting all traffic at once can take down the backup too. Hence circuit breaking — drop a provider after N consecutive failures, then probe with a trickle.
  6. Expect: how long do you drop it for? Exponential backoff with a half-open probe — the same pattern as database connection pool breakers.

  答题要点

  • 先分类再重试，判据是「换一家有没有可能变好」而不是状态码首位：400/403 不该切，408/429/5xx 该切，402 余额不足和 404 模型下线同样该切，401 取决于三家是否共用同一把凭证
  • 成本：每次 fallback 都要重付一遍 prompt 的钱，链路越长最坏成本越高
  • 延迟：串行 fallback 的耗时是各超时值累加，必须按 provider 分设超时并设总预算
  • 雪崩防护：主 provider 故障时全量流量压向备用会把备用也压垮，需要熔断 + 指数退避 + 半开试探

  Key points

  • Classify before retrying, judging by whether another provider could plausibly succeed rather than the leading digit: 400/403 must not fail over; 408/429/5xx should; so should 402 (out of credit) and 404 (model retired); 401 depends on whether the providers share one key
  • Cost: every fallback re-pays for the same prompt, so worst-case cost scales with chain length
  • Latency: serial fallback sums the timeouts, so set per-provider timeouts plus an overall budget
  • Thundering herd: shifting full traffic to the backup can topple it too — use circuit breaking with exponential backoff and half-open probes

D7 封装成服务：Fastify + SSE + Docker（dg P07）；W1 复盘

• 一个 SSE 长连接服务上线，心跳、连接断开处理和优雅退出分别在解决什么问题？For a long-lived SSE service in production, what problems do heartbeats, disconnect handling and graceful shutdown each solve?

  国内高频海外高频深入#sse#reliability#deployment

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

  1. 这题的区分度在于三件事各自的失败现象完全不同，能分别说出现象的人一定真上过线。答成「都是为了稳定性」等于没答。
  2. 心跳解决的是「被中间设施误杀」。负载均衡和网关普遍有空闲超时，常见 60 到 120 秒，一段时间没有字节流动就关连接；而 Agent 天生有大量静默期——模型在思考、在调工具、在等慢接口。现象是连接莫名其妙断在一半，且本地直连时完全复现不了。实现上用 SSE 的注释行（冒号开头）做心跳，客户端会安静忽略，不用改客户端代码。
  3. 连接断开处理解决的是「花钱」。用户关掉页面之后服务端不会自动停，模型继续生成、token 继续计费，只是没人接收。这是流式服务里最贵的疏忽，而且测试环境暴露不出来，因为没人会中途关页面。做法是监听响应对象的关闭事件，判定是被掐断而不是正常收尾，就把上游请求一起中止。
  4. 这里有个必须说对的细节，说错会当场暴露没写过：Node 里要监听的是响应对象的 close，不是 request 的——request 的 close 在请求体读完时就触发，拿它当断线信号会把每一条正常请求都误判成客户端跑了，现象是每次只推出一两个片段就停。
  5. 优雅退出解决的是「发布时切断在途请求」。容器收到 SIGTERM 后应当先停止接受新连接，给在途的流一点收尾时间再退出，否则用户看到的是回复说了一半突然没了。前提是信号真的能传到进程——CMD 写成包管理器的话 PID 1 不是 node，SIGTERM 传不到，只能等超时被强杀。
  6. 可以预期的追问：收尾时间给多久？答案是要小于编排系统的终止宽限期（Docker 默认十秒、K8s 默认三十秒），超过就会被 SIGKILL，等于白设计；同时新连接要立刻拒绝，让负载均衡把流量挪走。

  How to reason about it · think before answering

  1. The discriminator is that the three have completely different failure symptoms. Someone who can describe each symptom has shipped one; 'they all improve stability' is a non-answer.
  2. Heartbeats prevent middleboxes from killing you. Load balancers and gateways commonly close idle connections after 60 to 120 seconds, and agents are full of silent gaps while the model reasons, calls a tool or waits on a slow API. The symptom is a stream that dies halfway for no visible reason and never reproduces against a local server. Implement it as an SSE comment line, which clients silently ignore, so no client change is needed.
  3. Disconnect handling is about money. When a user closes the tab the server does not stop on its own: the model keeps generating and tokens keep billing with nobody receiving. It is the most expensive oversight in streaming services, and staging never reveals it because nobody closes tabs mid-run. Watch for the response closing, distinguish a premature close from a normal finish, and abort the upstream request.
  4. One detail must be right or it exposes you immediately: in Node listen on the response object's close, not the request's. The request emits close once its body has been read, so using it as a disconnect signal misfires on every normal request and you see streams stopping after one or two chunks.
  5. Graceful shutdown is about deploys cutting live requests. On SIGTERM the process should stop accepting new connections, give in-flight streams a short window, then exit; otherwise users watch a reply stop mid-sentence. This assumes the signal actually reaches the process — if the container's PID 1 is a package manager, SIGTERM never arrives and the runtime kills you on timeout.
  6. Expect: how long is the window? Shorter than the orchestrator's termination grace period (10s by default in Docker, 30s in Kubernetes), or you get SIGKILLed anyway; and refuse new connections immediately so the load balancer drains traffic away.

  答题要点

  • 心跳防的是中间设施的空闲超时，Agent 的静默期常常超过网关的 60 到 120 秒，用 SSE 注释行实现，客户端无感
  • 断开处理防的是浪费：用户关页面后服务端不停就是纯烧 token，测试环境暴露不出来
  • Node 里要监听响应对象的 close 而不是 request 的——后者在请求体读完时就触发，会把正常请求误判成断线
  • 优雅退出防的是发布切断在途流：SIGTERM 后先停收新连接、给在途流收尾时间，收尾窗口要小于编排系统的终止宽限期
  • 前提是信号能传到进程：容器的 PID 1 必须是 node 本身，不能是包管理器

  Key points

  • Heartbeats defeat idle timeouts in middleboxes, since agent silence often exceeds a gateway's 60 to 120 seconds; SSE comment lines do it transparently
  • Disconnect handling stops waste: after a user closes the tab, an unaware server keeps burning tokens, and staging never shows it
  • In Node listen on the response's close, not the request's — the latter fires when the body is read and misclassifies normal requests as disconnects
  • Graceful shutdown stops deploys from cutting live streams: on SIGTERM refuse new connections and drain, within the orchestrator's grace period
  • It only works if the signal reaches the process, so PID 1 must be node itself rather than a package manager