dsh-router-core 0.3.12 → 0.3.14

package/lib/types/router/account-pool.d.ts

@@ -31,10 +31,14 @@ export declare class AccountPool {
     /** uid → 连接级禁用 / 手动暂停。 */
     private byUid;
     private rrCursor;
-    /** (supplier, model) → 块轮询驻留状态。 */
+    /** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
     private blocks;
+    /** (supplier, model, uid) → 该号的缓存质量样本（降权判据，跨驻留累计）。 */
+    private samples;
     /** (supplier, model, uid) → 缓存无效降权。 */
     private demoted;
+    /** (supplier, model) → Map<前缀指纹, uid>：前缀亲和的选号记忆（LRU 封顶）。 */
+    private affinity;
     constructor(supplierId?: string);
     private key;
     private entry;
@@ -51,26 +55,34 @@ export declare class AccountPool {
     /**
      * 按策略为「某个模型」选一个健康账号。
      *
-     * round-robin 走**块轮询**：一次轮转内连续服务若干请求，而不是每请求换号。
-     * 设计见 docs/pool-sticky-block.md。要点：
-     *  - 留守 = `计数 < N OR 命中率 < M`(OR,用户拍板):
-     *    命中率达标（缓存热了）→ 换号保均衡；计数到 N → 换号止损。
-     *    单号最多连续服务 N 次，不会因命中率低而死守到 N_max（打架场景关键）。
-     *  - 切号因子的思路：命中率是**留守**条件不是切号条件。反接会正反馈死锁
-     *    （切→cold miss→命中率 0%→触发切号→…），见文档 §3。
-     *  - `N_max` 绝对兜底：命中率永远不达标的号不能无限驻留（防死锁 + 防均衡归零）。
+     * round-robin = **前缀亲和定号 + 块统计只用来判定缓存无效**：
+     *
+     *  1. 算请求的前缀指纹（messages 前几条），查绑定表 → 命中且该号健康 → 用它。
+     *     这是第一优先：同一个会话的连续请求**永远落回同一个号**，前缀在该号的
+     *     缓存里只写一份。块轮询治不了跨会话驱逐（多会话大前缀在同一号互踩，
+     *     实测 3 会话 3.8% vs 单会话 82.5%），亲和才是根治。
+     *  2. 新指纹（或绑定的号不健康）→ 按游标挑一个号并**记下绑定**，之后就固定。
+     *     新会话用游标分发，所以不同会话天然散到不同号上（均衡）。
+     *  3. 块统计不再驱动轮转（亲和已经保证驻留，再轮转只会把会话踢出已热前缀），
+     *     只保留 `BLOCK_MAX` 次不达标 → 降权该号（缓存无效，可恢复）。
+     *
+     * 亲和失效（拿不到 messages / 指纹算不出）时**回退到块轮询**，行为与之前一致。
+     * 设计见 docs/pool-sticky-block.md §8。
      *
      * @param accounts 插件报告的「现在状态」（顺序即插件的自然顺序）
      * @param poolOrder 用户在面板拖出来的顺序（核心管）
-     * @param strategy fallback 取第一个健康 / round-robin 块轮转健康号
+     * @param strategy fallback 取第一个健康 / round-robin 前缀亲和
      * @param modelId 当前要路由的模型（决定查哪个 (model, uid) 冷却单元）
+     * @param messages 请求体的 messages（可选；给了才能算前缀指纹）
      * @returns 选中的 uid；无健康账号返回 undefined
      */
-    pick(accounts: SupplierAccountNow[], poolOrder: string[], strategy: string, modelId: string): string | undefined;
+    pick(accounts: SupplierAccountNow[], poolOrder: string[], strategy: string, modelId: string, messages?: unknown): string | undefined;
+    /** 记下「前缀指纹 → 号」的绑定（LRU：超上限丢最久未用的）。 */
+    private bind;
     /** 该号在本模型上是否被判定「缓存无效」（降权中）。 */
     private isDemoted;
     /**
-     * 块是否还应驻留在当前号上。
+     * 驻留是否还应留在当前号上（**只用于无亲和的回退路径**）。
      *
      * OR 语义（用户拍板）：`留守 = 计数 < N OR 命中率 < M`。
      * 单一账号内部：一个号先被轮到（冷启动/热），然后
@@ -80,22 +92,20 @@ export declare class AccountPool {
      *
      * 关键：命中率是**留守**条件不是切号执行器（反接会正反馈死锁，
      * 见文档 §3）。换号由「命中达标 OR 份额用够」触发，都不是「命中率低」。
-     *
-     * 每个号各自守着「这个会话在自己账号上的那段前缀」，轮流热；
-     * 命中率 = 块的命中占比。单会话下每个号块都从冷到热各付一次,
-     * 收益来自块内连续驻留(缺了它就跟每请求轮询一样)。
      */
     private blockKeeps;
     /**
-     * 记录一次成功请求的缓存命中情况（块轮询的反馈信号）。
+     * 记录一次成功请求的缓存命中情况（降权判据的反馈信号）。
      *
-     * 只有**成功**请求才计入：失败没产生缓存，计入会污染命中率并导致错切。
+     * 只有**成功**请求才计入：失败没产生缓存，计入会污染命中率并导致错降权。
+     * 统计按 (model, uid) 记，**不管这个号是不是「当前驻留」**——亲和开启后
+     * 多个会话各绑各的号交错服务，按驻留记会漏掉大部分真实反馈。
      * @param uid 实际服务的号
      * @param modelId 模型（块粒度）
      * @param cachedTokens 上游报的命中 token 数；0 = 全量重算
      */
     noteCache(uid: string, modelId: string, cachedTokens: number): void;
-    /** 故障切走时作废当前块：换号后前缀归属变了，块计数不能沿用。 */
+    /** 故障切走时作废当前驻留：换号后前缀归属变了，驻留计数不能沿用。 */
     dropBlock(modelId: string): void;
     /** 块状态键：与冷却同粒度 (supplier, model)，不含 uid。 */
     private blockKey;

package/lib/types/router/prefix-affinity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 算请求的前缀指纹。
+ * @param messages OpenAI 请求体的 `messages` 字段（未校验，来自外部输入）
+ * @returns 指纹字符串；**空串 = 算不出来（无亲和，回退到块轮询）**
+ */
+export declare function prefixFingerprint(messages: unknown): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "DSH plugin: a simplified 9router (AI routing gateway). Adds a 路由系统 (Routing System) sidebar entry beside 记忆系统; the panel shows suppliers, account pool, combos, and endpoint/API keys.",
   "type": "module",
   "repository": {
@@ -64,11 +64,15 @@
     "prepublishOnly": "npm run build && node scripts/check-publish.mjs --pack"
   },
   "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-locale": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-settings": "^0.1.5-rc.2",
     "cordis": "^4.0.0-rc.7",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
@@ -85,7 +89,7 @@
     }
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-llm": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.1",
     "@types/node": "^26.4.1",
     "@types/react": "~19.2.18",
     "@types/react-dom": "~19.2.7",

package/src/client/SupplierDetail.tsx

@@ -908,7 +908,7 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
             </>
             <>
               <label className="dshr-fieldLabel">连接池策略</label>
-              <p className="dshr-muted">回退 = 按连接池顺序取第一个健康链接；轮询 = 轮流使用健康链接。</p>
+              <p className="dshr-muted">回退 = 按连接池顺序取第一个健康链接；轮询 = 按会话前缀粘住同一链接（前缀亲和，多会话不打架），拿不到会话信息时退回块轮转。</p>
               <select
                 className="dshr-select dshr-input"
                 value={poolStrategy}

package/src/client/index.tsx

@@ -11,6 +11,7 @@
 import { mountRouterWorkspace } from './workspace-mount.tsx'
 import { RouterSettingsSection } from './settings-section.tsx'
 import { registerSettingsNavIcon } from './settings-nav-icon.ts'
+import { rewriteRouterModelHint } from './model-hint-copy.ts'
 import './router.css'
 
 /**
@@ -65,4 +66,6 @@ export function apply(ctx: Ctx): void {
   ctx.effect(() => disposeSettings, 'dsh-router: settings section')
   // 换掉宿主的默认齿轮（契约没有 icon 字段，只能注册后认领自己的行）
   ctx.effect(() => registerSettingsNavIcon(SECTION_LABEL), 'dsh-router: settings nav icon')
+  // 设置-模型 里 Router 卡片的那句死路提示 → 正确说法（同样只能认领后就地改写）
+  ctx.effect(() => rewriteRouterModelHint(), 'dsh-router: models provider hint copy')
 }

package/src/client/model-hint-copy.test.ts

@@ -0,0 +1,31 @@
+/**
+ * 改写判据测试 —— 锁定「识别宿主提示」与「不自激」两条。
+ *
+ * 为什么要有：这个改写是按文案指纹认领宿主 DOM（见 model-hint-copy.ts）。
+ * 判据写错有两种坏法：漏认（提示原样留着）和自激（改完又被自己判定为需要改，
+ * 观察器反复触发）。两条都是纯函数可测的。
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { routerHintRewrite, ROUTER_MODEL_HINT_COPY } from './model-hint-copy.ts'
+
+test('认出宿主提示（中/英两种文案 + 命名空间指纹）', () => {
+  const zh = '其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-dsh-router)'
+  const en = 'Other fields live in settings.yaml; edit that section directly. (llm-dsh-router)'
+  assert.equal(routerHintRewrite(zh), ROUTER_MODEL_HINT_COPY)
+  assert.equal(routerHintRewrite(en), ROUTER_MODEL_HINT_COPY)
+})
+
+test('别的 provider 的同类提示不动（指纹只属于 Router）', () => {
+  const deepseek = '其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-deepseek)'
+  assert.equal(routerHintRewrite(deepseek), undefined)
+})
+
+test('已是目标文案时早退 —— 观察器不自激', () => {
+  assert.equal(routerHintRewrite(ROUTER_MODEL_HINT_COPY), undefined)
+})
+
+test('无关段落一律不动', () => {
+  assert.equal(routerHintRewrite(''), undefined)
+  assert.equal(routerHintRewrite('配置 DeepSeek 官方模型，即可开始使用。'), undefined)
+})

package/src/client/model-hint-copy.ts

@@ -0,0 +1,55 @@
+/**
+ * 设置-模型 → Router 卡片：把宿主那句走不通的提示换成正确说法。
+ *
+ * 为什么不能直接改源头：Router 的卡片走宿主的 "unknown" 布局（宿主只认得
+ * llm-deepseek / llm-pi-ai 两套表单），那句
+ *   「其余字段在 settings.yaml 中，请直接编辑对应段。 (llm-dsh-router)」
+ * 属于宿主 `settings.models` 的 locale 字典，而字典注册对同一个 (ns, locale)
+ * 只允许一个占位者（重复注册直接抛），插件覆写不了，契约也没给可覆写字段。
+ * 所以沿用本插件既有的认领手法（同 settings-nav-icon.ts）：按文案指纹认出宿主
+ * 渲染的那一段，就地改写。
+ *
+ * 只写 `nodeValue`、不增删节点（节点归 React，摘掉会让它的引用落空）。React 重渲染
+ * 覆盖回来时观察器会再改一次；已是目标文案就早退，不会自激。
+ *
+ * 升级路径：宿主若给该提示长出可覆写字段（或 Router 有了专属布局），删掉本文件。
+ */
+
+/** 指纹：语言无关（不受中英文切换影响），且只出现在 Router 卡片上。 */
+const FINGERPRINT = '(llm-dsh-router)'
+
+/** 正确说法：对齐 README「组合即模型」。 */
+export const ROUTER_MODEL_HINT_COPY = '组合即模型 · 建好的组合会自动出现在 DSH 模型目录中，选中组合名即可直接使用。'
+
+/**
+ * 这段文本要不要改写。
+ * @param text 段落当前文本
+ * @returns 需要改写时给出目标文案，否则 undefined
+ */
+export function routerHintRewrite(text: string): string | undefined {
+  if (!text.includes(FINGERPRINT)) return undefined
+  if (text === ROUTER_MODEL_HINT_COPY) return undefined // 已改过，早退防自激
+  return ROUTER_MODEL_HINT_COPY
+}
+
+/**
+ * 持续把 Router 卡片里的宿主提示改写成 {@link ROUTER_MODEL_HINT_COPY}。
+ * @returns 清理函数：断开观察
+ */
+export function rewriteRouterModelHint(): () => void {
+  const sync = (): void => {
+    for (const el of document.querySelectorAll<HTMLElement>('p[class*="advancedHint"]')) {
+      const next = routerHintRewrite(el.textContent ?? '')
+      // 宿主把整句渲染成一个文本节点（单个模板串）——直接整段替换
+      const node = el.firstChild
+      if (next === undefined || node?.nodeType !== Node.TEXT_NODE) continue
+      node.nodeValue = next
+    }
+  }
+
+  sync()
+  // 设置面板按需挂载、React 重渲染都会覆盖回去，子树变动时重新认领
+  const observer = new MutationObserver(sync)
+  observer.observe(document.body, { childList: true, subtree: true, characterData: true })
+  return () => observer.disconnect()
+}

package/src/index.ts

@@ -31,9 +31,10 @@
  */
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { join } from 'node:path'
+import Schema from '@deepseek-ai/schemastery'
 import { ROUTER_API_BASE, type RouterPeriod } from './shared.ts'
 import { Router } from './router/index.ts'
-import { RouterAdapter } from './llm/adapter.ts'
+import { RouterAdapter, type RouterAttachmentStore } from './llm/adapter.ts'
 import { KeysStore } from './keys.ts'
 import { loadSuppliers, wrapModule, type LoadedSupplier } from './suppliers/loader.ts'
 import { supplierRoutes } from './suppliers/registry.ts'
@@ -94,6 +95,29 @@ interface Llm {
   registerAdapter: (providers: readonly string[], adapter: unknown) => () => void
 }
 
+/**
+ * 设置服务（`ctx.settings`，dsh-settings）的最小切面：本插件只用 `installSection`
+ * 注册一个命名空间，让设置-模型页能列出 Router provider 卡片。dsh-settings 是
+ * 宿主注入的 peer service，这里不深绑它的类型，只声明用到的这一个方法。
+ */
+interface SettingsServiceFace {
+  installSection: (
+    owner: CordisContext,
+    ns: string,
+    schema: unknown,
+    entry: unknown,
+    hooks: { setSource: (current: () => unknown) => void; onChange: () => void },
+  ) => void
+}
+
+/**
+ * cordis Context 的最小切面。`installSection(owner)` 只会对 owner 调
+ * `ctx.effect(...)` 并在卸载时读 `fiber.state`，所以这里只声明 `effect`。
+ */
+interface CordisContext {
+  effect: (fn: () => () => void, label?: string) => unknown
+}
+
 function writeJson(res: ServerResponse, status: number, body: unknown): void {
   const payload = JSON.stringify(body)
   res.writeHead(status, {
@@ -574,14 +598,35 @@ export function apply(rawContext: unknown): void {
         const combos = await router.combos()
         return combos.map((c) => ({ id: c.name }))
       }))
+      // Router 的配置（组合/密钥/签到）存在 core 自己的 state.json，走插件自己的
+      // 「路由系统」面板；设置-模型 这边**仍必须注册 `llm-dsh-router` 命名空间**。
+      // 原因：设置-模型 的 provider 列表只渲染 settingsNs 能在设置镜像里解析出来的
+      // 行（见 dsh-client-ui-settings-models 的 configurable 过滤）。只调
+      // registerConfigurableProviders 而不注册 section，Router 卡片**不会出现**。
+      // 空 schema = 卡片是入口/占位（该布局下不可提交），真正的配置在路由系统面板。
+      const routerSettingsSchema = Schema.object({})
+      ctx.inject(['settings'], (sctx: unknown) => {
+        const settings = (sctx as { settings?: SettingsServiceFace }).settings
+        if (settings === undefined) {
+          log('settings service absent — skip Router settings-section registration')
+          return
+        }
+        settings.installSection(rawContext as CordisContext, LLM_NS, routerSettingsSchema, {}, {
+          setSource: () => {},
+          onChange: () => {},
+        })
+        log(`Router settings section registered (${LLM_NS})`)
+      })
       // adapter：模型目录自动带出组合；对话转发到本插件 /v1（组合路由在 /v1 内完成）。
       // 带上组合的上下文窗口：没有它 dsh 的自动压缩算不出阈值、会静默关闭。
+      // 图片序列化需要读附件字节：把 ctx.attachments 传给 adapter（dsh-attachment
+      // 是宿主注入的 service，插件不直接 import 它，只依赖 duck-typed 切面）。
       disposers.push(ctx.llm.registerAdapter(['router'], new RouterAdapter('http://localhost:3080/v1', {
         comboModels: async () => (await router.combos()).map((c) => {
           const w = router.comboContextWindow(c)
           return { id: c.name, ...(w !== undefined ? { contextWindow: w } : {}) }
         }),
-      })))
+      }, () => ctx.get('attachments') as RouterAttachmentStore | undefined)))
       log('llm provider (Router) + discovery + adapter registered ok')
       // 预热模型缓存：`comboContextWindow` 只读缓存、不打上游，缓存空着就
       // 报不出窗口。这里后台填一次，让第一次 resolveModel 就有值。
