dsh-chubby-whale 1.1.65 → 1.1.66

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 
 ## [未发布]
 
+## [1.1.66] - 2026-11-07
+
+### 修复（B94 HTTP 错误分类与聊天断连分身）
+- **`isTimeoutError` 把「客户端走了」与「上游太慢」混为一类**：日志分不清，路由也没法据此分流。新增 `isAbortError` / `isTimeoutOnly`（旧函数语义原样保留，不破既有断言）
+- **`/chat` 不接断连**：客户端走了仍把模型跑完、且把 AbortError 记成 `CHAT-TIMEOUT`；请求体断连还会往死连接回 200 兜底包。现在断连即 abort 上游、**半截不记账**（`resolve` 出的完整回复仍照常记账——已付费的语义不变）
+- **`/chat-stream` 漏 `req` 侧断连信号**、每请求留一个 `res close` 监听不摘、断连后仍往死 socket 写 `stream: client closed` 帧
+- `http.ts` 新增公共 `watchClientGone`（三形状判定，正常结束有 `writableFinished` 守护）
+
+### 修复（B94 TTS 断连中止分身）
+- **客户端走了仍在合成**：`/tts` 完全没有断连检测，`TtsEngine`/`cloudTts` 也没有 signal 通道。现在 signal 一路贯到 worker/CLI/云端
+- 取舍写在代码里：edge-tts **共享 worker 不杀**（杀掉会连带失败并发段并重付启动），只把本次从 pending 摘除、产物作废；CLI 回退路径本请求独占 python，abort 直接 kill；临时文件 `EBUSY` 时 5s 补删一次
+- abort 的请求**不记账、不写缓存、不进降级闸、不回退 edge-tts**，只留一行 `TTS-CLIENT-ABORT` 诊断
+
+### 修复（主代理）
+- **整句打断词表三处各抄一份**：`echo-filter` 认 19 条、`voice-bridge` 只认 8 条 → 「停下来吧」在闸门能放行、到桥接却认不出。统一到 `shared/noise.ts` 的 `INTERRUPT_PHRASES` + `isInterruptCommand()`
+- `intent.ts` 头部「纯函数」口径修正：判定同步，但会触发一次 `ensurePoemTitles()` 后台预热（有网络副作用），单测须 stub
+
+### 测试
+- 新增 `test-chat-abort.mjs`(51)、`test-tts-abort.mjs`(61)，接入 `npm test`；`test-shared-voice` +7
+- 全链 **4033 项 0 失败**（`node tools/test-count.mjs`：56 个套件，失败 0，未识别 0）
+
 ## [1.1.65] - 2026-11-07
 
 ### 修复（B93 音色白名单同源分身）

package/dist/client.js

@@ -25,7 +25,7 @@
   }
 
   // src/client/version.ts
-  var VERSION = "1.1.65";
+  var VERSION = "1.1.66";
 
   // src/client/styles.ts
   var W = 240;
@@ -1133,6 +1133,32 @@
     if (/^([\u4e00-\u9fa5])\1{2,}$/.test(k)) return true;
     return false;
   }
+  var INTERRUPT_PHRASES = Object.freeze([
+    "停下",
+    "停下来",
+    "停下来吧",
+    "停一下",
+    "停一停",
+    "停吧",
+    "别说了",
+    "别讲了",
+    "别念了",
+    "别吵",
+    "别说下去了",
+    "不要说了",
+    "不用说了",
+    "安静",
+    "打住",
+    "够了",
+    "暂停",
+    "算了"
+  ]);
+  function isInterruptCommand(text) {
+    const k = normalizeNoiseKey(text);
+    if (!k) return false;
+    if (isInterruptWord(k)) return true;
+    return INTERRUPT_PHRASES.indexOf(k) >= 0;
+  }
   function isInterruptWord(text) {
     const k = normalizeNoiseKey(text);
     return k.length > 0 && INTERRUPT_WORDS.indexOf(k) >= 0;
@@ -1183,31 +1209,6 @@
   }
 
   // src/client/voice/echo-filter.ts
