dsh-router-core 0.3.13 → 0.3.15

package/src/client/SupplierDetail.tsx

@@ -62,7 +62,6 @@ function untilLabel(account: RouterAccount): string {
 }
 
 function statusBadge(account: RouterAccount): { text: string; cls: string } {
-  if (account.disabled) return { text: '已禁用', cls: 'dshr-badge-danger' }
   if (account.cooling) return { text: '冷却中', cls: 'dshr-badge-warn' }
   return { text: '健康', cls: 'dshr-badge-ok' }
 }
@@ -666,7 +665,7 @@ export function SupplierDetail({ supplier, accounts, statusLoading, onBack, onRe
               <div className="dshr-linkList">
                 {orderedAccounts.map((account, index) => {
                   const badge = statusBadge(account)
-                  const coolingText = account.cooling || account.disabled
+                  const coolingText = account.cooling
                     ? `${account.reason ?? ''}${untilLabel(account) !== '' ? ` · ${untilLabel(account)}` : ''}`
                     : ''
                   return (

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'), '读不到附件时必须给占位文本，图片不能无声消失')
+})

package/src/llm/adapter.ts

@@ -4,7 +4,11 @@
  * 模型目录 = 组合（自动带出，不可改）。对话转发到本插件 /v1/chat/completions，
  * 由现有路由按组合策略命中供应商模型。
  *
- * 纯文本流：组合为文本模型，本 adapter 不处理图片附件。
+ * 图文流：adapter 声明图片 modal（`inputModalities` 含 `image`），把 user 消息里的
+ * `image` 块序列化成 OpenAI 标准的 `image_url` base64 part，经 /v1 原样透传给
+ * 命中的上游供应商。最终能否看图取决于**命中的那个上游模型**——组合里是异构
+ * 供应商，可能在网关端声明了图片能力、某条上游却只收文本（此时由上游自行拒收）。
+ * 图片字节从 `ctx.attachments` 读取（读不到的按稳定占位文本降级，绝不静默丢图）。
  */
 import {
   EMPTY_RESPONSE_CODE,
@@ -22,6 +26,29 @@ import {
 } from '@deepseek-ai/dsh-llm'
 import { mergeUsage, normalizeUsage, toTokenUsage, type UsageTokens } from '../router/usage-tokens.ts'
 
+/**
+ * dsh-attachment 的最小本地切面：adapter 只依赖「读一张图片的请求版本」
+ * 这一行为，不引入对 dsh-attachment 包编译期/运行期的依赖（它是宿主注入的
+ * devDependency）。本地声明与原包 `AttachmentStore.readImageRequest` 形状一致，
+ * 宿主注入真实 store 时天然满足。
+ */
+export interface RouterAttachmentStore {
+  readImageRequest(
+    ref: { attachmentId: string; mediaType: string; bytes: number; width: number; height: number },
+    policy: { maxPixels: number; maxBytes: number },
+    signal?: AbortSignal,
+  ): Promise<{ mediaType: string; data: Uint8Array }>
+}
+
+/** 一张 image 块的 attachment ref 的最小形状（value 类型，够用即可）。 */
+interface RouterImgLike {
+  attachmentId: string
+  mediaType: string
+  bytes: number
+  width: number
+  height: number
+}
+
 /** 模型目录来源：组合。 */
 export interface RouterAdapterSource {
   /**
@@ -34,7 +61,7 @@ export interface RouterAdapterSource {
 }
 
 /**
- * 把 DSH 消息序列化成 openai 兼容 wire 消息（纯文本 + tool）。
+ * 把 DSH 消息序列化成 openai 兼容 wire 消息（文本 + 图片 + tool）。
  *
  * `system` 必须由调用方从 `options.system` 传进来：one-shot 调用方把系统提示词
  * 放在 **options.system 这个独立槽位**，不放进 messages。不读这个槽位，
@@ -46,8 +73,12 @@ export interface RouterAdapterSource {
  * 可出现在任意位置以支持提示词热更新）。两条路径都必须支持 —— 与官方
  * dsh-llm-deepseek 一致（serializeRequest 前置 options.system，再按位置序列化
  * messages 里的 system 消息）。
+ *
+ * 图片：`image` 块被序列化成 OpenAI `content` 数组里的 `image_url` part（data URI
+ * base64）。图片字节经 `resolveAttachments` 读取；读不到时回退为稳定的占位文本，
+ * **绝不静默丢图**（丢图 = 模型看到一条没有图的消息却毫无提示）。
  */
-function wireMessages(options: GenerateOptions, system?: string): Array<Record<string, unknown>> {
+async function wireMessages(options: GenerateOptions, system: string | undefined, attachments: RouterAttachmentStore | undefined): Promise<Array<Record<string, unknown>>> {
   const out: Array<Record<string, unknown>> = []
   if (typeof system === 'string' && system !== '') {
     out.push({ role: 'system', content: system })
@@ -76,9 +107,16 @@ function wireMessages(options: GenerateOptions, system?: string): Array<Record<s
       continue
     }
     // user / tool-result
-    const text = flattenText(message.content)
     const toolResults = message.content.filter((b) => b.type === 'tool-result')
-    if (text.length > 0 || toolResults.length === 0) out.push({ role: 'user', content: text })
+    // 有图 → content 数组；纯文本 → 保持紧凑字符串 wire 形式不回归。
+    if (hasImageBlock(message.content)) {
+      const parts = await contentParts(message.content, attachments, options.signal)
+      if (parts.length > 0) out.push({ role: 'user', content: parts })
+      else if (toolResults.length === 0) out.push({ role: 'user', content: '' })
+    } else {
+      const text = flattenText(message.content)
+      if (text.length > 0 || toolResults.length === 0) out.push({ role: 'user', content: text })
+    }
     for (const result of toolResults) {
       // 空结果就发空串，不要替换成 '(no output)' 之类的字面量 —— 模型会
       // 以为工具真的打印了那句话（9router 也是补 content: ""）。
@@ -88,9 +126,73 @@ function wireMessages(options: GenerateOptions, system?: string): Array<Record<s
   return out
 }
 
-/** 组装 wire 请求体。 */
-function wireRequest(options: GenerateOptions): Record<string, unknown> {
-  const messages = wireMessages(options, options.system)
+/**
+ * 一块 DSH user/tool-result 内容序列化成 OpenAI content parts（text + image_url）。
+ * 纯文本时返回空数组（上层走紧凑字符串路径）。图片转 base64 data URI；
+ * attachments 缺失或读取失败时回退稳定占位文本（绝不静默丢图）。
+ */
+async function contentParts(
+  blocks: ReadonlyArray<{ type: string }>,
+  attachments: RouterAttachmentStore | undefined,
+  signal: AbortSignal | undefined,
+): Promise<Array<Record<string, unknown>>> {
+  const parts: Array<Record<string, unknown>> = []
+  for (const block of blocks) {
+    if (block.type === 'text') {
+      const text = (block as { text?: string }).text ?? ''
+      if (text.length > 0) parts.push({ type: 'text', text })
+      continue
+    }
+    if (block.type === 'image') {
+      const ref = (block as unknown as { attachment: RouterImgLike }).attachment
+      parts.push(...(await imageParts(ref, attachments, signal)))
+      continue
+    }
+    if (block.type === 'tool-result') {
+      parts.push(...(await contentParts((block as unknown as { content: ReadonlyArray<{ type: string }> }).content, attachments, signal)))
+    }
+    // 其它块（reasoning/tool-call）不属于 user content，忽略
+  }
+  return parts
+}
+
+/** 一张图片 → 一个 OpenAI image_url part（或读不到附件时的占位文本）。 */
+async function imageParts(
+  ref: { attachmentId: string; mediaType: string; bytes: number; width: number; height: number },
+  attachments: RouterAttachmentStore | undefined,
+  signal: AbortSignal | undefined,
+): Promise<Array<Record<string, unknown>>> {
+  if (attachments === undefined) return [{ type: 'text', text: imagePlaceholder(ref.attachmentId) }]
+  try {
+    const img = await attachments.readImageRequest(
+      { attachmentId: ref.attachmentId, mediaType: ref.mediaType, bytes: ref.bytes, width: ref.width, height: ref.height },
+      { maxPixels: 64e4, maxBytes: 1024 * 1024 },
+      signal,
+    )
+    return [{ type: 'image_url', image_url: { url: `data:${img.mediaType};base64,${bytesToBase64(img.data)}` } }]
+  } catch {
+    return [{ type: 'text', text: imagePlaceholder(ref.attachmentId) }]
+  }
+}
+
+/** Uint8Array → base64（browser + node 双环境安全，不依赖 Buffer 全局）。 */
+function bytesToBase64(bytes: Uint8Array): string {
+  let bin = ''
+  const chunk = 0x8000
+  for (let i = 0; i < bytes.length; i += chunk) {
+    bin += String.fromCharCode(...bytes.subarray(i, i + chunk))
+  }
+  return btoa(bin)
+}
+
+/** 读不到图片字节时的稳定占位文本。 */
+function imagePlaceholder(attachmentId: string): string {
+  return `[image omitted because the attached bytes could not be read; attachment ${attachmentId}]`
+}
+
+/** 组装 wire 请求体。图片序列化需要读 attachments，故为异步。 */
+async function wireRequest(options: GenerateOptions, attachments: RouterAttachmentStore | undefined): Promise<Record<string, unknown>> {
+  const messages = await wireMessages(options, options.system, attachments)
   const body: Record<string, unknown> = {
     model: options.model,
     messages,
@@ -136,6 +238,15 @@ function flattenText(blocks: readonly { type: string; text?: string }[]): string
   return blocks.filter((b) => b.type === 'text').map((b) => b.text ?? '').join('')
 }
 
+/** 内容块里（含递归进 tool-result）是否存在 image 块。决定走数组 content 还是字符串。 */
+function hasImageBlock(blocks: readonly { type: string }[]): boolean {
+  for (const b of blocks) {
+    if (b.type === 'image') return true
+    if (b.type === 'tool-result' && hasImageBlock((b as unknown as { content: ReadonlyArray<{ type: string }> }).content)) return true
+  }
+  return false
+}
+
 interface OpenBlock {
   index: number
   kind: 'text' | 'reasoning' | 'tool-call'
@@ -379,11 +490,13 @@ const ROUTER_REASONING_EFFORTS: readonly LlmReasoningEffortInfo[] = [
 export class RouterAdapter extends LlmAdapter {
   private readonly baseURL: string
   private readonly source: RouterAdapterSource
+  private readonly resolveAttachments: () => RouterAttachmentStore | undefined
 
-  constructor(baseURL: string, source: RouterAdapterSource) {
+  constructor(baseURL: string, source: RouterAdapterSource, resolveAttachments?: () => RouterAttachmentStore | undefined) {
     super()
     this.baseURL = baseURL
     this.source = source
+    this.resolveAttachments = resolveAttachments ?? (() => undefined)
   }
 
   providerInfo(provider: string): { id: string; name: string } {
@@ -403,14 +516,14 @@ export class RouterAdapter extends LlmAdapter {
   }
 
   /**
-   * 只收文本。`resolveModel` 声明 `inputModalities: ['text']` 是**必须**的：
-   * 0.1.5 的 runtime 只在 `inputModalities` 存在且不含 `image` 时才把 image 块
-   * 投影成占位文本（见 dsh-llm adapterStream 的 projectImagesForTextModel）。
-   * 不声明 = "unknown" = 不投影，而 wireMessages 只读 text 块 → 图片**静默
-   * 丢失**，模型看到一条没有图片的用户消息却毫无提示。声明后由 runtime 统一
-   * 投影，我们仍只处理文本。
+   * 声明图文：`inputModalities` 必须同时含 `text` 与 `image`。
+   * - 含 `image`：runtime/subagent 的模态门禁放行（不再抛
+   *   `MODEL_DOES_NOT_SUPPORT_IMAGES` = 界面「当前模型不支持图片」），
+   *   `projectImagesForTextModel` 也不会把图片块投影成占位文本。
+   * - 组合背后是异构供应商，**统一声明图片能力**；真正能否看图取决于命中
+   *   的某个上游模型（供应商各模型 capability 不同，网关端不能一刀切拦截）。
    */
-  private static readonly INPUT_MODALITIES: readonly ModelModality[] = ['text']
+  private static readonly INPUT_MODALITIES: readonly ModelModality[] = ['text', 'image']
 
   async resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo> {
     const combos = await this.source.comboModels()
@@ -430,7 +543,7 @@ export class RouterAdapter extends LlmAdapter {
   }
 
   async *stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
-    const body = wireRequest(options)
+    const body = await wireRequest(options, this.resolveAttachments())
     const controller = new AbortController()
     const onAbort = (): void => controller.abort()
     options.signal?.addEventListener('abort', onAbort, { once: true })

package/src/router/account-pool.test.ts

@@ -1,10 +1,11 @@
 /**
- * 账号池（核心策略）测试 —— 选号/冷却/禁用/遍历回退。
+ * 账号池（核心策略）测试 —— 选号/冷却/遍历回退。
  *
  * 关键语义（v2）：
  *   - 冷却单元 = (supplierId, modelId, uid)。某连接在模型 A 上失败，只冷
  *     (A, 该连接)，该连接调模型 B 不受影响。
- *   - 禁用(session_dead) = 连接级(uid)：该号所有模型都不可用。
+ *   - session_dead = 连接级(uid)可恢复冷却：该号所有模型都不可用，到期自愈。
+ *     **没有永久禁用**——403 分不清凭证死活与风控误伤，误伤号不该被钉死。
  *   - no_such_model 不惩罚账号（模型不属于本供应商不是号的错）。
  * 用 node --test 跑（Node 原生 TS 剥离，零新依赖）。
  */
@@ -327,16 +328,18 @@ test('【颗粒度】同一连接对不同模型的退避独立累加/清零', (
   assert.equal(p.decorate(list, 'm1')[0]?.err_count, 0)
 })
 
-// ============ 连接级禁用(跨模型) ============
+// ============ 连接级冷却(跨模型, session_dead) ============
 
-test('【颗粒度】session_dead 是连接级禁用：跨该号所有模型', () => {
+test('【颗粒度】session_dead 是连接级冷却：跨该号所有模型，到期自愈', () => {
   const p = pool()
   const list = accs(['a'])
   p.noteFailure('a', 'm1', 'session_dead', '凭证失效')
   // 该号在 m1、m2 上都不可用（登录态问题，不是模型问题）
   assert.equal(p.pick(list, [], 'fallback', 'm1'), undefined)
   assert.equal(p.pick(list, [], 'fallback', 'm2'), undefined)
-  assert.equal(p.decorate(list)[0]?.disabled, true)
+  const d = p.decorate(list)[0]
+  assert.equal(d?.cooling, true)
+  assert.ok(d?.until !== undefined, 'session_dead 冷却必须有 until（可恢复）')
 })
 
 test('处置：未知错误第一次就冷却（坏号不留在池里等下一次撞）', () => {
@@ -347,7 +350,7 @@ test('处置：未知错误第一次就冷却（坏号不留在池里等下一
   assert.equal(p.pick(list.filter((x) => x.uid === 'a'), [], 'fallback', 'm1'), undefined)
 })
 
-test('decorate：把冷却/禁用叠加到插件报的「现在状态」上（聚合展示）', () => {
+test('decorate：把冷却叠加到插件报的「现在状态」上（聚合展示）', () => {
   const p = pool()
   const list: SupplierAccountNow[] = [
     { uid: 'ok', credits: 5, state: 'ok' },
@@ -359,10 +362,9 @@ test('decorate：把冷却/禁用叠加到插件报的「现在状态」上（
   const out = p.decorate(list)
   const by = new Map(out.map((a) => [a.uid, a]))
   assert.equal(by.get('ok')?.cooling, false)
-  assert.equal(by.get('ok')?.disabled, false)
   assert.equal(by.get('cool')?.cooling, true)
   assert.equal(by.get('cool')?.until !== undefined, true)
-  assert.equal(by.get('dead')?.disabled, true)
+  assert.equal(by.get('dead')?.cooling, true, 'session_dead 连接级冷却也展示为冷却中')
   // 插件报的字段要原样透出（不能被 decorate 吃掉）
   assert.equal(by.get('ok')?.credits, 5)
 })
@@ -375,7 +377,6 @@ test('no_such_model 不惩罚账号：不冷却、不计数', () => {
   assert.equal(p.pick(list, [], 'fallback', 'm1'), 'a')
   const out = p.decorate(list, 'm1')[0]
   assert.equal(out?.cooling, false)
-  assert.equal(out?.disabled, false)
   assert.equal(out?.err_count, 0)
 })
 
@@ -389,7 +390,7 @@ test('状态表：各 AccountState 的处置符合预期', () => {
   const by = new Map(p.decorate(list).map((a) => [a.uid, a]))
   assert.equal(by.get('rate')?.cooling, true)
   assert.equal(by.get('quota')?.cooling, true)
-  assert.equal(by.get('dead')?.disabled, true)
+  assert.equal(by.get('dead')?.cooling, true, 'session_dead = 连接级冷却')
   assert.equal(by.get('unavail')?.cooling, true, '瞬时错误第一次就冷却')
   assert.equal(p.pick(list, [], 'fallback', 'm1'), undefined, '四个号都不可服务')
 })