@@ -616,11 +661,25 @@ export function apply(rawContext: unknown): void {
     } catch (err) {
       registeredProviders = `error: ${(err as Error).message}`
     }
+    // 设置命名空间是否注册成功 —— 卡片不出现的**唯一**嫌疑点：provider 在目录里
+    // （上面的 directory）却没注册 section 时，设置-模型 的 configurable 过滤会
+    // 把该行整条丢掉，界面上什么都不显示、也没有任何报错。
+    let settingsNamespaces: unknown = 'n/a'
+    try {
+      const settings = ctx.get('settings') as { describe?: (opts?: unknown) => Array<{ ns: string }> } | undefined
+      settingsNamespaces = settings?.describe === undefined
+        ? 'no settings service'
+        : settings.describe({ redactSecrets: true }).map((d) => d.ns)
+    } catch (err) {
+      settingsNamespaces = `error: ${(err as Error).message}`
+    }
     writeJson(res, 200, {
       ok: true,
       llmAvailable: ctx.llm !== undefined,
       directory,
       registeredProviders,
+      settingsNamespaces,
+      routerNamespaceRegistered: Array.isArray(settingsNamespaces) && settingsNamespaces.includes('llm-dsh-router'),
     })
   })
 

package/src/llm/adapter.test.ts

@@ -519,6 +519,9 @@ test('模型目录：resolveModel 对每个组合声明推理等级（off/low/hi
   assert.equal(a.provider, 'router')
   assert.equal(a.id, 'c-a')
   assert.equal(a.name, '组合A')
+  // 图文模态：必须声明含 image，否则 runtime/subagent 的模态门禁会抛
+  // `MODEL_DOES_NOT_SUPPORT_IMAGES`（界面「当前模型不支持图片」）。
+  assert.deepEqual(a.inputModalities, ['text', 'image'], 'adapter 必须声明 image 模态，否则图片被门禁拦截')
   assert.ok(a.reasoning, '组合应声明推理等级，DSH 才允许显式 effort')
   assert.deepEqual(a.reasoning!.efforts.map((e) => e.id), ['off', 'low', 'high', 'max'])
   assert.equal(a.reasoning!.defaultEffort, 'high', '默认 High：调用方不指定时物化为 high')
@@ -543,3 +546,82 @@ test('resolveModel 透传组合的 contextWindow（自动压缩才能算阈值
   const b = await adapter.resolveModel('router', 'c-b')
   assert.equal(b.context, undefined, '没拿到就不声明 context，绝不填一个假窗口')
 })