-  var SINGLE_INTERRUPT = /^[停别不]$/;
-  var INTERRUPT_PHRASES = [
-    "停下",
-    "停下来",
-    "停下来吧",
-    "停一下",
-    "停一停",
-    "停吧",
-    "别说了",
-    "别讲了",
-    "别念了",
-    "别吵",
-    "别说下去了",
-    "不要说了",
-    "不用说了",
-    "闭嘴",
-    "安静",
-    "打住",
-    "够了",
-    "暂停",
-    "算了"
-  ];
-  function isInterruptCommand(plain) {
-    return SINGLE_INTERRUPT.test(plain) || INTERRUPT_PHRASES.indexOf(plain) >= 0;
-  }
   function createEchoFilter() {
     const spokenRecent = [];
     const recentHeard = [];
@@ -1229,7 +1230,7 @@
       }
       const plain = normalizePlain(text).toLowerCase();
       const plainKey = echoKey(text).toLowerCase();
-      const interrupt = SINGLE_INTERRUPT.test(plain);
+      const interrupt = isInterruptWord(plain);
       const stopCmd = isInterruptCommand(plain);
       if (plain.length < 2 && !interrupt) return { ok: false, reason: "trivial" };
       if (!interrupt && isNoiseText(plain)) return { ok: false, reason: "noise" };
@@ -3887,13 +3888,11 @@
   }
 
   // src/client/voice-bridge.ts
