dsh-router-core 0.3.18 → 0.3.20

package/src/client/ExtTab.tsx

@@ -10,6 +10,7 @@
  */
 import { useEffect, useRef, useState } from 'react'
 import { ROUTER_API_BASE, type RouterExtItem, type RouterExtResponse } from '../shared.ts'
+import { ExtDetail } from './ExtDetail.tsx'
 
 function Icon({ d, size = 18 }: { d: string; size?: number }): JSX.Element {
   return (
@@ -28,6 +29,7 @@ export function ExtTab(): JSX.Element {
   const [items, setItems] = useState<RouterExtItem[]>([])
   const [loaded, setLoaded] = useState(false)
   const [error, setError] = useState('')
+  const [selectedId, setSelectedId] = useState<string | null>(null)
   const mounted = useRef(true)
 
   useEffect(() => {
@@ -79,6 +81,12 @@ export function ExtTab(): JSX.Element {
     }
   }
 
+  // 打开详情视图：用 live item（否则详情里的开关状态不会随列表更新）。
+  const selected = selectedId !== null ? items.find((i) => i.id === selectedId) ?? null : null
+  if (selected !== null) {
+    return <ExtDetail item={selected} onBack={() => setSelectedId(null)} onToggle={toggle} />
+  }
+
   return (
     <div className="dshr-tabBody">
       {error !== '' && (
@@ -92,51 +100,43 @@ export function ExtTab(): JSX.Element {
           <span className="dshr-keyEmptyIcon"><Icon d={I.puzzle} size={30} /></span>
           <p className="dshr-keyEmptyTitle">暂无扩展</p>
           <p className="dshr-keyEmptyDesc">
-            安装扩展插件(如 <code>dsh-router-ext-rtk</code>)后,这里会出现开关
+            安装扩展插件(如 <code>dsh-router-ext-watch</code>)后,这里会出现开关
           </p>
         </div>
       ) : (
-        items.map(item => {
-          const notReady = item.ready === false
-          return (
-            <section key={item.id} className="dshr-card">
-              <div className="dshr-cardHead">
-                <span className="dshr-cardIcon"><Icon d={I.bolt} /></span>
-                <div className="dshr-cardTitle">{item.name}</div>
-                {/* 开关放标题行最右端:.dshr-cardAction 是现成的
-                    margin-left:auto(EndpointTab 的「创建 Key」就靠它),复用不新增。
-                    不可用时禁开——禁了就无从开启成功。 */}
-                <button
-                  type="button"
-                  className={`dshr-toggle dshr-cardAction ${item.enabled ? 'dshr-toggle-on' : ''}`}
-                  role="switch"
-                  aria-checked={!!item.enabled}
-                  disabled={notReady && !item.enabled}
-                  onClick={() => void toggle(item, !item.enabled)}
-                  title={notReady && !item.enabled
-                    ? '当前不可用,无法开启'
-                    : item.enabled ? `关闭 ${item.name}` : `开启 ${item.name}`}
-                >
-                  <span className="dshr-toggleKnob" />
-                </button>
-              </div>
+        <div className="dshr-supplierGrid">
+          {items.map(item => {
+            const notReady = item.ready === false
+            return (
+              <section key={item.id} className="dshr-supplierCard" onClick={() => setSelectedId(item.id)}>
+                <div className="dshr-supplierRow">
+                  {item.icon !== undefined ? (
+                    <img
+                      className="dshr-supplierIcon dshr-extLogo"
+                      src={item.icon}
+                      alt=""
+                      onError={(e) => { e.currentTarget.style.display = 'none' }}
+                    />
+                  ) : (
+                    <span className="dshr-supplierIcon"><Icon d={I.bolt} size={24} /></span>
+                  )}
+                  <div className="dshr-supplierName">{item.name}</div>
+                </div>
 
-              {/* 内容区：说明 + 未就绪红字（左对齐、与卡片图标对齐） */}
-              <div className="dshr-extBody">
-                {item.description !== undefined && item.description !== '' && (
-                  <div className="dshr-muted">{item.description}</div>
-                )}
                 {notReady && (
-                  <div className="dshr-ext-error">
-                    {item.detail !== undefined && item.detail !== ''
-                      ? item.detail
-                      : '未就绪,无法开启'}
+                  <div className="dshr-extCardError">
+                    {item.detail !== undefined && item.detail !== '' ? item.detail : '未就绪'}
                   </div>
                 )}
-              </div>
-            </section>
-          )
-        })
+
+                <div className="dshr-supplierMeta">
+                  <span className="dshr-muted">{item.enabled ? '已启用' : '未启用'}</span>
+                  <span className="dshr-chevron">›</span>
+                </div>
+              </section>
+            )
+          })}
+        </div>
       )}
     </div>
   )

package/src/client/router.css

@@ -923,6 +923,34 @@ html[data-dsh-router-active]:not([data-dsh-taskboard-active]):not([data-dsh-ssh-
   margin-top: 4px;
 }
 
+/* watch 进程行动作区（复制 PID / kill 命令，只读） */
+.dshr-procOps {
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 4px;
+  white-space: nowrap;
+}
+
+/* 扩展供应商式小卡片：未就绪红字（描述只在详情页，卡片不放） */
+.dshr-extCardError {
+  color: var(--rs-danger);
+  font-size: 11px;
+}
+
+/* 扩展卡 logo（如 rtk 白底 logo）：黑底 + 内边距,白色 logo 在黑底上显形 */
+.dshr-extLogo {
+  background: #000;
+  padding: 3px;
+  box-sizing: border-box;
+  object-fit: contain;
+}
+
+/* 扩展详情头部右侧的开关（顶到标题行右边，同供应商详情的编辑按钮位） */
+.dshr-extDetailToggle {
+  margin-left: auto;
+}
+
 /* 扩展卡片内容区：文字左对齐，左侧留白与标题行的图标位对齐 */
 .dshr-extBody {
   padding: 10px 14px 12px 48px;

package/src/ext/contract.ts

@@ -25,6 +25,7 @@
  *     file IO —— 落盘位置由核心锚定（不跟 cwd 跑），读写经核心，插件无状态。
  */
 import type { Context } from '@deepseek-ai/cordis'
+import type { IncomingMessage, ServerResponse } from 'node:http'
 
 /** 扩展器唯一 id（注册键）。 */
 export type ExtId = string
@@ -53,8 +54,16 @@ export interface RouterExt {
   readonly name: string
   /** 面板副标题说明。 */
   readonly description?: string
+  /** 卡片/详情图标的 logo URL（可选；缺省用默认图标）。 */
+  readonly icon?: string
   /** 当前运行时状态（ready + 不就绪时的说明）。 */
   getState(): ExtState
+  /**
+   * 通用扩展 API 点（可选）：核心把 `/router/api/ext/{id}/{subpath}` 兜底路由派发进来，
+   * 由扩展器自己裁决/处理（如 watch 的 `processes`/`kill`）。返回 true 表示已处理；
+   * false / 未实现 → 核心回 404。这样扩展的执行面逻辑进插件，核心只加一条通用转发。
+   */
+  api?(subpath: string, req: IncomingMessage, res: ServerResponse): boolean | Promise<boolean>
   /** 卸载清理（表删除时由 dsh-router 调用，可选）。 */
   dispose?(): void
 }
@@ -64,6 +73,8 @@ export interface ExtInfo {
   id: string
   name: string
   description?: string
+  /** 卡片/详情图标 logo URL（可选）。 */
+  icon?: string
   /** 核心持久化的开关（默认关）。 */
   enabled: boolean
   /** 插件报的运行时就绪状态。 */

package/src/index.ts

@@ -525,6 +525,7 @@ export function apply(rawContext: unknown): void {
           id: e.id,
           name: e.name ?? e.id,
           ...(e.description !== undefined ? { description: e.description } : {}),
+          ...(e.icon !== undefined ? { icon: e.icon } : {}),
           enabled: extStore.isEnabled(e.id),
           ready: st?.ready === true,
           ...(st?.detail !== undefined ? { detail: st.detail } : {}),
@@ -534,6 +535,34 @@ export function apply(rawContext: unknown): void {
     writeJson(res, 200, { ok: true, enhancers: list })
   })
 
+  // ---- 扩展通用 API 转发：/router/api/ext/{id}/{subpath} → 该扩展器的 api() ----
+  // watch 这类自定义扩展用它暴露自己的面板接口（如 processes）。分开的 exact 路由
+  // `/ext`（上方）管开关列表；这里必须是 **prefix** 路由兜子路径（`route()` 是 exact,
+  // 匹配不了 `/ext/watch/processes`——用 exact 会造成 404 空 body → 前端 res.json() 崩）。
+  // 核心不知道子路径长什么样——是否处理、怎么处理全由扩展器自己裁决（执行面），核心只转发。
+  const extDispatch = ctx.webServer.register({
+    kind: 'prefix',
+    path: `${ROUTER_API_BASE}/ext/`,
+    handler: async (req, res) => {
+      const pathname = new URL(req.url ?? '/', 'http://localhost').pathname
+      const mount = `${ROUTER_API_BASE}/ext/`
+      const rest = pathname.startsWith(mount) ? pathname.slice(mount.length) : ''
+      const slash = rest.indexOf('/')
+      const extId = slash < 0 ? rest : rest.slice(0, slash)
+      const subpath = slash < 0 ? '' : rest.slice(slash + 1)
+      if (extId === '') {
+        writeJson(res, 404, { ok: false, error: 'extension not found' })
+        return
+      }
+      const ext = (exts[extId] as RouterExt | undefined)
+      if (ext !== undefined && typeof ext.api === 'function' && (await ext.api(subpath, req, res))) {
+        return // 扩展器已处理并写出响应
+      }
+      writeJson(res, 404, { ok: false, error: 'extension api not found' })
+    },
+  })
+  disposers.push(extDispatch)
+
   // ---- 概览看板：用量统计 ----
 
   /** 解析并校验周期参数（不接受任意字符串）。 */

package/src/llm/adapter.test.ts

@@ -15,6 +15,13 @@ import { EMPTY_RESPONSE_CODE } from '@deepseek-ai/dsh-llm'
 import { toTokenUsage } from '../router/usage-tokens.ts'
 import { RouterAdapter, translateSse } from './adapter.ts'
 
+/**
+ * 本文件大量用例把 `globalThis.fetch` 打桩成假上游，且**从不还原**（沿既有惯例：
+ * 每个用例自己设桩）。所以「要打真实网络」的用例必须自己把真 fetch 放回去 ——
+ * 否则会静默拿到上一个用例残留的桩（曾导致「停摆测试 0ms 就 ended」的假结果）。
+ */
+const realFetch: typeof fetch = globalThis.fetch
+
 /**
  * dsh-llm 默认可重试的错误码白名单（DEFAULT_RETRYABLE_CODES）。
  *
@@ -727,3 +734,78 @@ test('wire：纯文本 tool-result 不因图片逻辑改变顺序（tool 紧跟
   assertToolPairingIntact(messages)
   assert.deepEqual(messages.map((m) => m.role), ['user', 'assistant', 'tool'], '纯文本 tool 结果仍紧跟 assistant')
 })
+
+/* ---------------- 流空闲超时：上游停摆不能永久挂住（issue #6） ---------------- */
+
+/**
+ * 为什么要有这一组：同一个 dsh-router `/v1`，走**自定义供应商**（llm-pi-ai 的
+ * openai-completions adapter）时有 `idleWatchdog`（默认 300s）兜底，走**内置
+ * Router adapter** 时此前没有任何超时 —— 上游连上后一停摆就永久挂着，连接和
+ * in-flight 请求都收不回。这是 issue #6「内置 vs 自定义」差异的一半。
+ *
+ * **必须用真实 http server**：合成 `ReadableStream` 上 `AbortSignal` 是无效的
+ * （实测合成流 + AbortSignal.timeout 永不收尾），拿它测只能得到假结论。
+ */
+test('流空闲超时：上游停摆 → adapter 自己中止（不依赖调用方给 signal）', async () => {
+  const http = await import('node:http')
+  const server = http.createServer((_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' })
+    res.flushHeaders()          // 一个字节都不吐，也不结束
+  })
+  await new Promise<void>((r) => server.listen(0, '127.0.0.1', () => r()))
+  const base = `http://127.0.0.1:${(server.address() as { port: number }).port}`
+  globalThis.fetch = realFetch   // 本文件前面的用例会留桩，必须装回真 fetch
+  try {
+    // 用可注入的短超时（默认 300s，测起来太慢）；不注入就退回生产值。
+    const adapter = new RouterAdapter(base, { comboModels: async () => [] }, undefined, 400)
+    const started = Date.now()
+    const consume = (async () => {
+      for await (const _c of adapter.stream({ model: 'm', messages: [] } as never)) void _c
+    })()
+    const outcome = await Promise.race([
+      consume.then(() => 'ended', (e: Error) => `threw:${(e as Error & { code?: string }).code ?? e.message}`),
+      new Promise<string>((r) => setTimeout(() => r('HANG'), 4000)),
+    ])
+    const ms = Date.now() - started
+    console.log(`[gate] 无调用方 signal，停摆 → ${outcome} @${ms}ms`)
+    assert.notEqual(outcome, 'HANG', 'adapter 必须自带空闲超时，不能永久挂住')
+    assert.ok(String(outcome).includes('TIMEOUT'), `应抛 TIMEOUT（可重试码），实际 ${outcome}`)
+  } finally {
+    server.closeAllConnections?.()
+    server.close()
+  }
+})
+
+test('调用方取消必须能贯穿整条流（响应头到手后仍可中断，不永久挂住）', async () => {
+  // 用**真实 http server**：合成 ReadableStream 会给出假象（abort 对非 undici 流
+  // 无效）。这里上游发出响应头 + 一块数据后停摆，调用方给 1s 超时。
+  // 修复前：adapter 在 fetch 返回时就 removeEventListener，body 读无人打断 →
+  // 请求永久挂住（实测 6s 仍未收尾）。修复后：1s 左右被中止。
+  const http = await import('node:http')
+  const server = http.createServer((_req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' })
+    res.write('data: {"choices":[{"delta":{"content":"a"}}]}\n\n')
+    res.flushHeaders()          // 之后停摆：不吐数据也不结束
+  })
+  await new Promise<void>((r) => server.listen(0, '127.0.0.1', () => r()))
+  const base = `http://127.0.0.1:${(server.address() as { port: number }).port}`
+  globalThis.fetch = realFetch   // 同上：必须先装回真 fetch
+  try {
+    const adapter = new RouterAdapter(base, { comboModels: async () => [] })
+    const t0 = Date.now()
+    const consume = (async () => {
+      for await (const _c of adapter.stream({ model: 'm', messages: [], signal: AbortSignal.timeout(1000) } as never)) void _c
+    })()
+    const outcome = await Promise.race([
+      consume.then(() => 'ended', (e: Error) => `threw:${e.message}`),
+      new Promise((r) => setTimeout(() => r('HANG'), 5000)),
+    ])
+    const ms = Date.now() - t0
+    console.log(`[gate] 停摆 + 1s 超时 → ${outcome} @${ms}ms`)
+    assert.notEqual(outcome, 'HANG', '调用方取消后必须收尾，不能永久挂住')
+    assert.ok(ms < 4000, `应在调用方超时附近收尾（实际 ${ms}ms）`)
+  } finally {
+    server.closeAllConnections?.()
+    server.close()
+  }
+})

package/src/llm/adapter.ts

@@ -81,6 +81,17 @@ export interface RouterAdapterSource {
 /** tool-result 里图片挂到 user 消息时用的说明文字（与官方适配器一致）。 */
 const TOOL_RESULT_IMAGE_TEXT = 'Tool result images'
 
+/**
+ * 流空闲超时：上游连上后这么久没吐**任何**字节就判失败（抛 TIMEOUT，可重试）。
+ *
+ * 对齐 `dsh-llm-pi-ai` 的 `DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300_000`：同一个
+ * dsh-router `/v1`，走自定义供应商（pi-ai）时有这个兜底、走内置 adapter 时没有
+ * —— 差异导致「上游停摆」在内置路径上永久挂住。
+ *
+ * 只守空闲、不封总时长：长生成只要持续吐块就不该被打断。
+ */
+const STREAM_IDLE_TIMEOUT_MS = 300_000
+
 async function wireMessages(options: GenerateOptions, system: string | undefined, attachments: RouterAttachmentStore | undefined): Promise<Array<Record<string, unknown>>> {
   const out: Array<Record<string, unknown>> = []
   /**
@@ -530,12 +541,24 @@ export class RouterAdapter extends LlmAdapter {
   private readonly baseURL: string
   private readonly source: RouterAdapterSource
   private readonly resolveAttachments: () => RouterAttachmentStore | undefined
+  /** 流空闲超时（ms）：上游这么久不吐字节就判 TIMEOUT。 */
+  private readonly idleTimeoutMs: number
 
-  constructor(baseURL: string, source: RouterAdapterSource, resolveAttachments?: () => RouterAttachmentStore | undefined) {
+  /**
+   * @param idleTimeoutMs 流空闲超时；缺省用生产值（300s，对齐 pi-ai）。
+   *   可注入只为测试能压到几百毫秒，生产不传。
+   */
+  constructor(
+    baseURL: string,
+    source: RouterAdapterSource,
+    resolveAttachments?: () => RouterAttachmentStore | undefined,
+    idleTimeoutMs: number = STREAM_IDLE_TIMEOUT_MS,
+  ) {
     super()
     this.baseURL = baseURL
     this.source = source
     this.resolveAttachments = resolveAttachments ?? (() => undefined)
+    this.idleTimeoutMs = idleTimeoutMs
   }
 
   providerInfo(provider: string): { id: string; name: string } {
@@ -602,16 +625,24 @@ export class RouterAdapter extends LlmAdapter {
         signal: controller.signal,
       })
     } catch (error) {
+      options.signal?.removeEventListener('abort', onAbort)
       throw new LlmError(`dsh-router upstream call failed: ${(error as Error).message}`, 'TRANSPORT', { cause: error })
+    }
+    // **监听必须活到整条流结束**，不能在 fetch 返回时就摘：`controller.signal`
+    // 已经把传入的 signal 与这次 fetch 绑在一起（含 body 流），响应头到手后
+    // body 还在读，此时调用方取消（用户中断 / agent-loop 收敛 / 上游停摆被
+    // 上层超时放弃）必须还能 abort 掉这次请求 —— 摘早了，body 读就无人打断，
+    // 请求永久挂住、连接也收不回（issue #6「内置供应商才挂死」的另一半）。
+    try {
+      if (!resp.ok) {
+        const detail = await resp.text().catch(() => '')
+        throw new LlmError(`dsh-router /v1 returned ${resp.status}: ${detail.slice(0, 200)}`, 'TRANSPORT')
+      }
+      if (resp.body === null) return
+      yield* translateSse(ssePayloads(resp.body, this.idleTimeoutMs))
     } finally {
       options.signal?.removeEventListener('abort', onAbort)
     }
-    if (!resp.ok) {
-      const detail = await resp.text().catch(() => '')
-      throw new LlmError(`dsh-router /v1 returned ${resp.status}: ${detail.slice(0, 200)}`, 'TRANSPORT')
-    }
-    if (resp.body === null) return
-    yield* translateSse(ssePayloads(resp.body))
   }
 }
 
@@ -641,16 +672,42 @@ function looksComplete(payload: string): boolean {
  * 跨块边界：一个 `data:` 行可能横跨两次 read()，所以留 `buffer` 接住
  * 最后一段未完整的行（9router 的 pipeTransformedSSE 同样处理）。
  */
-async function* ssePayloads(body: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+async function* ssePayloads(body: ReadableStream<Uint8Array>, idleTimeoutMs: number): AsyncGenerator<string> {
   const reader = body.getReader()
   const decoder = new TextDecoder('utf-8', { fatal: false })
   let buffer = ''
   /** 攒一帧内的多行 data（SSE 规范：多行用 \n 连起来）。**必须**是局部
    *  状态 —— 放模块级会让并发请求互相串数据。 */
   let payload = ''
+  /**
+   * 带**空闲超时**的读：上游连上后若长时间一个字节都不吐，就读穿不了 ——
+   * 没有超时的话这里会永久挂着，连接和 in-flight 请求都收不回。
+   *
+   * 为什么必须有（issue #6 的另一半）：`dsh-llm-pi-ai`（自定义供应商走的那条
+   * openai-completions adapter）有 `idleWatchdog`，默认 **300s** 空闲即
+   * `LLM_STREAM_IDLE_TIMEOUT` 中止；而本 adapter 此前**没有任何超时**，只靠
+   * 调用方的 `options.signal`。于是同一个组合，走内置 Router 时上游一停摆就
+   * 永久挂住（占用连接、且该请求永不收尾），走自定义供应商时 300s 后被放弃
+   * —— 放弃又会触发服务端那条「客户端断开不回收」的泄漏路径，两边叠加就是
+   * 「用久了报 connection error」。
+   *
+   * 只守**空闲**、不设总时长：长生成可以跑很久，只要还在吐块就不该被打断
+   * （总时长封顶会让长回答写到一半被砍）。
+   */
+  const readWithIdleTimeout = (): Promise<ReadableStreamReadResult<Uint8Array>> =>
+    new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new LlmError(`dsh-router upstream stream idle for ${idleTimeoutMs}ms`, 'TIMEOUT')),
+        idleTimeoutMs,
+      )
+      reader.read().then(
+        (r) => { clearTimeout(timer); resolve(r) },
+        (e) => { clearTimeout(timer); reject(e) },
+      )
+    })
   try {
     for (;;) {
-      const { done, value } = await reader.read()
+      const { done, value } = await readWithIdleTimeout()
       if (done) break
       buffer += decoder.decode(value, { stream: true })
       const lines = buffer.split('\n')

package/src/router/disconnect-leak.test.ts

@@ -0,0 +1,200 @@
+/**
+ * 客户端断开的连接回收测试 —— issue #6「组合模型用久了报 connection error」的真根因。
+ *
+ * 现象：把 `http://127.0.0.1:3080/v1` 加为**自定义供应商**（llm-pi-ai 的
+ * openai-completions）后，连续用半天到一天就全面 connection error；内置 Router
+ * 供应商同一个组合却正常。
+ *
+ * 真根因（**不是**「undici 每 origin 限 10 socket」——那条实测不成立，见下）：
+ * 客户端主动断开时，服务端 `writeChatResult` 只监听 `res` 的 `'error'`，**不监听
+ * `'close'`**。对端关闭触发的是 `'close'`，于是：
+ *   - 上游流还在推 → `writeChunk` 里 `res.write` 返回 false → 挂起等 `'drain'`
+ *   - 连接已死 → `'drain'` 永不到来 → `pipeTo` 永不 settle
+ *   - → `finally` 不执行 → 上游 fetch body **永不 cancel**
+ *   → 每次「客户端放弃」漏一条上游 TCP 连接 + 挂一个请求；长跑累积到 fd/端口耗尽。
+ *
+ * 为什么只有自定义供应商路径中招：pi-ai 有**流空闲超时**（idleWatchdog，默认
+ * 300s）和消费方提前退出时的 `consumer.abort()`，会**主动放弃**请求；而 dsh-router
+ * 自己的 adapter 不设任何超时、从不主动放弃 → 内置路径几乎不触发这条泄漏。
+ *
+ * 为什么「每 origin 10 socket」的解释不成立：实测（探针 I）连续泄漏 200 次
+ * **全部成功、无排队**（单次 ≤10ms），undici 会自行关闭多余连接 —— 默认 fetch
+ * 没有这个硬上限，所以「池满 → 全部 connection error」推不出来。
+ *
+ * 用 node --test 跑（Node 原生 TS 剥离，零新依赖）。
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import http from 'node:http'
+import { Router } from './index.ts'
+import { AccountPool } from './account-pool.ts'
+import type { ChatOnceResult, SupplierAccountNow, SupplierStatusNow } from '../suppliers/contract.ts'
+import type { ModelInfo } from './types.ts'
+
+/**
+ * 造一个**永不结束**的上游流（模拟长生成），并记录它有没有被 cancel。
+ * `enqueued` 用来证明「断开后服务端是否还在继续消费」。
+ */
+function infiniteStream(): { stream: ReadableStream<Uint8Array>; cancelled: () => boolean; enqueued: () => number } {
+  const enc = new TextEncoder()
+  let cancelled = false
+  let enqueued = 0
+  let timer: ReturnType<typeof setInterval> | undefined
+  const stream = new ReadableStream<Uint8Array>({
+    start(ctrl) {
+      timer = setInterval(() => {
+        try { ctrl.enqueue(enc.encode('data: {"choices":[{"delta":{"content":"x"}}]}\n\n')); enqueued += 1 } catch { /* closed */ }
+      }, 20)
+    },
+    cancel() { cancelled = true; if (timer !== undefined) clearInterval(timer) },
+  })
+  return { stream, cancelled: () => cancelled, enqueued: () => enqueued }
+}
+
+function supplierWith(stream: ReadableStream<Uint8Array>) {
+  return {
+    id: 'sup', name: 'sup', priority: 0, pool: new AccountPool('sup'),
+    status: (): SupplierStatusNow => ({ id: 'sup', name: 'sup', accounts: [] }),
+    listModels: async (): Promise<ModelInfo[]> => [{ id: 'm1' }],
+    accounts: (): SupplierAccountNow[] => [{ uid: 'u1', credits: 0, state: 'ok' }],
+    getAlias: () => 'sup',
+    chatOnce: async (): Promise<ChatOnceResult> => ({ ok: true, stream }),
+    dispose: () => {},
+  }
+}
+
+/** 建 server + 发起「拿一块就断」的请求，返回服务端是否收尾。 */
+async function abandonedRequest(
+  router: Router,
+  leak: { cancelled: () => boolean; enqueued: () => number },
+): Promise<{ settled: boolean; closeSeen: boolean; enqueuedAfterSettle: number }> {
+  let settled = false
+  let closeSeen = false
+  const server = http.createServer((req, res) => {
+    let body = ''
+    req.on('data', (c) => { body += c })
+    req.on('end', () => {
+      res.on('close', () => { closeSeen = true })
+      void router.chatCompletions(
+        { model: 'sup,m1', stream: true, rawBody: body } as never,
+        res as never,
+      ).then(() => { settled = true }, () => { settled = true })
+    })
+  })
+  await new Promise<void>((r) => server.listen(0, '127.0.0.1', () => r()))
+  const port = (server.address() as { port: number }).port
+
+  await new Promise<void>((resolve) => {
+    const creq = http.request({
+      host: '127.0.0.1', port, path: '/x', method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    }, (cres) => {
+      cres.once('data', () => { creq.destroy(); resolve() })
+    })
+    creq.on('error', () => resolve())
+    creq.end(JSON.stringify({ model: 'sup,m1', messages: [{ role: 'user', content: 'hi' }], stream: true }))
+  })
+
+  await new Promise((r) => setTimeout(r, 1200))
+  const enqueuedAfterSettle = leak.enqueued()
+  server.closeAllConnections?.()
+  server.close()
+  return { settled, closeSeen, enqueuedAfterSettle }
+}
+
+test('客户端中途断开：服务端必须停手并 cancel 上游流（否则每放弃一次漏一条连接）', async () => {
+  const leak = infiniteStream()
+  const router = new Router('')
+  router.add(supplierWith(leak.stream) as never)
+
+  const { settled, closeSeen } = await abandonedRequest(router, leak)
+
+  assert.equal(closeSeen, true, 'server 应看到客户端 close')
+  assert.equal(settled, true, '客户端断开后请求处理必须收尾（不能永远挂着）')
+  assert.equal(leak.cancelled(), true, '上游流必须被 cancel（否则 fetch body 泄漏，累积到 connection error）')
+
+  // 断开后不能再继续消费上游
+  const a = leak.enqueued()
+  await new Promise((r) => setTimeout(r, 400))
+  assert.equal(leak.enqueued(), a, '断开后不该继续从上游拉数据')
+})
+
+test('客户端断开：上游流 cancel 链要穿过 tapStreamUsage / normalizeSSEStream 两层 wrapper', async () => {
+  // 带 probe（= 真实请求路径）时会多包一层 tapStreamUsage；两层 wrapper 都必须
+  // 实现 cancel→reader.cancel()，取消才到得了上游（缺一层就静默断链）。
+  const leak = infiniteStream()
+  const router = new Router('')
+  router.add(supplierWith(leak.stream) as never)
+
+  let settled = false
+  let closeSeen = false
+  const server = http.createServer((req, res) => {
+    let body = ''
+    req.on('data', (c) => { body += c })
+    req.on('end', () => {
+      res.on('close', () => { closeSeen = true })
+      void router.chatCompletions(
+        { model: 'sup,m1', stream: true, rawBody: body } as never,
+        res as never,
+      ).then(() => { settled = true }, () => { settled = true })
+    })
+  })
+  await new Promise<void>((r) => server.listen(0, '127.0.0.1', () => r()))
+  const port = (server.address() as { port: number }).port
+  await new Promise<void>((resolve) => {
+    const creq = http.request({
+      host: '127.0.0.1', port, path: '/x', method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    }, (cres) => { cres.once('data', () => { creq.destroy(); resolve() }) })
+    creq.on('error', () => resolve())
+    creq.end(JSON.stringify({ model: 'sup,m1', messages: [{ role: 'user', content: 'hi' }], stream: true }))
+  })
+  await new Promise((r) => setTimeout(r, 1200))
+  server.closeAllConnections?.()
+  server.close()
+
+  assert.equal(closeSeen, true)
+  assert.equal(settled, true, '带探针的路径也必须收尾')
+  assert.equal(leak.cancelled(), true, '取消必须穿过两层 wrapper 到达上游')
+})
+
+test('聚合失败：reader 必须被解绑（否则连接还活着时上层无法 cancel）', async () => {
+  // 这一条测的**不是**「cancel 回调有没有触发」——那测不出东西：
+  // 实测结论（两个都验过）：
+  //   - 流 error 后调 cancel()，只会以同一错误 reject，**不触发** cancel 回调
+  //     （`pull()` 抛错会把流置为 errored；上游拆连接则流直接 error）
+  //   - 这两种情况下 undici **已经自己关了连接**，不需要我们 cancel
+  // 所以聚合失败路径真正要保证的是 **reader 被解绑**：流锁着的话，上层
+  // （writeChatResult 的失败路径 / 未来的取消逻辑）想 cancel 都会抛
+  // `Invalid state: ReadableStream is locked`，连接就永久漏了。
+  let releaseLocked = false
+  const enc = new TextEncoder()
+  const failing = new ReadableStream<Uint8Array>({
+    start(c) { c.enqueue(enc.encode('data: {"choices":[{"delta":{"content":"a"}}]}\n\n')) },
+    pull() { throw new Error('aggregate read failed') },
+  })
+  const origGetReader = failing.getReader.bind(failing)
+  ;(failing as unknown as { getReader: () => unknown }).getReader = () => {
+    const r = origGetReader()
+    const origRelease = r.releaseLock.bind(r)
+    r.releaseLock = () => { releaseLocked = true; origRelease() }
+    return r
+  }
+
+  const router = new Router('')
+  router.add(supplierWith(failing) as never)
+  const sink = {
+    writeHead: () => undefined, end: () => undefined, write: () => true,
+    once: () => undefined, removeListener: () => undefined, destroy: () => undefined,
+    writableEnded: false, destroyed: false,
+  } as never
+
+  await router.chatCompletions(
+    { model: 'sup,m1', stream: false, rawBody: JSON.stringify({ model: 'sup,m1', messages: [] }) } as never,
+    sink,
+  )
+  await new Promise((r) => setTimeout(r, 150))
+
+  assert.equal(releaseLocked, true, '聚合失败后必须 releaseLock，否则流锁死、上层无法回收')
+  assert.equal(failing.locked, false, '流必须处于未锁定状态（可被 cancel / 已被回收）')
+})