+
+/* ---------------- 图片序列化：图片必须真正到上游（不静默丢图） ---------------- */
+
+/** 假附件 store：返回指定 mediaType + bytes 的请求版本。 */
+function fakeAttachments(mediaType = 'image/png', data = new TextEncoder().encode('<png-bytes>')): {
+  readImageRequest: () => Promise<{ mediaType: string; data: Uint8Array }>
+} {
+  return {
+    readImageRequest: async () => ({ mediaType, data }),
+  }
+}
+
+/** 用给定 attachments 跑一次 stream()，返回上游收到的 body。 */
+async function captureBodyWith(options: Record<string, unknown>, attachments?: unknown): Promise<Record<string, unknown>> {
+  let captured: Record<string, unknown> = {}
+  globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+    captured = JSON.parse(init?.body ?? '{}') as Record<string, unknown>
+    return new Response('data: [DONE]\n\n', { status: 200 })
+  }) as typeof fetch
+  const adapter = new RouterAdapter(
+    'http://x',
+    { comboModels: async () => [] },
+    () => attachments as never,
+  )
+  for await (const _c of adapter.stream({ model: 'm', messages: [], signal: AbortSignal.timeout(3000), ...options } as never)) {
+    void _c
+  }
+  return captured
+}
+
+test('wire：图片块被序列化成 OpenAI image_url base64 part（不再静默丢图）', async () => {
+  const ref = {
+    attachmentId: 'sha256:abcdef1234567890',
+    mediaType: 'image/png',
+    bytes: 11,
+    width: 4,
+    height: 2,
+  }
+  const body = await captureBodyWith({
+    messages: [{ role: 'user', content: [
+      { type: 'text', text: '看这张图' },
+      { type: 'image', attachment: ref },
+    ] }],
+  }, fakeAttachments())
+  const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
+  const parts = (user?.content ?? []) as Array<{ type: string; text?: string; image_url?: { url: string } }>
+  assert.equal(parts.length, 2, 'text + image 两个 part')
+  assert.equal(parts[0]?.type, 'text')
+  assert.equal(parts[0]?.text, '看这张图')
+  assert.equal(parts[1]?.type, 'image_url', '图片必须是 image_url part，不是占位文本')
+  const b64 = btoa(String.fromCharCode(...new TextEncoder().encode('<png-bytes>')))
+  assert.equal(parts[1]?.image_url?.url, `data:image/png;base64,${b64}`, 'data URI 必须是 base64 编码的真实字节')
+})
+
+test('wire：纯文本 user 消息仍是紧凑字符串（不回归 wire 形式）', async () => {
+  const body = await captureBodyWith({
+    messages: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+  }, fakeAttachments())
+  const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
+  assert.equal(user?.content, 'hi', '无图时必须保持字符串 content')
+})
+
+test('wire：无 attachments 时图片回退占位文本，绝不静默丢图', async () => {
+  const ref = {
+    attachmentId: 'sha256:abcdef1234567890',
+    mediaType: 'image/png',
+    bytes: 11,
+    width: 4,
+    height: 2,
+  }
+  const body = await captureBodyWith({
+    messages: [{ role: 'user', content: [{ type: 'image', attachment: ref }] }],
+  }, undefined)
+  const user = (body.messages as Array<{ role: string; content: unknown }>).find((m) => m.role === 'user')
+  const parts = (user?.content ?? []) as Array<{ type: string; text?: string }>
+  assert.equal(parts.length, 1)
+  assert.equal(parts[0]?.type, 'text')
+  assert.ok((parts[0]?.text ?? '').includes('image omitted'), '读不到附件时必须给占位文本，图片不能无声消失')
+})