-  var STOP_PHRASES = ["停下", "停一下", "别说了", "别讲了", "别念了", "别吵", "安静", "够了"];
   var NARR_STOP_RE = /停|别念|不念|够了|算了|打住/;
   var HAS_CONTENT_RE = /[\u4e00-\u9fa5a-z0-9]/i;
   function isStopCommand(norm) {
     if (!norm) return false;
-    if (isInterruptWord(norm)) return true;
-    return STOP_PHRASES.indexOf(norm) >= 0;
+    return isInterruptCommand(norm);
   }
   function bump(key) {
     try {

package/dist/host/http.js

@@ -21,11 +21,35 @@ function bodyTooLarge() {
 export function isBodyTooLarge(err) {
     return Boolean(err && err.code === BODY_TOO_LARGE);
 }
-/** 超时/中止类错误（AbortSignal.timeout 抛 TimeoutError，手动 abort 抛 AbortError） */
+/**
+ * 错误名（B94）：只看 name，不猜 instanceof —— DOMException 跨 realm 不可靠，
+ * 测试里的替身错误也只是 Object.assign(new Error(...), { name })。
+ * 有的运行时/薄封装会把中止原因再包一层（err.reason = 原始 reason），这里顺手认一层。
+ */
+function errorName(err) {
+    return String((err && err.name) || '');
+}
+/** 超时/中止类错误 —— **兼容旧语义：TimeoutError 与 AbortError 都算**（既有测试与 asr 路由按此口径） */
 export function isTimeoutError(err) {
-    const n = String((err && err.name) || '');
+    const n = errorName(err);
     return n === 'TimeoutError' || n === 'AbortError';
 }
+/**
+ * 只因**调用方**（外部 signal：客户端断连 / 切页 / 上层主动取消）中止 —— AbortError。
+ * 依据：fetch 被中止时以 signal.reason 拒绝；AbortController.abort() 的默认 reason 是 AbortError。
+ * 与内部超时（TimeoutError）互斥：路由据此把「客户端走了」与「上游太慢」分开记日志/记账
+ * （B93 取证：两者混在 isTimeoutError 里时，CHAT-TIMEOUT / ASR-TIMEOUT 分不出是谁先放弃的）。
+ */
+export function isAbortError(err) {
+    return errorName(err) === 'AbortError' || errorName(err && err.reason) === 'AbortError';
+}
+/**
+ * 只是内部**超时**（AbortSignal.timeout(ms) 到点）—— TimeoutError；调用方中止不算。
+ * 旧名 isTimeoutError 被「两者都算」的历史语义占着，区分用的新名字另起（B94）。
+ */
+export function isTimeoutOnly(err) {
+    return errorName(err) === 'TimeoutError' || errorName(err && err.reason) === 'TimeoutError';
+}
 /** N 毫秒后自动中止的 signal（Node 18+ 的 AbortSignal.timeout，项目 engines 要求 >=22） */
 export function timeoutSignal(ms) {
     return AbortSignal.timeout(ms);
@@ -37,6 +61,25 @@ function pickSignal(signal, init) {
         return undefined;
     return typeof cand.addEventListener === 'function' && typeof cand.aborted === 'boolean' ? cand : undefined;
 }
+/**
+ * 取中止原因（B94）：先触发那一方的 reason 原样转发；老运行时 signal 没有 reason 时
+ * 按来源补一个**同名**的 DOMException —— 否则内部超时会退化成 AbortError，
+ * isTimeoutOnly 就再也认不出「这是超时还是客户端中止」（手写兜底路径的关键）。
+ */
+function abortReason(src, name) {
+    if (src && src.reason !== undefined)
+        return src.reason;
+    const D = globalThis.DOMException;
+    if (typeof D === 'function') {
+        try {
+            return new D('aborted: ' + name, name);
+        }
+        catch { }
+    }
+    const e = new Error('aborted: ' + name);
+    e.name = name;
+    return e;
+}
 /**
  * 把「内部超时」和「调用方中止」（客户端断连等外部 signal）合成一个 signal：任一触发都中止外呼。
  *
@@ -80,12 +123,11 @@ function combineSignals(timeout, outer) {
     }
     function onAbort(ev) {
         unhookOuter();
-        const src = ev && (ev.target || ev.currentTarget);
+        // 事件没带源 signal（少数实现）时按「谁已经中止」判来源：绝不能把超时当调用方中止
+        const given = ev && (ev.target || ev.currentTarget);
+        const src = given || (timeout.aborted ? timeout : outer);
         try {
-            if (src && src.reason !== undefined)
-                ctl.abort(src.reason);
-            else
-                ctl.abort();
+            ctl.abort(abortReason(src, src === timeout ? 'TimeoutError' : 'AbortError'));
         }
         catch { }
     }
@@ -93,7 +135,7 @@ function combineSignals(timeout, outer) {
     if (timeout.aborted || outer.aborted) {
         const src = timeout.aborted ? timeout : outer;
         try {
-            ctl.abort(src.reason);
+            ctl.abort(abortReason(src, src === timeout ? 'TimeoutError' : 'AbortError'));
         }
         catch { }
         return { signal: ctl.signal, dispose() { } };
@@ -219,3 +261,74 @@ export async function readBody(req, maxBytes) {
         throw bodyTooLarge(); // 已经读空，路由这时写 413 能送到客户端
     return Buffer.concat(chunks);
 }
+/**
+ * 盯住「客户端是不是走了」（B94：从 routes/asr.ts 的私有实现提成公共件，两条 chat 路由共用）。
+ * 返回的 signal 交给 host/http.ts 的外呼（fetchWithTimeout / fetchJson 的第 4 个参数）：
+ * 客户端一走，还在等上游的那次付费请求就立刻中止，不必跑满超时、也不把回复写进记忆。
+ * onGone 可选：仅供路由在自己的 controller 上收口（如 /chat-stream 的空闲/总时长 controller），
+ * 在 ctl.abort() 之后调用一次，抛错只吞掉。
+ *
+ * 为什么不能只听 req 的 close（Node 24 本机实测，时间线见 scripts/test-asr-abort.mjs）：
+ * 请求体读完时 req 就会发 close（此时 req.complete=true、res.writableEnded=false、响应还没写）——
+ * 只看 close 会把**每个正常请求**都误判成断连。真正的断连有三种形状：
+ *   ① req 'aborted'：请求体还没收完客户端就断了（Node 24 实测会发，虽已标记废弃）；
+ *   ② req 'close' 且 req.complete === false：①的兜底（老版本/某些客户端不发 aborted）；
+ *   ③ res 'close' 且响应没写完（writableEnded 与 writableFinished 都为 false）：客户端发完了
+ *      body、等不到结果先走了 —— 客户端 30s 硬超时就是这个形状（宿主还在跑 30s 的聊天/60s 的识别）。
+ * 正常结束的 res 'close' 里 writableFinished=true，不会命中 ③，所以不会误中止正常请求。
+ */
+export function watchClientGone(req, res, onGone) {
+    const ctl = new AbortController();
+    let gone = false;
+    const mark = () => {
+        if (gone)
+            return;
+        gone = true;
+        try {
+            ctl.abort();
+        }
+        catch { }
+        if (onGone) {
+            try {
+                onGone();
+            }
+            catch { }
+        }
+    };
+    const onReqAborted = () => mark();
+    const onReqClose = () => { if (!req || req.complete === false)
+        mark(); };
+    const onResClose = () => { if (!res || !(res.writableEnded || res.writableFinished))
+        mark(); };
+    const on = (target, ev, fn) => {
+        // 测试里的假 req/res 未必是 EventEmitter：没有 on 就静默跳过（既有用例都是这种形状）
+        if (!target || typeof target.on !== 'function')
+            return;
+        try {
+            target.on(ev, fn);
+        }
+        catch { }
+    };
+    const off = (target, ev, fn) => {
+        if (!target || typeof target.removeListener !== 'function')
+            return;
+        try {
+            target.removeListener(ev, fn);
+        }
+        catch { }
+    };
+    on(req, 'aborted', onReqAborted);
+    on(req, 'close', onReqClose);
+    on(res, 'close', onResClose);
+    return {
+        signal: ctl.signal,
+        gone: () => gone,
+        dispose() {
+            // req/res 是每请求对象，不摘也不会串到下一个请求；但已结束的 handler 没必要继续响应
+            // 'close'/'aborted'（多做一次无意义的 abort），排障时也容易看花眼
+            off(req, 'aborted', onReqAborted);
+            off(req, 'close', onReqClose);
+            off(res, 'close', onResClose);
+        },
+    };
+}

package/dist/host/routes/chat-stream.js

@@ -18,6 +18,9 @@
  *   · 请求解析、system 片段、messages 结构全部走 host/chat-core.ts（同一输入 → 同一请求体）；
  *   · 命中缓存：直接发一条 delta + done(cached:true)
  *   · 未命中：边转发边累积，结束时写缓存、写记忆、记 token；半截（中断/客户端断开）一律不落盘。
+ *   · 客户端断连（B94）：req 'aborted' / req close(complete=false) / res close(响应没写完) 都算
+ *     「客户端走了」——立刻 abort 上游、不写记忆不记账；正常结束的 res close（writableFinished）
+ *     不算断连。判定与 /chat、/asr 共用 host/http.ts 的 watchClientGone 一份实现。
  *
  * 记账口径（2026-11-06 起与普通 /chat 一致）：
  *   · 成功回复：亲密度 +1、经验 +1（可升级）、appendTurns、token、onReply；
@@ -34,7 +37,7 @@
  *
  * 纯函数与其它路由共用 host/chat-core.ts，不再从 routes/chat.ts 横向 import。
  */
-import { sendTooLarge } from '../http.js';
+import { sendTooLarge, watchClientGone } from '../http.js';
 import { readJsonBody } from '../body.js';
 import { sendJson, sendSseHeaders } from '../respond.js';
 import { DEFAULT_CHAT_MODEL } from '../config.js';
@@ -46,6 +49,12 @@ const SSE_PING_MS = 12 * 1000; // SSE 心跳间隔
 const CHAT_MAX_BODY = 6 * 1024 * 1024;
 /** 图片超限文案：与 host/routes/chat.ts 的同一句保持一致（路由之间不横向 import，各持一份） */
 const IMAGE_TOO_LARGE_FALLBACK = '主人，这张图太大啦（原图超过约 3MB），本鲸一口吞不下，换张小一点的再发吧～';
+/**
+ * 客户端已经走了的日志标签（B94）：与上游超时/网络错误分开，排障时一眼能分清谁先放弃。
+ * 分两条对应时机：外呼/读流途中断开（中止外呼）/ 还没发起外呼就断开（body 阶段断连）。
+ */
+const LOG_CLIENT_ABORT_OUTBOUND = '[chat-stream] CHAT-CLIENT-ABORT 客户端已断开，上游外呼已中止（不计入上游超时/网络失败）';
+const LOG_CLIENT_ABORT_REQUEST = '[chat-stream] CHAT-CLIENT-ABORT 客户端已断开，请求中止（未发起外呼）';
 export function createChatStreamHandler(opts) {
     // 与普通 /chat 共用同一个装配值（index.ts 的 readChatModel），缓存 key 也带它
     const model = opts.model || DEFAULT_CHAT_MODEL;
@@ -131,6 +140,16 @@ export function createChatStreamHandler(opts) {
             }
             idleTimer = setTimeout(() => abortUpstream('idle timeout ' + CHAT_IDLE_TIMEOUT + 'ms'), CHAT_IDLE_TIMEOUT);
         };
+        /**
+         * 断连观察器（B94，与 /asr、/chat 共用 host/http.ts 的同一套判定）：
+         * 覆盖 req 'aborted' / req close(complete=false) / res close(响应没写完) 三种真实断连形状，
+         * 正常结束的 res close（writableFinished=true）不会命中 —— 基线只看 res close 时，
+         * 客户端在**上传 body 阶段**断开会漏掉（req 侧没人听）。
+         * 客户端一走就 abort 上游：没有读者的流继续读到 30s 空闲/120s 硬上限，等于白烧 token；
+         * 收尾阶段（上游已读完）不再 abort。
+         */
+        const client = watchClientGone(req, res, () => { if (!finished)
+            abortUpstream('client closed'); });
         try {
             const parsed = await readJsonBody(req, CHAT_MAX_BODY);
             if (!parsed.ok) {
@@ -159,24 +178,11 @@ export function createChatStreamHandler(opts) {
                 return;
             }
             sendSseHeaders(res);
-            // 立刻把 SSE 头刷出去，客户端不必等首帧；同时记录客户端断开
+            // 立刻把 SSE 头刷出去，客户端不必等首帧（断连监听已由上面的 watchClientGone 挂好）
             try {
                 res.flushHeaders && res.flushHeaders();
             }
             catch { }
-            let clientGone = false;
-            try {
-                if (typeof res.on === 'function') {
-                    res.on('close', () => {
-                        clientGone = true;
-                        // 客户端已经走了：没有读者的流继续读到 30s 空闲/120s 硬上限，等于白烧 token。
-                        // 收尾阶段（上游已读完/已 res.end）不再 abort。
-                        if (!finished)
-                            abortUpstream('client closed');
-                    });
-                }
-            }
-            catch { }
             // SSE 心跳：浏览器/反向代理会掐掉长时间没有数据的连接（豆包/nginx 一类默认 60s 左右），
             // 每 12s 写一行注释帧（以 : 开头，客户端解析器直接跳过）既保活又不污染事件流。
             // 正常结束/出错统一由 finally 里的 stopPing 清掉，不会残留定时器。
@@ -264,6 +270,14 @@ export function createChatStreamHandler(opts) {
                 totalTimer = setTimeout(() => abortUpstream('total timeout ' + CHAT_MAX_DURATION + 'ms'), CHAT_MAX_DURATION);
                 touchIdle();
             }
+            // 客户端在发起外呼之前就走了（读完 body 就断开/切页）：把中止补到刚建好的 controller 上。
+            // fetch 拿到的是已中止的 signal，真实网络请求不会真的打出去；日志由下面的 connect 分支统一出。
+            if (client.gone() && ctl && !ctl.signal.aborted) {
+                try {
+                    ctl.abort();
+                }
+                catch { }
+            }
             let upstream = null;
             try {
                 upstream = await fetch(CHAT_URL, {
@@ -282,6 +296,15 @@ export function createChatStreamHandler(opts) {
                 });
             }
             catch (err) {
+                // 客户端先走了：这次外呼是我们自己 abort 的（不是上游超时/网络故障），断开后也没人收帧
+                if (client.gone()) {
+                    console.error(LOG_CLIENT_ABORT_OUTBOUND);
+                    try {
+                        res.end();
+                    }
+                    catch { }
+                    return;
+                }
                 // 空闲/总时长中止时抛的是 AbortError，消息没用，用我们记下的原因
                 send({ error: 'connect: ' + (abortReason || String(err?.message || err)) });
                 res.end();
@@ -347,7 +370,11 @@ export function createChatStreamHandler(opts) {
             }
             catch (err) {
                 aborted = true;
-                send({ error: 'stream: ' + (abortReason || String(err?.message || err)) });
+                // 客户端先走了：这是我们自己 abort 的，不是上游故障；连接已断，也别再往死 socket 上写 error 帧
+                if (client.gone())
+                    console.error(LOG_CLIENT_ABORT_OUTBOUND);
+                else
+                    send({ error: 'stream: ' + (abortReason || String(err?.message || err)) });
             }
             finally {
                 // 流已结束（正常或异常），超时定时器再留着只会误伤后续收尾
@@ -355,20 +382,24 @@ export function createChatStreamHandler(opts) {
             }
             // 上游已读完：后面的收尾与客户端断开无关，close 事件不再 abort
             finished = true;
-            // 流中断或客户端已断开：这段回复是半截的，绝不能写进缓存和记忆（否则被永久命中）
-            if (aborted || clientGone) {
+            // 流中断或客户端已断开：这段回复是半截的，绝不能写进缓存和记忆（否则被永久命中）。
+            // 注意这里保持保守口径：客户端在流读取途中断开一律不落盘 —— 既有用例
+            // （test-stream-ledger ③B / test-chat-limits ⑦B）钉的就是这一条；「完整回复只是回不去」
+            // 的记账口径属于普通 /chat 那条同步路径（它没有半截概念），两边不混用。
+            if (aborted || client.gone()) {
+                if (client.gone())
+                    console.error('[chat-stream] CHAT-CLIENT-ABORT 客户端已断开：本轮不写缓存/记忆、不记 token、不加经验');
                 try {
                     res.end();
                 }
                 catch { }
-                ;
                 return;
             }
             const text = reply.trim() || '主人……本鲸刚刚走神了。';
             // 收尾：token / 记忆 / done（与普通 /chat 同口径）
             // token 口径：
             //   · 请求体已带 stream_options.include_usage，usage 在 [DONE] 之前的最后一帧里给，拿到就记；
-            //   · 中断（空闲/总时长超时、客户端断开、上游异常）在上面的 aborted/clientGone 分支已 return，
+            //   · 中断（空闲/总时长超时、客户端断开、上游异常）在上面的 aborted / client.gone() 分支已 return，
             //     不计 token —— 半截流没有最终 usage，估算只会虚记，宁可漏记；
             //   · 上游不回 usage（部分兼容服务不实现）时同样跳过，不猜。
             try {
@@ -472,15 +503,20 @@ export function createChatStreamHandler(opts) {
         }
         catch (err) {
             try {
-                send({ error: String(err?.message || err) });
+                // 请求体都没收完客户端就断了（req 'aborted' / ECONNRESET）：不算内部错误，也不往死连接写 error 帧
+                if (client.gone())
+                    console.error(LOG_CLIENT_ABORT_REQUEST);
+                else
+                    send({ error: String(err?.message || err) });
                 res.end();
             }
             catch { }
         }
         finally {
-            // 所有退出路径统一收口：心跳 interval 与两个超时定时器一个都不许残留
+            // 所有退出路径统一收口：心跳 interval、两个超时定时器、req/res 上的断连监听，一个都不许残留
             clearTimers();
             stopPing();
+            client.dispose();
         }
     };
 }

package/dist/host/routes/chat.js

@@ -2,13 +2,17 @@
  * host/routes/chat.ts —— 聊天路由（可复用模块）
  * 外呼统一走 host/http.ts：主聊天 30 秒、记忆摘要 20 秒（后台跑，不吊住回复）；
  * 请求体上限 6MB，单图 base64 上限 4MB（≈3MB 原图，超限回 413，与流式同一口径）
+ * 客户端断连（30s 硬超时/切页/断网）立刻中止外呼，不把模型跑完、不记账（B94）：
+ *   · 中途被 abort：没有完整回复 → 不写记忆、不记鱼粮、不回包（日志是 CHAT-CLIENT-ABORT）；
+ *   · 回复已完整拿到、只是回不去（abort 晚到一步）：照常记账/写记忆 —— 已经付过费，
+ *     丢掉反而让记忆里少一轮真实对话。两条口径都由 scripts/test-chat-abort.mjs 钉住。
  * 纯函数（语言判定/缓存 key/prompt 组装）在 host/chat-core.ts，流式路由共用同一份；
  * 本文件只做 HTTP 编排与「缓存 → 模型 → 记忆/成长」的调用顺序。
  *
  * 模型名不写死：由 index.ts 用 readChatModel 按配置算好，经 deps.model 注入；
  * max_tokens 预算见 chat-core.ts 的 CHAT_MAX_TOKENS / SUMMARY_MAX_TOKENS。
  */
-import { fetchJson, isTimeoutError, sendTooLarge } from '../http.js';
+import { fetchJson, isAbortError, isTimeoutError, isTimeoutOnly, sendTooLarge, watchClientGone } from '../http.js';
 import { readJsonBody } from '../body.js';
 import { sendJson, sendError } from '../respond.js';
 import { DEFAULT_CHAT_MODEL } from '../config.js';
@@ -20,12 +24,23 @@ const CHAT_MAX_BODY = 6 * 1024 * 1024; // 6MB（图片 base64 约 4MB * 1.34）
 const NET_FALLBACK = '主人，本鲸一时想不起来话（网络或接口有点问题）……';
 /** 图片超限文案：与 host/routes/chat-stream.ts 的同一句保持一致（路由之间不横向 import，各持一份） */
 const IMAGE_TOO_LARGE_FALLBACK = '主人，这张图太大啦（原图超过约 3MB），本鲸一口吞不下，换张小一点的再发吧～';
+/**
+ * 客户端已经走了的日志标签（B94）：与上游超时/网络错误分开，排障时一眼能分清谁先放弃。
+ * 分两条是因为时机差一步：外呼发出后断开（中止外呼）/ 请求体还没读完就断开（根本没发起外呼）。
+ * 文案刻意不写 CHAT-TIMEOUT / CHAT-NETWORK 这两个标签名（与 /asr 的「不计入 ASR 失败」同口径）：
+ * 否则按标签 grep 日志时会自己命中自己。
+ */
+const LOG_CLIENT_ABORT_OUTBOUND = '[chat] CHAT-CLIENT-ABORT 客户端已断开，上游外呼已中止（不计入上游超时/网络失败）';
+const LOG_CLIENT_ABORT_REQUEST = '[chat] CHAT-CLIENT-ABORT 客户端已断开，请求中止（未发起外呼，不计入上游失败）';
 export function createChatHandler(opts) {
     let summaryCount = 0;
     let summarizing = false;
     // 装配值优先；直接构造 handler（离线测试/旧调用方）时回落到配置模块的默认模型
     const model = opts.model || DEFAULT_CHAT_MODEL;
     return async function handleChat(req, res) {
+        // 先挂断连观察器：读 body → 外呼 → 写记忆的整段都在它的看护下，结束时必须 dispose（finally）。
+        // 客户端 30s 硬超时/切页/断网先走了以后，宿主不再把这次付费外呼跑满、也不把半截状态记进账（B94）。
+        const client = watchClientGone(req, res);
         try {
             const parsed = await readJsonBody(req, CHAT_MAX_BODY);
             if (!parsed.ok) {
@@ -119,7 +134,7 @@ export function createChatHandler(opts) {
                         temperature: 0.8,
                         thinking: { type: 'disabled' },
                     }),
-                }, CHAT_TIMEOUT);
+                }, CHAT_TIMEOUT, client.signal);
                 if (!r.ok) {
                     console.error('[chat] CHAT-HTTP ' + r.status + ' ' + String(r.text || '').slice(0, 200));
                     sendJson(res, { ok: false, error: `HTTP ${r.status}`, reply: NET_FALLBACK });
@@ -128,11 +143,21 @@ export function createChatHandler(opts) {
                 data = r.data;
             }
             catch (err) {
-                // 超时/网络错误：用户看到的仍是原来的兜底文案，日志里留标签
-                if (isTimeoutError(err))
+                // 客户端先走了（30s 硬超时/切页/断网）：这次外呼是**我们自己** abort 的，不是上游超时、
+                // 也不是网络故障。处理口径与 /asr 一致：不回包（连接已断，没人收）、不写记忆、不记账，
+                // 只留专用诊断（B94：此前这里会把它记成 CHAT-TIMEOUT，排障时分不清是谁先放弃的）。
+                if (client.gone()) {
+                    console.error(LOG_CLIENT_ABORT_OUTBOUND);
+                    return;
+                }
+                // 分类口径（host/http.ts）：内部超时 = TimeoutError；调用方中止但没标 gone = AbortError；其余算网络错
+                if (isTimeoutOnly(err))
                     console.error('[chat] CHAT-TIMEOUT ' + CHAT_TIMEOUT + 'ms 无响应，已中止');
+                else if (isAbortError(err))
+                    console.error('[chat] CHAT-ABORT 外呼被中止（无客户端断连标记）');
                 else
                     console.error('[chat] CHAT-NETWORK ' + String(err?.message || err));
+                // 回给客户端的 error 字段沿用旧口径（超时/中止类都算 timeout），不改客户端可见语义
                 sendJson(res, { ok: false, error: isTimeoutError(err) ? 'timeout' : String(err?.message || err), reply: NET_FALLBACK });
                 return;
             }
@@ -251,9 +276,18 @@ export function createChatHandler(opts) {
         }
         catch (err) {
             try {
+                // 请求体都没收完客户端就断了（req 'aborted' / ECONNRESET）：不算内部错误，也不往死连接写兜底包
+                if (client.gone()) {
+                    console.error(LOG_CLIENT_ABORT_REQUEST);
+                    return;
+                }
                 sendError(res, err, { reply: '主人，本鲸卡住了（内部错误）……' });
             }
             catch { }
         }
+        finally {
+            // 结束就摘监听：已结束的 handler 没必要继续响应 'close'/'aborted'（与 /asr 同一收口口径）
+            client.dispose();
+        }
     };
 }