dsh-router-core 0.2.0 → 0.3.1

package/src/router/models-cache.test.ts

@@ -142,6 +142,219 @@ test('未知供应商返回空，不抛错', async () => {
   assert.deepEqual(await router.modelsOf('nonexistent'), [])
 })
 
+/**
+ * 回归：客户端要非流式、供应商只给流（如 codebuddy 强制 stream:true）时，
+ * 核心必须聚合成 JSON——响应写入归核心，协议错配得核心吸收。
+ * 否则客户端按 JSON 解析会在 SSE delta 里找不到工具名，报 unknown tool ""。
+ */
+test('要 JSON 却拿到流 → 聚合成非流式响应，工具名不丢', async () => {
+  const router = new Router('')
+  const cb = supplier('cb', [{ id: 'hy4-preview' }])
+  // 模拟只支持流式的供应商：name 在首块，arguments 分两段
+  cb.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      start(c) {
+        const enc = new TextEncoder()
+        c.enqueue(enc.encode('data: {"id":"cmpl-1","model":"hy4-preview","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_1","type":"function","function":{"name":"bash","arguments":""}}]}}]}\n\n'))
+        c.enqueue(enc.encode('data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\\"command\\": \\"ls -la\\"}"}}]}}]}\n\n'))
+        c.enqueue(enc.encode('data: {"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}],"usage":{"total_tokens":42}}\n\n'))
+        c.enqueue(enc.encode('data: [DONE]\n\n'))
+        c.close()
+      },
+    }),
+  })
+  addSupplier(router, cb.s)
+
+  let ctype = ''
+  let out = ''
+  const res = {
+    writeHead: (_c: number, h?: Record<string, string>): void => { ctype = h?.['Content-Type'] ?? '' },
+    write: (b: Uint8Array | string): boolean => { out += Buffer.from(b).toString(); return true },
+    end: (b?: Uint8Array | string): void => { if (b !== undefined) out += Buffer.from(b).toString() },
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+
+  await router.chatCompletions({ model: 'cb/hy4-preview', stream: false, rawBody: JSON.stringify({ model: 'cb/hy4-preview', stream: false, messages: [] }) }, res)
+
+  assert.match(ctype, /application\/json/, `客户端要 JSON 就该给 JSON，实际 ${ctype}`)
+  const o = JSON.parse(out) as { choices?: Array<{ message?: { tool_calls?: Array<{ function?: { name?: string; arguments?: string } }> }; finish_reason?: string }>; usage?: unknown }
+  const tc = o.choices?.[0]?.message?.tool_calls?.[0]
+  assert.equal(tc?.function?.name, 'bash', '工具名必须保住（否则下游 unknown tool ""）')
+  assert.deepEqual(JSON.parse(tc?.function?.arguments ?? ''), { command: 'ls -la' }, '分段的 arguments 要拼成合法 JSON')
+  assert.equal(o.choices?.[0]?.finish_reason, 'tool_calls')
+  assert.ok(o.usage !== undefined, 'usage 要带上')
+})
+
+test('要流式就原样流式，不能被聚合（否则首字节延迟爆炸）', async () => {
+  const router = new Router('')
+  const cb = supplier('cb', [{ id: 'm' }])
+  cb.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      start(c) { c.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"hi"}}]}\n\ndata: [DONE]\n\n')); c.close() },
+    }),
+  })
+  addSupplier(router, cb.s)
+
+  let ctype = ''
+  let out = ''
+  const res = {
+    writeHead: (_c: number, h?: Record<string, string>): void => { ctype = h?.['Content-Type'] ?? '' },
+    write: (b: Uint8Array | string): boolean => { out += Buffer.from(b).toString(); return true },
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+
+  await router.chatCompletions({ model: 'cb/m', stream: true, rawBody: JSON.stringify({ model: 'cb/m', stream: true, messages: [] }) }, res)
+
+  assert.match(ctype, /event-stream/, '要流式就该给 SSE')
+  assert.ok(out.includes('data: [DONE]'), '原始 SSE 帧要原样透传')
+})
+
+/** 请求日志要能回答「这个组合到底用的哪个模型和账号」——排障全靠它。 */
+test('每次 chat 记一行：组合名 → 供应商/模型 (账号) 结果', async () => {
+  const lines: string[] = []
+  const router = new Router('', undefined, (m) => lines.push(m))
+  const ok = supplier('supA', [{ id: 'a-m' }])
+  addSupplier(router, ok.s)
+  assert.equal(router.createCombo('combo1', 'fallback', ['supA,a-m']).ok, true)
+
+  const res = {
+    writeHead: (): void => {},
+    write: (): boolean => true,
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+  await router.chatCompletions({ model: 'combo1', stream: false, rawBody: JSON.stringify({ model: 'combo1', messages: [] }) }, res)
+
+  assert.equal(lines.length, 1)
+  assert.match(lines[0] ?? '', /^chat "combo1" → supA\/a-m \(u1\) ok \d+ms$/, `日志格式不对: ${lines[0]}`)
+})
+
+test('失败的成员也要记，且带真实原因（不能笼统写 no account）', async () => {
+  const lines: string[] = []
+  const router = new Router('', undefined, (m) => lines.push(m))
+  const dead = supplier('dead', [{ id: 'dead-m' }])
+  dead.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({ start(c) { c.error(new Error('刚连上就断')) } }),
+  })
+  const live = supplier('live', [{ id: 'live-m' }])
+  addSupplier(router, dead.s)
+  addSupplier(router, live.s)
+  assert.equal(router.createCombo('c1', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+
+  const res = {
+    writeHead: (): void => {},
+    write: (): boolean => true,
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+  await router.chatCompletions({ model: 'c1', stream: true, rawBody: JSON.stringify({ model: 'c1', messages: [] }) }, res)
+
+  assert.equal(lines.length, 2, '每个成员一行')
+  assert.ok((lines[0] ?? '').includes('dead/dead-m 失败'), `失败成员要记: ${lines[0]}`)
+  assert.ok((lines[0] ?? '').includes('stream failed before first byte'), `要带真实原因: ${lines[0]}`)
+  assert.ok((lines[1] ?? '').includes('ok'), `成功的要记: ${lines[1]}`)
+})
+
+/**
+ * 回归：上游「刚连上就断」时组合必须回退到下一个模型。
+ * 之前 writeChatResult 先写响应头再 pipe，且把 pipe 错误吞掉 —— 于是返回
+ * 「成功」但一个字节都没写，客户端拿到空/截断的 SSE，表现为工具调用名是
+ * 空串（Tool call Error: unknown tool ""）。
+ */
+test('流在写出第一个字节前就断 → 组合回退到下一个模型', async () => {
+  const router = new Router('')
+  const dead = supplier('dead', [{ id: 'dead-m' }])
+  dead.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({ start(c) { c.error(new Error('上游刚连上就断')) } }),
+  })
+  const live = supplier('live', [{ id: 'live-m' }])
+  // 兜底模型要返回真的 SSE 流，才贴近组合的真实场景
+  live.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      start(c) {
+        c.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"兜底"}}]}\n\ndata: [DONE]\n\n'))
+        c.close()
+      },
+    }),
+  })
+  addSupplier(router, dead.s)
+  addSupplier(router, live.s)
+  assert.equal(router.createCombo('c1', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+
+  let out = ''
+  let heads = 0
+  const res = {
+    writeHead: (): void => { heads += 1 },
+    write: (b: Uint8Array | string): boolean => { out += Buffer.from(b).toString(); return true },
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+  await router.chatCompletions({ model: 'c1', stream: true, rawBody: JSON.stringify({ model: 'c1', messages: [] }) }, res)
+
+  assert.ok(out.includes('[DONE]'), `应拿到完整响应，实际: ${JSON.stringify(out)}`)
+  assert.equal(heads, 1, '响应头只应提交一次')
+})
+
+test('已写出字节后断流 → 诚实截断，不回退也不二次写头', async () => {
+  const router = new Router('')
+  const half = supplier('half', [{ id: 'half-m' }])
+  half.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      async start(c) {
+        c.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"半截"}}]}\n\n'))
+        await new Promise((r) => setTimeout(r, 30)) // 确保字节已投递
+        c.error(new Error('上游中途断流'))
+      },
+    }),
+  })
+  const live = supplier('live', [{ id: 'live-m' }])
+  live.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      start(c) {
+        c.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"兜底"}}]}\n\ndata: [DONE]\n\n'))
+        c.close()
+      },
+    }),
+  })
+  addSupplier(router, half.s)
+  addSupplier(router, live.s)
+  assert.equal(router.createCombo('c2', 'fallback', ['half,half-m', 'live,live-m']).ok, true)
+
+  let out = ''
+  let heads = 0
+  const res = {
+    writeHead: (): void => { heads += 1 },
+    write: (b: Uint8Array | string): boolean => { out += Buffer.from(b).toString(); return true },
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+  await router.chatCompletions({ model: 'c2', stream: true, rawBody: JSON.stringify({ model: 'c2', messages: [] }) }, res)
+
+  assert.ok(out.includes('半截'), '已投递的字节要送达客户端')
+  assert.ok(!out.includes('[DONE]'), '已提交就不该再接第二个模型的内容（会串流）')
+  assert.equal(heads, 1, '响应头只能提交一次')
+})
+
 /**
  * 对照组：插件若用 unavailable 表示「不是我的模型」就会污染账号——
  * 这正是当初把 no_such_model 加进契约的原因（unavailable 在 RULES 里计数）。
@@ -184,3 +397,59 @@ test('组合请求不污染无关供应商的账号（no_such_model 不记账）
   assert.equal(acc?.cooling, false, '不该被冷却')
   assert.equal(acc?.disabled, false, '不该被禁用')
 })
+
+/**
+ * 回归：CodeBuddy 上游的工具调用第二个 delta 会**显式发空串** name 和 id
+ * （OpenAI 规范里后续 delta 应当省略，客户端沿用首帧）。客户端（dsh）判空用
+ * `!== void 0`，空串过不了这个判断，首帧的 "bash" 就被 "" 冲掉 → 工具名变空，
+ * 下游报 `unknown tool ""`，而 arguments 独立累积所以「参数对、名字空」。
+ *
+ * 核心是流式响应的唯一写入方，必须在转发时把这些空字段剥掉。
+ * 帧数据取自真实上游（hy4-preview 工具调用）。
+ */
+test('流式：剥掉上游多发一次的空白 tool_call name/id', async () => {
+  const router = new Router('')
+  const cb = supplier('cb', [{ id: 'hy4-preview' }])
+  const REAL = [
+    'data: {"id":"cmb-1","model":"hy4-preview","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"","tool_calls":[{"id":"chatcmpl-tool-a7ee5a0d3c361c7f","type":"function","function":{"name":"bash","arguments":""},"index":0}]},"finish_reason":""}]}\n\n',
+    'data: {"id":"cmb-1","model":"hy4-preview","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"","tool_calls":[{"id":"","function":{"name":"","arguments":"{\\"command\\": \\"echo hello\\"}"},"index":0}]},"finish_reason":"tool_calls"}]}\n\n',
+    'data: [DONE]\n\n',
+  ].join('')
+  cb.s.chatOnce = async (): Promise<ChatOnceResult> => ({
+    ok: true,
+    stream: new ReadableStream<Uint8Array>({
+      start(c) { c.enqueue(new TextEncoder().encode(REAL)); c.close() },
+    }),
+  })
+  addSupplier(router, cb.s)
+
+  let out = ''
+  const res = {
+    writeHead: (): void => {},
+    write: (b: Uint8Array | string): boolean => { out += Buffer.from(b).toString(); return true },
+    end: (): void => {},
+    once: (): void => {},
+    removeListener: (): void => {},
+    destroy: (): void => {},
+  } as unknown as ServerResponse
+  await router.chatCompletions({ model: 'cb/hy4-preview', stream: true, rawBody: JSON.stringify({ model: 'cb/hy4-preview', stream: true, messages: [] }) }, res)
+
+  // 按 dsh 的合并规则跑一遍：name !== void 0 就覆盖
+  let name: string | undefined
+  let callId: string | undefined
+  let args = ''
+  for (const line of out.split('\n')) {
+    if (!line.startsWith('data: ')) continue
+    const payload = line.slice(6).trim()
+    if (payload === '[DONE]') continue
+    const o = JSON.parse(payload) as { choices?: Array<{ delta?: { tool_calls?: Array<{ id?: string; function?: { name?: string; arguments?: string } }> } }> }
+    for (const tc of o.choices?.[0]?.delta?.tool_calls ?? []) {
+      if (tc.id !== undefined) callId = tc.id
+      if (tc.function?.name !== undefined) name = tc.function.name
+      args += tc.function?.arguments ?? ''
+    }
+  }
+  assert.equal(name, 'bash', `工具名必须保住（空了就会 unknown tool ""），实际 ${JSON.stringify(name)}`)
+  assert.equal(callId, 'chatcmpl-tool-a7ee5a0d3c361c7f', 'callId 也不能被空串冲掉')
+  assert.deepEqual(JSON.parse(args), { command: 'echo hello' }, 'arguments 正常累积')
+})

