dsh-router-core 0.4.5 → 0.4.7

package/src/index.ts

@@ -33,7 +33,7 @@
 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_API_BASE, type RouterPeriod, clientIdentityOf } from './shared.ts'
 import { Router } from './router/index.ts'
 import { RouterAdapter, type RouterAttachmentStore } from './llm/adapter.ts'
 import { KeysStore } from './keys.ts'
@@ -47,6 +47,7 @@ import { loopbackBaseURL } from './host-base-url.ts'
 import { detectHostVersion, isHostSupported } from './host-version.ts'
 import { ExtStore } from './ext/store.ts'
 import type { ExtControl, ExtInfo, ExtStoreService, RouterExt, RouterExtService } from './ext/contract.ts'
+import { geminiModelFromPath, geminiStreamFromPath, lvOf, outboundSink, parseInbound } from './protocol/entry.ts'
 
 /**
  * Plugin identity for cordis.yml rows — 必须与 package.json 的 name 一致。
@@ -138,6 +139,24 @@ function writeJson(res: ServerResponse, status: number, body: unknown): void {
   res.end(payload)
 }
 
+/**
+ * 每种协议的 error body 形状。
+ *
+ * 为什么必须有：非 chat 入口的 400/413/501 若照 OpenAI 的
+ * `{error:{message,type,code}}` 写，Claude Code 解析不到 `error.message`
+ * 会显示「未知错误」——用户看到的是一个空错误，而真因（如 body 太大）
+ * 就在手边却送不出去。
+ */
+function errBodyFor(protocol: 'anthropic' | 'responses' | 'gemini', message: string): unknown {
+  if (protocol === 'anthropic') {
+    return { type: 'error', error: { type: 'invalid_request_error', message } }
+  }
+  if (protocol === 'gemini') {
+    return { error: { code: 400, message, status: 'INVALID_ARGUMENT' } }
+  }
+  return { error: { message, type: 'api_error', code: 'invalid_request' } }
+}
+
 function readBody(req: IncomingMessage, limit: number): Promise<string> {
   return new Promise((resolve, reject) => {
     const chunks: Buffer[] = []
@@ -334,6 +353,14 @@ export function apply(rawContext: unknown): void {
   })()
 
   // ---- /v1/* (OpenAI-compatible, Bearer auth via KeysStore) ----
+  //
+  // 四种协议共用同一套路由/账号池/用量统计，差别只在「怎么听懂请求、怎么回答」：
+  //   /v1/chat/completions                      OpenAI Chat Completions
+  //   /v1/messages, /v1/messages/count_tokens   Anthropic Messages
+  //   /v1/responses                             OpenAI Responses
+  //   /v1beta/models/<m>:generateContent        Google Gemini
+  // 入站一律先翻成规范请求（Chat Completions 形状）再进 Router，所以上面这些
+  // 端点**自动**获得组合回退、账号池选号、首字节预算与用量看板。
 
   const withV1Auth = (handler: (req: IncomingMessage, res: ServerResponse) => void | Promise<void>) => {
     return async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
@@ -363,9 +390,9 @@ export function apply(rawContext: unknown): void {
       writeJson(res, 413, { error: { message: 'request body too large', type: 'api_error', code: 'request_too_large' } })
       return
     }
-    let peek: { stream?: boolean; model?: string; reasoning_effort?: unknown }
+    let peek: { stream?: boolean; model?: string; reasoning_effort?: unknown; user?: unknown; prompt_cache_key?: unknown }
     try {
-      peek = JSON.parse(body) as { stream?: boolean; model?: string; reasoning_effort?: unknown }
+      peek = JSON.parse(body) as { stream?: boolean; model?: string; reasoning_effort?: unknown; user?: unknown; prompt_cache_key?: unknown }
     } catch {
       writeJson(res, 400, { error: { message: 'invalid JSON body', type: 'api_error', code: 'invalid_request' } })
       return
@@ -373,9 +400,12 @@ export function apply(rawContext: unknown): void {
     const lv = typeof peek.reasoning_effort === 'string' && peek.reasoning_effort !== ''
       ? peek.reasoning_effort
       : 'auto'
-    // 宿主会话身份（adapter 从 GenerateOptions.sessionId 转来的内部头）；外部客户端没有。
+    // 调用方身份：宿主会话内部头（adapter 从 GenerateOptions.sessionId 转来）
+    // 优先；外部客户端没有内部头，用 user/prompt_cache_key/UA 兜底归因——
+    // 否则 usage 记录全是匿名，反查不出是哪个客户端在打。
     const sessionRaw = req.headers['x-dsh-router-session']
-    const session = typeof sessionRaw === 'string' && sessionRaw !== '' ? sessionRaw : undefined
+    const session = (typeof sessionRaw === 'string' && sessionRaw !== '' ? sessionRaw : undefined)
+      ?? clientIdentityOf(peek, req.headers['user-agent'])
     await router.chatCompletions(
       {
         rawBody: body,
@@ -383,11 +413,92 @@ export function apply(rawContext: unknown): void {
         model: typeof peek.model === 'string' ? peek.model : '',
         lv,
         ...(session === undefined ? {} : { session }),
+        protocol: 'chat',
       },
       res,
     )
   }))
 
+  /**
+   * Anthropic / Responses / Gemini 三个非 chat 入口的**公共前半段**：
+   * 鉴权 → 读 body → 翻成规范请求 → 交给 Router → 把响应翻回客户端协议。
+   *
+   * 抽出来是因为三者的差别只有「协议 id 是什么、模型名从哪取」，而鉴权/限流/
+   * 归因/错误形状必须完全一致 —— 各写一份就会出现「Anthropic 入口认了
+   * x-dsh-router-session、Gemini 入口不认」这种只能靠实测发现的漂移。
+   */
+  const enterProtocol = (protocol: 'anthropic' | 'responses' | 'gemini') => withV1Auth(async (req, res) => {
+    const parsed = await parseInbound(req, protocol, {
+      limitBytes: 8 << 20,
+      modelFromPath: protocol === 'gemini' ? geminiModelFromPath(req.url ?? '') : undefined,
+      // Gemini 的「流不流式」在 URL 尾部（:streamGenerateContent vs
+      // :generateContent），body 里没有 stream 字段 —— 不认它，流式请求会被
+      // 当成非流式返回一整个 JSON，客户端按 SSE 解析就是空响应。
+      streamFromPath: protocol === 'gemini' ? geminiStreamFromPath(req.url ?? '') : undefined,
+      lvFromBody: (body) => lvOf(body, protocol),
+    })
+    if ('error' in parsed) {
+      writeJson(res, parsed.status, errBodyFor(protocol, parsed.error))
+      return
+    }
+    if (parsed.model === '') {
+      writeJson(res, 400, errBodyFor(protocol, 'missing model'))
+      return
+    }
+    const sessionRaw = req.headers['x-dsh-router-session']
+    const session = (typeof sessionRaw === 'string' && sessionRaw !== '' ? sessionRaw : undefined)
+      ?? clientIdentityOf(parsed.body, req.headers['user-agent'])
+    // 出口：Router 只会写 OpenAI 形态，sink 负责翻成客户端协议再写给 res。
+    // sink 是**透传式中继**，Router 那套「客户端断开就取消上游流」的逻辑
+    // 照旧生效 —— 它监听的是真实 res 的 close，与本层无关。
+    const sink = outboundSink(protocol, parsed.model, res)
+    await router.chatCompletions(
+      {
+        rawBody: JSON.stringify(parsed.body),
+        stream: parsed.stream,
+        model: parsed.model,
+        lv: parsed.lv,
+        ...(session === undefined ? {} : { session }),
+        protocol,
+      },
+      res,
+      sink,
+    )
+  })
+
+  // Anthropic Messages（Claude Code 只说这种协议）。
+  // count_tokens 是「问一句要多少 token」：没有本地 tokenizer 就不能诚实回答，
+  // 而跑一次上游只数 token 是要花钱的假精确 —— 直接 501，别编数字。
+  route('/v1/messages', enterProtocol('anthropic'))
+  route('/v1/messages/count_tokens', withV1Auth(async (_req, res) => {
+    writeJson(res, 501, {
+      type: 'error',
+      error: { type: 'not_supported', message: 'count_tokens is not supported; send the message instead' },
+    })
+  }))
+
+  // OpenAI Responses（Codex 用）。
+  route('/v1/responses', enterProtocol('responses'))
+
+  // Google Gemini。Gemini 的模型名在 **URL 路径**里
+  // （`/v1beta/models/<model>:generateContent`），所以走 prefix 路由自己解析
+  // `req.url`（webServer 的 exact 匹配不吃 `:param` 语法，而模型名本身可含
+  // 斜杠，逐段穷举不现实）。流式/非流式靠路径尾部的
+  // `:streamGenerateContent` / `:generateContent` 区分，已在
+  // `geminiModelFromPath` 与 `parseInbound` 里落到 `stream` 上。
+  //
+  // ⚠️ **prefix 不能带尾斜杠**：宿主 `Table.match()` 的判据是
+  //     `pathname === prefix || pathname.startsWith(prefix + '/')`
+  //   注册 `'/v1beta/models/'` 会让实际请求去比 `'/v1beta/models//'`，
+  //   **永不匹配** → 落到宿主兜底，表现为 GET 404 / POST 405（2026-10-21 实测
+  //   在 3080 上复现）。注册成不带斜杠的 `'/v1beta/models'`，
+  //   `startsWith('/v1beta/models/')` 才成立。
+  disposers.push(ctx.webServer.register({
+    kind: 'prefix',
+    path: '/v1beta/models',
+    handler: enterProtocol('gemini'),
+  }))
+
   // ---- /router/api/* (panel, same-origin) ----
 
   route(`${ROUTER_API_BASE}/health`, (_req, res) => {
@@ -618,7 +729,7 @@ return Object.values(table as RouterExtService)
             controls: e.controls
               .filter((c): c is ExtControl =>
                 !!c && typeof c.id === 'string' && c.id !== '' && typeof c.title === 'string')
-              .map((c) => ({ id: c.id, title: c.title, on: c.on === true, ...(c.detail !== undefined ? { detail: c.detail } : {}), ...(typeof c.body === 'string' ? { body: c.body } : {}), ...(c.editable === true ? { editable: true } : {}), custom: c.custom === true, overridden: c.overridden === true })),
+              .map((c) => ({ id: c.id, title: c.title, on: c.on === true, ...(c.detail !== undefined ? { detail: c.detail } : {}), ...(typeof c.body === 'string' ? { body: c.body } : {}), ...(c.editable === true ? { editable: true } : {}), ...(c.group !== undefined ? { group: c.group } : {}), ...(c.sortable !== undefined ? { sortable: c.sortable } : {}), custom: c.custom === true, overridden: c.overridden === true })),
           }
         : {}),
       ...(st?.detail !== undefined ? { detail: st.detail } : {}),

package/src/llm/adapter.test.ts

@@ -156,6 +156,60 @@ test('出口：空的 finish_reason 不许冲掉后面那个真终止原因', as
   assert.deepEqual(reason, { kind: 'tool-calls' })
 })
 
+test('出口：上游报 stop 却发了完整工具调用时，必须以 tool-calls 收尾', async () => {
+  // 真实事故（2026-10-15，traework 上游 + Delta 客户端）：带 tools 的请求上，
+  // 上游正常发出完整的 tool_calls（参数逐片拼全），收尾帧却写
+  // `finish_reason: "stop"` —— 与 OpenAI 契约不符（有工具调用应为 tool_calls）。
+  //
+  // 修复前 mapFinishReason('stop') 直接给 kind='stop'，而「无内容」兜底又因
+  // 为有内容不触发，于是已攒好的工具块被静默丢弃；调用方据此认为「本轮结束、
+  // 没有工具要执行」，表现为「模型能对话但工具永远调不动」（Delta 侧即
+  // 「test 能访问但 tool 调用不了」）。
+  const reason = await finishOf(
+    frame({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', function: { name: 'bash', arguments: '{"command":"ls"}' } }] } }] }),
+    frame({ choices: [{ delta: {}, finish_reason: 'stop' }] }),
+    '[DONE]',
+  )
+  assert.deepEqual(reason, { kind: 'tool-calls' })
+})
+
+test('出口：stop + 工具调用时，工具块本身也要照常交出（不能只改收尾）', async () => {
+  const calls = await toolCallsOf(
+    frame({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', function: { name: 'bash', arguments: '{"command":"ls"}' } }] } }] }),
+    frame({ choices: [{ delta: {}, finish_reason: 'stop' }] }),
+    '[DONE]',
+  )
+  assert.deepEqual(calls, [{ type: 'tool-call', id: 'call_1', name: 'bash', arguments: '{"command":"ls"}' }])
+})
+
+test('出口：stop 且没有工具调用时，仍然收尾为 stop（不能误报 tool-calls）', async () => {
+  // 反向判据：修复不能把普通对话也标成 tool-calls，否则调用方会空等工具结果。
+  const reason = await finishOf(frame({ choices: [{ delta: { content: 'hello' }, finish_reason: 'stop' }] }), '[DONE]')
+  assert.deepEqual(reason, { kind: 'stop' })
+})
+
+test('出口：length 截断即使带了工具调用也不能改成 tool-calls', async () => {
+  // `length` 必须原样透传：dsh-llm 的 assembled() 靠 `finish.kind === 'max-tokens'`
+  // 丢弃被截断的工具调用，改成 tool-calls 等于把半截调用放出去执行。
+  const reason = await finishOf(
+    frame({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', function: { name: 'bash', arguments: '{"command":"ls"}' } }] } }] }),
+    frame({ choices: [{ delta: {}, finish_reason: 'length' }] }),
+    '[DONE]',
+  )
+  assert.deepEqual(reason, { kind: 'max-tokens' })
+})
+
+test('出口：stop + 参数残缺的工具调用时，仍判 error（半成品不许当有效调用）', async () => {
+  // 与上一条互补：`stop` 只在工具块**完整**时才提升为 tool-calls。
+  // 参数残缺时既有逻辑已把 pendingFinish 改成 error，不能被这条修复绕过去。
+  const reason = await finishOf(
+    frame({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', function: { name: 'bash', arguments: '{"command": "cd' } }] } }] }),
+    frame({ choices: [{ delta: {}, finish_reason: 'stop' }] }),
+    '[DONE]',
+  )
+  assert.equal(reason?.kind, 'error')
+})
+
 test('出口：未知终止原因必须带非空 code（agent-loop 会拿它重建 LlmError）', async () => {
   const reason = await finishOf(frame({ choices: [{ delta: { content: 'x' }, finish_reason: 'content_filter' }] }), '[DONE]')
   assert.equal(reason?.kind, 'error')

package/src/llm/adapter.ts

@@ -444,13 +444,35 @@ export async function* translateSse(payloads: AsyncIterable<string> | Iterable<s
         const usage = toTokenUsage(accumulated)
         if (usage !== null) yield { type: 'usage', usage }
       }
+      // 上游报 `stop` **却发了工具调用**时，必须以 tool-calls 收尾。
+      //
+      // 为什么（2026-10-15 实测）：traework 上游在带 tools 的请求上正常发出
+      // 完整的 tool_calls（参数逐片拼全），收尾帧却写 `finish_reason: "stop"`
+      // ——与 OpenAI 契约不符（有工具调用应为 `tool_calls`）。而 mapFinishReason
+      // 只看 reason 字面量，于是 kind='stop'，下面那个 `order.length === 0` 的
+      // 兜底又因为「有内容」不触发，最终以 stop 收尾 → **已攒好的工具块被静默
+      // 丢弃**，调用方（Delta 等）据此认为「本轮结束、没有工具要执行」，表现为
+      // 「模型能对话但工具永远调不动」。
+      //
+      // 判据用 `complete` 而不是 `order`：只有**参数拼全**的工具块才配提升为
+      // tool-calls。注意在当前逻辑下两者等价——参数残缺时上面的 `pendingFinish`
+      // 已经把它改成 error，`reason.kind` 就不是 'stop'，根本走不到这里；
+      // 仍写 `complete` 是因为语义直接（「完整的工具调用」），且不依赖那个
+      // 副作用：哪天 error 分支挪走或放宽，这里不会跟着把半成品放行。
+      //
+      // 只改 `stop`：`length`（截断）必须原样透传 —— dsh-llm 的 assembled()
+      // 正是靠 `finish.kind === 'max-tokens'` 去丢弃被截断的工具调用，
+      // 改掉它就等于把半截调用放出去执行。
+      const hasCompleteToolCall = complete.some((block) => block.kind === 'tool-call')
       const reason = pendingFinish ?? { kind: 'stop' }
+      const resolved =
+        reason.kind === 'stop' && hasCompleteToolCall ? { kind: 'tool-calls' } : reason
       yield {
         type: 'finish',
         reason:
-          reason.kind === 'stop' && order.length === 0
+          resolved.kind === 'stop' && order.length === 0
             ? { kind: 'error', failure: { message: 'model returned a completed response with no content', code: EMPTY_RESPONSE_CODE } }
-            : (reason as never),
+            : (resolved as never),
       }
       return
     }