package/src/router/precise-dispatch.test.ts

@@ -0,0 +1,198 @@
+/**
+ * 精准调度测试 —— 组合调用不该挨个问供应商「这是不是你的模型」。
+ * 存储格式 = `supplierId,modelId`，对外展示/调用 = `alias/model`。
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import type { ServerResponse } from 'node:http'
+import { Router } from './index.ts'
+import type { ModelInfo } from './types.ts'
+import { AccountPool } from './account-pool.ts'
+import { SupplierConfigStore } from '../supplier-config.ts'
+import type { AccountPool as Pool } from './account-pool.ts'
+import type { ChatOnceResult, SupplierAccountNow, SupplierStatusNow } from '../suppliers/contract.ts'
+
+interface Spy {
+  /** chatOnce 被调用的次数 */
+  calls: number
+  /** 每次被调用的模型名 */
+  seen: string[]
+  s: {
+    id: string
+    name: string
+    priority: number
+    pool: Pool
+    status: () => SupplierStatusNow
+    listModels: () => Promise<ModelInfo[]>
+    modelsWithEnabled: () => Promise<Array<ModelInfo & { enabled: boolean }>>
+    getAlias: () => string
+    accounts: () => SupplierAccountNow[]
+    chatOnce: (uid: string, req: { rawBody: string }) => Promise<ChatOnceResult>
+    dispose: () => void
+  }
+}
+
+/** 带探针的供应商：只服务自己的模型，记录被问过什么。 */
+function spy(id: string, modelId: string, alias = id): Spy {
+  const calls = { n: 0 }
+  const seen: string[] = []
+  return {
+    get calls() { return calls.n },
+    seen,
+    s: {
+      id, name: id, priority: 0, pool: new AccountPool(),
+      status: () => ({ id, name: id, accounts: [{ uid: `${id}-u1`, credits: 0, state: 'ok' }] }),
+      listModels: async () => [{ id: modelId }],
+      modelsWithEnabled: async () => [{ id: modelId, enabled: true }],
+      getAlias: () => alias,
+      accounts: () => [{ uid: `${id}-u1`, credits: 0, state: 'ok' }],
+      chatOnce: async (_uid, req) => {
+        calls.n += 1
+        const m = (JSON.parse(req.rawBody) as { model?: string }).model ?? ''
+        seen.push(m)
+        if (m !== modelId) return { ok: false, state: 'no_such_model', message: `unknown model ${m}` }
+        return { ok: true, status: 200, body: '{"ok":1}' }
+      },
+      dispose: () => {},
+    },
+  }
+}
+
+/** 走真实注册路径（router.add 内部会 sync 已知 id，别名校验才能生效）。 */
+function add(router: Router, s: unknown): void {
+  router.add(s as Parameters<Router['add']>[0])
+}
+
+function fakeRes(): ServerResponse {
+  return {
+    writeHead: (): unknown => undefined,
+    end: (): unknown => undefined,
+    write: (): boolean => true,
+    once: (): unknown => undefined,
+    removeListener: (): unknown => undefined,
+    destroy: (): unknown => undefined,
+  } as unknown as ServerResponse
+}
+
+function reqWith(model: string) {
+  return { model, stream: false, rawBody: JSON.stringify({ model, messages: [] }) }
+}
+
+test('组合只调目标供应商，其它供应商一次都不会被问', async () => {
+  const router = new Router('')
+  const a = spy('supA', 'a-model')
+  const b = spy('supB', 'b-model')
+  const c = spy('supC', 'c-model')
+  add(router, a.s); add(router, b.s); add(router, c.s)
+  assert.equal(router.createCombo('my-combo', 'fallback', ['supB,b-model']).ok, true, '组合必须创建成功')
+
+  await router.chatCompletions(reqWith('my-combo'), fakeRes())
+
+  assert.equal(b.calls, 1, '目标供应商被调用')
+  assert.equal(a.calls, 0, '无关供应商不该被问')
+  assert.equal(c.calls, 0, '无关供应商不该被问')
+  assert.deepEqual(b.seen, ['b-model'], '插件收到的是自己的模型 id')
+})
+
+test('直接调 alias/model：用别名反查供应商，精准命中', async () => {
+  const router = new Router('')
+  const a = spy('supA', 'a-model', 'aaa')
+  const b = spy('supB', 'b-model', 'bbb')
+  add(router, a.s); add(router, b.s)
+
+  await router.chatCompletions(reqWith('bbb/b-model'), fakeRes())
+
+  assert.equal(b.calls, 1)
+  assert.equal(a.calls, 0, '别名唯一，不该误命中别的供应商')
+  assert.deepEqual(b.seen, ['bbb/b-model'], '核心原样传全名，剥前缀是插件自己的事')
+})
+
+test('同名模型不串台：两个供应商都有 gpt，各调各的', async () => {
+  const router = new Router('')
+  const a = spy('supA', 'gpt', 'aaa')
+  const b = spy('supB', 'gpt', 'bbb')
+  add(router, a.s); add(router, b.s)
+
+  await router.chatCompletions(reqWith('bbb/gpt'), fakeRes())
+
+  assert.equal(b.calls, 1)
+  assert.equal(a.calls, 0, 'supA 也有 gpt，但别名没指向它就不该被调用')
+})
+
+test('模型 id 含斜杠时不被吃掉（如 deepseek-ai/xxx）', async () => {
+  const router = new Router('')
+  const a = spy('supA', 'deepseek-ai/deepseek-v3', 'aaa')
+  add(router, a.s)
+
+  await router.chatCompletions(reqWith('aaa/deepseek-ai/deepseek-v3'), fakeRes())
+
+  assert.equal(a.calls, 1)
+  // 核心原样传，插件只剥第一段（别名），命名空间保留
+  assert.deepEqual(a.seen, ['aaa/deepseek-ai/deepseek-v3'])
+})
+
+test('旧数据裸模型 id 仍能工作（降级为遍历）', async () => {
+  const router = new Router('')
+  const a = spy('supA', 'a-model')
+  const b = spy('supB', 'b-model')
+  add(router, a.s); add(router, b.s)
+  // 模拟旧存储：裸 id，没有 supplierId 前缀
+  ;(router as unknown as { customCombos: Array<{ id: string; name: string; strategy: 'fallback'; models: string[] }> })
+    .customCombos.push({ id: 'legacy', name: 'legacy', strategy: 'fallback', models: ['b-model'] })
+
+  await router.chatCompletions(reqWith('legacy'), fakeRes())
+
+  assert.equal(a.calls, 1, '降级路径会先问 supA（它报 no_such_model）')
+  assert.equal(b.calls, 1, '最终由 supB 服务')
+})
+
+test('组合存了不存在的供应商 id → 调用失败，不静默落到别的供应商', async () => {
+  const router = new Router('')
+  const a = spy('supA', 'a-model')
+  add(router, a.s)
+  assert.equal(router.createCombo('broken', 'fallback', ['ghost,a-model']).ok, true, '组合必须创建成功')
+
+  const errs: unknown[] = []
+  const res = { ...fakeRes(), end: (b?: string): unknown => { if (b) errs.push(b); return undefined } } as unknown as ServerResponse
+  await router.chatCompletions(reqWith('broken'), res)
+
+  assert.equal(a.calls, 0, '不该兜底落到 supA')
+  assert.equal(errs.length, 1, '应返回失败响应')
+})
+
+test('别名唯一性：冲突拒绝，自己改自己不冲突', () => {
+  const store = new SupplierConfigStore('')   // 不落盘
+  const router = new Router('', store)
+  const a = spy('supA', 'a-model')
+  const b = spy('supB', 'b-model')
+  add(router, a.s); add(router, b.s)          // add() 会 sync 已知 id
+
+  assert.equal(store.setAlias('supA', 'taken').ok, true)
+  assert.equal(store.setAlias('supB', 'taken').ok, false, '别名冲突应拒绝')
+  assert.equal(store.setAlias('supA', 'taken').ok, true, '自己改自己不算冲突')
+  // 空别名 = 用供应商 id（默认值），且同样参与唯一性
+  assert.equal(store.setAlias('supB', '').ok, true)
+  assert.equal(store.get('supB').alias, '')
+})
+
+test('别名冲突时返回占用者，便于面板提示', () => {
+  const store = new SupplierConfigStore('')
+  const router = new Router('', store)
+  add(router, spy('supA', 'a-model').s)
+  add(router, spy('supB', 'b-model').s)
+
+  store.setAlias('supA', 'shared')
+  const r = store.setAlias('supB', 'shared')
+  assert.equal(r.ok, false)
+  assert.equal(r.conflictWith, 'supA')
+})
+
+test('空别名 → 生效别名回落到供应商 id', () => {
+  const store = new SupplierConfigStore('')
+  const router = new Router('', store)
+  add(router, spy('supA', 'a-model').s)
+
+  assert.equal(store.effectiveAliases().get('supA'), 'supA', '没设别名时 = 供应商 id')
+  store.setAlias('supA', 'custom')
+  assert.equal(store.effectiveAliases().get('supA'), 'custom')
+})