dsh-router-core 0.3.21 → 0.4.0

package/src/router/account-pool.ts

@@ -24,7 +24,7 @@
  * 得落盘，届时加 stateFile 即可，接口不用变。
  */
 import type { AccountState, SupplierAccountNow } from '../suppliers/contract.ts'
-import { prefixFingerprint } from './prefix-affinity.ts'
+import { sessionFingerprint } from './prefix-affinity.ts'
 
 /** 各 AccountState 的处置：冷却策略 / 是否计入连续错误。 */
 interface Rule {
@@ -182,9 +182,9 @@ export class AccountPool {
   private rrCursor = 0
   /** (supplier, model) → 当前驻留的号（只有**无亲和**的回退路径用它）。 */
   private blocks = new Map<string, string>()
-  /** (supplier, model, uid) → 该号的缓存质量样本（降权判据，跨驻留累计）。 */
+  /** (supplier, model, uid[, session]) → 该号在某会话下的缓存质量样本。 */
   private samples = new Map<string, Sample>()
-  /** (supplier, model, uid) → 缓存无效降权。 */
+  /** 同上键 → 缓存无效降权。 */
   private demoted = new Map<string, DemoteEntry>()
   /** (supplier, model) → Map<前缀指纹, uid>：前缀亲和的选号记忆（LRU 封顶）。 */
   private affinity = new Map<string, Map<string, string>>()
@@ -197,6 +197,23 @@ export class AccountPool {
     return `${this.supplierId}${SEP}${model}${SEP}${uid}`
   }
 
+  /**
+   * 缓存质量样本/降权的键。
+   *
+   * **按会话隔离**（team 场景的关键）：同一个号被多个会话共用时，各会话的
+   * 前缀会互相驱逐，把它们混在一起算命中率，会把「多会话互踩」误判成
+   * 「这个号缓存坏了」→ 错误降权 → 只剩一个号 → 那个号又被打低 → 降权串。
+   * 所以有会话身份时按 (model, uid, session) 记，降权只反映**该会话自己**
+   * 在这个号上的真实缓存表现。
+   *
+   * 无会话身份（外部 OpenAI 客户端，走无指纹回退路径）→ 保持 (model, uid)，
+   * 与块轮询的原语义一致（那时本就是单会话视角）。
+   */
+  private sampleKey(model: string, uid: string, session?: string): string {
+    const base = this.key(model, uid)
+    return session === undefined || session === '' ? base : `${base}${SEP}${session}`
+  }
+
   private entry(model: string, uid: string): CooldownEntry {
     const k = this.key(model, uid)
     let e = this.cooldowns.get(k)
@@ -236,30 +253,32 @@ export class AccountPool {
   }
 
   /**
-   * 按策略为「某个模型」选一个健康账号。
+   * 为「某个模型」选一个健康账号 —— **会话亲和选号，无策略旋钮**。
    *
-   * round-robin = **前缀亲和定号 + 块统计只用来判定缓存无效**：
+   * 旧的两策略（fallback 取第一个 / round-robin 轮转）都删了：前者让所有
+   * 会话挤同一个号（team/多会话必互踩），后者的"轮转"与亲和"同会话永不换号"
+   * 直接冲突。正确模型只有一条：
    *
    *  1. 算请求的前缀指纹（messages 前几条），查绑定表 → 命中且该号健康 → 用它。
-   *     这是第一优先：同一个会话的连续请求**永远落回同一个号**，前缀在该号的
-   *     缓存里只写一份。块轮询治不了跨会话驱逐（多会话大前缀在同一号互踩，
-   *     实测 3 会话 3.8% vs 单会话 82.5%），亲和才是根治。
+   *     同一个会话的连续请求**永远落回同一个号**，前缀在该号缓存里只写一份。
    *  2. 新指纹（或绑定的号不健康）→ 按游标挑一个号并**记下绑定**，之后就固定。
    *     新会话用游标分发，所以不同会话天然散到不同号上（均衡）。
-   *  3. 块统计不再驱动轮转（亲和已经保证驻留，再轮转只会把会话踢出已热前缀），
-   *     只保留 `BLOCK_MAX` 次不达标 → 降权该号（缓存无效，可恢复）。
+   *  3. 指纹算不出（拿不到 messages）→ **块轮询兜底**（§2 旧行为）。这不是
+   *     "策略"，是无会话身份时的替身。
+   *  4. 块统计不驱动轮转（亲和已保证驻留），只保留 `BLOCK_MAX` 次不达标 →
+   *     降权该号（缓存无效，可恢复）。
    *
-   * 亲和失效（拿不到 messages / 指纹算不出）时**回退到块轮询**，行为与之前一致。
-   * 设计见 docs/pool-sticky-block.md §8。
+   * 天花板：号数 < 并发会话数时必然有会话共用号 → 互踩，无法用选号手法消除
+   * （缓存空间是账号侧物理限制）。见 docs/pool-sticky-block.md §10。
    *
    * @param accounts 插件报告的「现在状态」（顺序即插件的自然顺序）
    * @param poolOrder 用户在面板拖出来的顺序（核心管）
-   * @param strategy fallback 取第一个健康 / round-robin 前缀亲和
    * @param modelId 当前要路由的模型（决定查哪个 (model, uid) 冷却单元）
-   * @param messages 请求体的 messages（可选；给了才能算前缀指纹）
+   * @param messages 请求体的 messages（算亲和指纹的内容兜底）
+   * @param session 宿主会话身份；给了就以它为主键（精确、零撞车）
    * @returns 选中的 uid；无健康账号返回 undefined
    */
-  pick(accounts: SupplierAccountNow[], poolOrder: string[], strategy: string, modelId: string, messages?: unknown): string | undefined {
+  pick(accounts: SupplierAccountNow[], poolOrder: string[], modelId: string, messages?: unknown, session?: string): string | undefined {
     const now = Date.now()
     const byUid = new Map(accounts.map((a) => [a.uid, a]))
     // 池顺序优先，未配置的按插件自然顺序追加
@@ -268,35 +287,98 @@ export class AccountPool {
       ...accounts.map((a) => a.uid).filter((uid) => !poolOrder.includes(uid)),
     ]
     const healthy = ordered.filter((uid) => this.healthy(uid, modelId, now))
-    if (healthy.length === 0) return undefined
-    if (strategy !== 'round-robin') return healthy[0]
+    if (healthy.length === 0) {
+      this.lastWhy = '全池无健康号（都在冷却）'
+      return undefined
+    }
     // 缓存无效降权：该号缓存质量样本长期不达标 → 跳过它（可到期恢复）
-    const usable = healthy.filter((uid) => !this.isDemoted(uid, modelId, now))
+    const usable = healthy.filter((uid) => !this.isDemoted(uid, modelId, now, session))
     const pool = usable.length > 0 ? usable : healthy
     // 前缀亲和：指纹有绑定且该号仍可用 → 直接复用（不进驻留逻辑）
-    const fp = messages === undefined ? '' : prefixFingerprint(messages)
-    if (fp !== '' && pool.includes(this.affinity.get(this.blockKey(modelId))?.get(fp) ?? '')) {
-      return this.affinity.get(this.blockKey(modelId))!.get(fp)!
+    const fp = sessionFingerprint(session, messages)
+    const bound = fp === '' ? undefined : this.affinity.get(this.blockKey(modelId))?.get(fp)
+    if (bound !== undefined && pool.includes(bound)) {
+      this.lastWhy = `亲和命中 ${bound}（会话/前缀已绑定）`
+      return bound
+    }
+    // 走到这里说明没粘住：把「为什么没用原绑定」记清楚，否则每次换号都要靠猜
+    const why: string[] = []
+    if (fp === '') {
+      why.push('无指纹（拿不到 messages/会话）')
+    } else if (bound === undefined) {
+      why.push('该指纹无绑定（会话首次出现）')
+    } else {
+      if (!healthy.includes(bound)) {
+        const c = this.cooldowns.get(this.key(modelId, bound))
+        why.push(`原绑定 ${bound} 正在冷却${c?.reason ? `(${c.reason})` : ''}`)
+      } else if (!usable.includes(bound)) {
+        why.push(`原绑定 ${bound} 被降权（本会话样本不达标）`)
+      } else {
+        why.push(`原绑定 ${bound} 不在当前健康池`)
+      }
     }
+    // 无指纹：沿用块轮询语义 —— 块内粘住（blockKeeps）则留守当前 block。
     const block = this.blocks.get(this.blockKey(modelId))
     if (fp === '' && block !== undefined && pool.includes(block) && this.blockKeeps(modelId, block)) {
+      this.lastWhy = `块驻留 ${block}（无指纹路径）`
       return block
     }
-    // 无亲和（或块满/块达标）→ 前进游标。从当前号之后开始找，保证轮转顺序稳定。
-    const from = block === undefined ? this.rrCursor : Math.max(0, pool.indexOf(block) + 1)
-    const uid = pool[from % pool.length]!
+    // 分配一个号并记住绑定。
+    //
+    // 有指纹（新会话）：**优先铺开到未被其它会话占用的号**——同 model 下
+    // 每个 fresh 会话尽量独占一个号（缓存空间隔离、互不驱逐），号不够时
+    // 才回绕复用（共用号无害：样本按会话语义隔离，不会误降权）。
+    // 候选顺序：先「空闲号」，用完后才是「已被占用的号」。
+    // 无指纹：沿用块轮询（从 block 之后前进，原语义不变）。
+    const uid = fp !== ''
+      ? this.allocSession(pool, modelId, fp)
+      : pool[(block === undefined ? this.rrCursor : Math.max(0, pool.indexOf(block) + 1)) % pool.length]!
     this.rrCursor = (pool.indexOf(uid) + 1) % pool.length
     this.blocks.set(this.blockKey(modelId), uid)
     if (fp !== '') {
       this.bind(modelId, fp, uid)
+      const free = this.freeUids(pool, modelId, fp)
+      why.push(free.length === 0 ? `号已铺满，按游标复用 ${uid}` : `铺开到空闲号 ${uid}`)
     } else {
       // 新驻留 = 新观察窗口（旧行为：块计数从 0 开始）。样本是跨驻留累计的，
       // 不清的话上一个大样本会立刻把新驻留判走。
       this.samples.delete(this.key(modelId, uid))
+      why.push(`块推进到 ${uid}`)
     }
+    this.lastWhy = why.join('；')
+    return uid
+  }
+
+  /**
+   * 新会话分配：优先返回**未被其它会话占用**的号（按游标推进），
+   * 空闲号用尽才回绕到已占用的号（此时按游标复用，语义等同旧行为）。
+   *
+   * 「占用」= 该 model 的绑定表里，某个 **其它** 指纹当前指向该 uid。
+   * 同一会话自己的旧绑定不算占用（它已经在上面的亲和分支处理过，走到这里
+   * 说明原绑定不可用，允许它改绑到自己的其它号或空闲号）。
+   */
+  private allocSession(pool: string[], modelId: string, fp: string): string {
+    const free = this.freeUids(pool, modelId, fp)
+    const candidates = free.length > 0 ? free : pool
+    const uid = candidates[this.rrCursor % candidates.length]!
     return uid
   }
 
+  /** 当前 model 下、本指纹之外没有任何其它会话绑定的号（按 pool 原顺序）。 */
+  private freeUids(pool: string[], modelId: string, fp: string): string[] {
+    const taken = new Set<string>()
+    const m = this.affinity.get(this.blockKey(modelId))
+    if (m !== undefined) {
+      for (const [k, v] of m) {
+        if (k !== fp) taken.add(v)
+      }
+    }
+    return pool.filter((uid) => !taken.has(uid))
+  }
+
+  /** 上一次 pick 的选号理由（诊断用：解释"为什么没粘住原号"）。 */
+  lastWhy = ''
+
   /** 记下「前缀指纹 → 号」的绑定（LRU：超上限丢最久未用的）。 */
   private bind(modelId: string, fp: string, uid: string): void {
     const k = this.blockKey(modelId)
@@ -314,9 +396,14 @@ export class AccountPool {
     }
   }
 
-  /** 该号在本模型上是否被判定「缓存无效」（降权中）。 */
-  private isDemoted(uid: string, modelId: string, now: number): boolean {
-    const e = this.demoted.get(this.key(modelId, uid))
+  /**
+   * 该号在**本会话**（有身份时）本模型上是否被判定「缓存无效」（降权中）。
+   *
+   * 判据按会话隔离（见 sampleKey）：降权只惩罚「这个会话在这个号上真的
+   * 反复不命中」，不会因别的会话共用同号互踩而被牵连。
+   */
+  private isDemoted(uid: string, modelId: string, now: number, session?: string): boolean {
+    const e = this.demoted.get(this.sampleKey(modelId, uid, session))
     return e !== undefined && e.until > now
   }
 
@@ -344,14 +431,16 @@ export class AccountPool {
    * 记录一次成功请求的缓存命中情况（降权判据的反馈信号）。
    *
    * 只有**成功**请求才计入：失败没产生缓存，计入会污染命中率并导致错降权。
-   * 统计按 (model, uid) 记，**不管这个号是不是「当前驻留」**——亲和开启后
-   * 多个会话各绑各的号交错服务，按驻留记会漏掉大部分真实反馈。
+   * 统计按 (model, uid[, session]) 记，**不管这个号是不是「当前驻留」**——
+   * 亲和开启后多个会话各绑各的号交错服务，按驻留记会漏掉大部分真实反馈。
+   * 按会话隔离（见 sampleKey）则保证「多会话共用同号互踩」不会误伤降权。
    * @param uid 实际服务的号
    * @param modelId 模型（块粒度）
    * @param cachedTokens 上游报的命中 token 数；0 = 全量重算
+   * @param session 宿主会话身份；有则按会话隔离统计
    */
-  noteCache(uid: string, modelId: string, cachedTokens: number): void {
-    const k = this.key(modelId, uid)
+  noteCache(uid: string, modelId: string, cachedTokens: number, session?: string): void {
+    const k = this.sampleKey(modelId, uid, session)
     const s = this.samples.get(k) ?? { served: 0, hits: 0 }
     s.served += 1
     if (cachedTokens > 0) s.hits += 1

package/src/router/index.ts

@@ -1,7 +1,7 @@
 /**
  * dsh-router 路由器本体：供应商注册表 + OpenAI 兼容 /v1/* 处理。
- * 仿 9router：组合 = 一组模型，请求 model 命中组合名时，按策略
- * （fallback 顺序尝试 / round-robin 轮转）选中一个模型路由。
+ * 仿 9router：组合 = 一组模型，请求 model 命中组合名时，作为降级链
+ * 按序尝试选中一个模型路由（无策略旋钮，见 docs/pool-sticky-block.md §10）。
  */
 import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
 import { dirname, join } from 'node:path'
@@ -24,6 +24,8 @@ interface ChatTrace {
   lastError?: string
   /** 最后一次失败的状态（组合据此判断要不要「喘口气」再降级）。 */
   lastState?: AccountState
+  /** 本次选号的理由（诊断「为什么没粘住原号」）。 */
+  pickWhy?: string
 }
 
 /**
@@ -527,9 +529,7 @@ export class Router {
   private suppliers: Supplier[] = []
   private combosFp = ''
   private customCombos: Combo[] = []
-  /** round-robin 轮转游标（按组合 id 记忆）。 */
-  private rrCursors = new Map<string, number>()
-  /** 通用供应商配置（连接池顺序/策略、模型启用、别名）。 */
+  /** 通用供应商配置（连接池顺序、模型启用、别名）。 */
   private store: SupplierConfigStore
   /** 模型列表缓存（supplierId → 模型 + 拉取时间）。插件只管拉，不缓存。 */
   private modelsCache = new Map<string, { models: ModelWithEnabled[]; fetchedAt: number }>()
@@ -565,7 +565,7 @@ export class Router {
     try {
       const f = JSON.parse(readFileSync(this.combosFp, 'utf8')) as { combos?: Combo[] }
       if (Array.isArray(f.combos)) {
-        // 兼容旧格式：steps(供应商) → models(模型)；无 strategy 默认 fallback。
+        // 兼容旧格式：steps(供应商) → models(模型)；旧 strategy 字段静默忽略。
         this.customCombos = f.combos
           .filter((c) => typeof c.id === 'string' && c.id !== '')
           .map((c) => {
@@ -595,7 +595,6 @@ export class Router {
             return {
               id: c.id,
               name: typeof c.name === 'string' ? c.name : c.id,
-              strategy: c.strategy === 'round-robin' ? 'round-robin' as const : 'fallback' as const,
               models,
             }
           })
@@ -819,10 +818,6 @@ export class Router {
       typeof m === 'string' && m !== '')
   }
 
-  private validStrategy(strategy: string | undefined): strategy is 'fallback' | 'round-robin' {
-    return strategy === 'fallback' || strategy === 'round-robin'
-  }
-
   /** 组合模型统一存裸 id：剥掉 alias/ 前缀（前缀随供应商动态变）。
    *  只剥「已知 alias + /」开头的前缀——模型 id 本身可以含斜杠
    *  （如 nvidia 的 `deepseek-ai/deepseek-v4-flash-0731`），用 lastIndexOf 会把
@@ -849,22 +844,21 @@ export class Router {
       })
   }
 
-  /** 创建组合（name 唯一，非 default）。 */
-  createCombo(name: string, strategy: string, models: string[]): { ok: boolean; error?: string; combo?: Combo } {
+  /** 创建组合（name 唯一，非 default）。选模型是降级链（按序尝试），无策略。 */
+  createCombo(name: string, models: string[]): { ok: boolean; error?: string; combo?: Combo } {
     const clean = name.trim()
     if (clean === '' || clean === 'default') return { ok: false, error: '组合名无效' }
     if (!/^[A-Za-z0-9._-]+$/.test(clean)) return { ok: false, error: '组合名只能含字母、数字、-、_ 和 .' }
     if (this.customCombos.some((c) => c.name === clean)) return { ok: false, error: `组合 ${clean} 已存在` }
     if (!this.validModels(models)) return { ok: false, error: '至少需要一个模型' }
-    if (!this.validStrategy(strategy)) return { ok: false, error: '策略无效' }
-    const combo: Combo = { id: clean, name: clean, strategy, models: this.normalizeModelIds(models) }
+    const combo: Combo = { id: clean, name: clean, models: this.normalizeModelIds(models) }
     this.customCombos.push(combo)
     this.saveCombos()
     return { ok: true, combo }
   }
 
   /** 更新组合（按 id）。 */
-  updateCombo(id: string, name: string, strategy: string, models: string[]): { ok: boolean; error?: string } {
+  updateCombo(id: string, name: string, models: string[]): { ok: boolean; error?: string } {
     const target = this.customCombos.find((c) => c.id === id)
     if (!target) return { ok: false, error: '组合不存在' }
     const clean = name.trim()
@@ -872,9 +866,7 @@ export class Router {
     if (!/^[A-Za-z0-9._-]+$/.test(clean)) return { ok: false, error: '组合名只能含字母、数字、-、_ 和 .' }
     if (this.customCombos.some((c) => c.id !== id && c.name === clean)) return { ok: false, error: `组合 ${clean} 已存在` }
     if (!this.validModels(models)) return { ok: false, error: '至少需要一个模型' }
-    if (!this.validStrategy(strategy)) return { ok: false, error: '策略无效' }
     target.name = clean
-    target.strategy = strategy
     target.models = this.normalizeModelIds(models)
     this.saveCombos()
     return { ok: true }
@@ -929,19 +921,16 @@ export class Router {
         ttfbMs: probe.ttfbMs,
         // 只有真被服务过才记 uid：失败请求的 uid 可能是空或上一次的残留
         ...(ok && probe.uid !== '' ? { uid: probe.uid } : {}),
+        ...(req.session === undefined ? {} : { session: req.session }),
         ...(error === undefined ? {} : { error }),
       }, usage)
     }
 
     const combo = this.comboByName(req.model)
     if (combo) {
-      // 组合：按策略选起点，然后按组合模型顺序回退
-      const start = combo.strategy === 'round-robin'
-        ? (this.rrCursors.get(combo.id) ?? 0) % combo.models.length
-        : 0
-      if (combo.strategy === 'round-robin') this.rrCursors.set(combo.id, (this.rrCursors.get(combo.id) ?? 0) + 1)
+      // 组合 = 降级链：从第一个模型起顺序尝试，谁先服务成功就停。
       for (let i = 0; i < combo.models.length; i++) {
-        const model = combo.models[(start + i) % combo.models.length]
+        const model = combo.models[i]
         if (model === undefined) continue
         const trace: ChatTrace = { attempts: 0 }
         const served = await this.chatWithModel(req, res, model, probe, trace)
@@ -1042,7 +1031,7 @@ export class Router {
       outTrace.lastState = trace.lastState
     }
     this.logChat(req.model, served
-      ? `${s.id}/${modelId} (${trace.uid ?? '?'}) ok${trace.attempts > 0 ? ` 重试${trace.attempts}次` : ''}`
+      ? `${s.id}/${modelId} (${trace.uid ?? '?'}) ok${trace.attempts > 0 ? ` 重试${trace.attempts}次` : ''}${trace.pickWhy !== undefined ? ` [选号: ${trace.pickWhy}]` : ''}`
       : `${s.id}/${modelId} 失败 ${trace.lastError ?? 'no account'}`, Date.now() - t0)
     return served
   }
@@ -1093,9 +1082,11 @@ export class Router {
     // 否则同一会话的两次尝试会绑到不同的号上）。
     const messages = reqMessages(req.rawBody)
     const tried = new Set<string>()
+    let pickWhy = ''
     for (;;) {
-      const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, cfg.poolStrategy, req.model, messages)
+      const uid = pool.pick(s.accounts().filter((a) => !tried.has(a.uid)), cfg.poolOrder, req.model, messages, req.session)
       if (uid === undefined) return false
+      pickWhy = pool.lastWhy
       tried.add(uid)
       const r = await s.chatOnce(uid, req.lv ?? 'auto', req)
       if (!r.ok) {
@@ -1121,7 +1112,10 @@ export class Router {
         continue
       }
       pool.noteSuccess(uid, req.model)
-      if (trace !== undefined) trace.uid = uid
+      if (trace !== undefined) {
+        trace.uid = uid
+        trace.pickWhy = pickWhy
+      }
       if (probe !== undefined) {
         probe.supplier = s.id
         // 记对外全名 alias/model：与直接调用路径一致。组合里存的是裸
@@ -1133,7 +1127,7 @@ export class Router {
       const committed = await writeChatResult(res, r, req.stream, probe, probe?.startedAt ?? 0)
       if (committed) {
         // 块轮询反馈：只有成功请求才计入（失败没产生缓存，计入会污染命中率）
-        pool.noteCache(uid, req.model, probe?.tokens?.cachedTokens ?? 0)
+        pool.noteCache(uid, req.model, probe?.tokens?.cachedTokens ?? 0, req.session)
         return true
       }
       // 一个字节都没写（上游刚连上就断）→ 这个号不算数，换下一个重试

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

@@ -357,7 +357,7 @@ test('每次 chat 记一行：组合名 → 供应商/模型 (账号) 结果', a
   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)
+  assert.equal(router.createCombo('combo1', ['supA,a-m']).ok, true)
 
   const res = {
     writeHead: (): void => {},
@@ -370,7 +370,7 @@ test('每次 chat 记一行：组合名 → 供应商/模型 (账号) 结果', a
   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]}`)
+  assert.match(lines[0] ?? '', /^chat "combo1" → supA\/a-m \(u1\) ok( \[选号: .+?\])? \d+ms$/, `日志格式不对: ${lines[0]}`)
 })
 
 test('失败的成员也要记，且带真实原因（不能笼统写 no account）', async () => {
@@ -384,7 +384,7 @@ test('失败的成员也要记，且带真实原因（不能笼统写 no account
   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)
+  assert.equal(router.createCombo('c1', ['dead,dead-m', 'live,live-m']).ok, true)
 
   const res = {
     writeHead: (): void => {},
@@ -428,7 +428,7 @@ test('流在写出第一个字节前就断 → 组合回退到下一个模型',
   })
   addSupplier(router, dead.s)
   addSupplier(router, live.s)
-  assert.equal(router.createCombo('c1', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+  assert.equal(router.createCombo('c1', ['dead,dead-m', 'live,live-m']).ok, true)
 
   let out = ''
   let heads = 0
@@ -479,7 +479,7 @@ test('已写出字节后断流 → 截断并补 [DONE]，不回退也不二次
   })
   addSupplier(router, half.s)
   addSupplier(router, live.s)
-  assert.equal(router.createCombo('c2', 'fallback', ['half,half-m', 'live,live-m']).ok, true)
+  assert.equal(router.createCombo('c2', ['half,half-m', 'live,live-m']).ok, true)
 
   let out = ''
   let heads = 0
@@ -552,7 +552,7 @@ test('首字节前就断 → 不补 [DONE]，留给组合回退', async () => {
   })
   addSupplier(router, dead.s)
   addSupplier(router, live.s)
-  assert.equal(router.createCombo('c3', 'fallback', ['dead,dead-m', 'live,live-m']).ok, true)
+  assert.equal(router.createCombo('c3', ['dead,dead-m', 'live,live-m']).ok, true)
 
   let out = ''
   const res = {
@@ -683,7 +683,7 @@ test('组合窗口：取组合内模型的最小值，单位 K → token', async
     { id: 'a-2', context_length: 1000 },  // 1M
   ]).s)
   await router.modelsOf('a') // 填缓存
-  const w = router.comboContextWindow({ id: 'x', name: 'x', strategy: 'fallback', models: ['a,a-1', 'a,a-2'] })
+  const w = router.comboContextWindow({ id: 'x', name: 'x', models: ['a,a-1', 'a,a-2'] })
   assert.equal(w, 128_000, '取最小的那个（fallback 到任意一条分支都得成立）')
 })
 
@@ -692,7 +692,7 @@ test('组合窗口：供应商还没缓存过 → undefined（不猜，绝不打
   addSupplier(router, supplier('a', [{ id: 'a-1', context_length: 128 }]).s)
   // 故意不调 modelsOf：模拟冷启动
   assert.equal(
-    router.comboContextWindow({ id: 'x', name: 'x', strategy: 'fallback', models: ['a,a-1'] }),
+    router.comboContextWindow({ id: 'x', name: 'x', models: ['a,a-1'] }),
     undefined,
     '没缓存就报 undefined —— 压缩这轮跳过，下次就有，比撒谎安全',
   )
@@ -703,7 +703,7 @@ test('组合窗口：模型都没报 context_length → undefined', async () =>
   addSupplier(router, supplier('a', [{ id: 'a-1' }]).s)
   await router.modelsOf('a')
   assert.equal(
-    router.comboContextWindow({ id: 'x', name: 'x', strategy: 'fallback', models: ['a,a-1'] }),
+    router.comboContextWindow({ id: 'x', name: 'x', models: ['a,a-1'] }),
     undefined,
     '一家都没报就别编一个数（traework/nvidia 目前就是如此）',
   )

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

@@ -87,7 +87,7 @@ test('组合只调目标供应商，其它供应商一次都不会被问', async
   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, '组合必须创建成功')
+  assert.equal(router.createCombo('my-combo', ['supB,b-model']).ok, true, '组合必须创建成功')
 
   await router.chatCompletions(reqWith('my-combo'), fakeRes())
 
@@ -140,8 +140,8 @@ test('组合存了缺供应商前缀的裸模型 id → 直接失败，不降级
   const b = spy('supB', 'b-model')
   add(router, a.s); add(router, b.s)
   // 模拟旧存储：裸 id，没有 supplierId 前缀 —— 图6 下这是配置错误，不遍历兜底
-  ;(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'] })
+  ;(router as unknown as { customCombos: Array<{ id: string; name: string; models: string[] }> })
+    .customCombos.push({ id: 'legacy', name: 'legacy', models: ['b-model'] })
 
   const errs: unknown[] = []
   const res = { ...fakeRes(), end: (x?: string): unknown => { if (x) errs.push(x); return undefined } } as unknown as ServerResponse
@@ -156,7 +156,7 @@ test('组合存了不存在的供应商 id → 调用失败，不静默落到别
   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, '组合必须创建成功')
+  assert.equal(router.createCombo('broken', ['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
@@ -274,7 +274,7 @@ test('组合：瞬时故障降级前会等一等，不是毫秒级打穿整个
   const m1 = failingSpy('s1', 'm1', 'transport')
   const m2 = failingSpy('s2', 'm2', 'unavailable')
   add(router, m1.s); add(router, m2.s)
-  router.createCombo('combo', 'fallback', ['s1,m1', 's2,m2'])
+  router.createCombo('combo', ['s1,m1', 's2,m2'])
 
   const t0 = Date.now()
   await router.chatCompletions(reqWith('combo'), fakeRes())
@@ -291,7 +291,7 @@ test('组合：no_such_model 不是故障，降级不该等', async () => {
   const m1 = failingSpy('s1', 'm1', 'no_such_model')
   const m2 = failingSpy('s2', 'm2', 'no_such_model')
   add(router, m1.s); add(router, m2.s)
-  router.createCombo('combo', 'fallback', ['s1,m1', 's2,m2'])
+  router.createCombo('combo', ['s1,m1', 's2,m2'])
 
   const t0 = Date.now()
   await router.chatCompletions(reqWith('combo'), fakeRes())

package/src/router/prefix-affinity.ts

@@ -59,7 +59,28 @@ function textOf(content: unknown): string {
 }
 
 /**
- * 算请求的前缀指纹。
+ * 算请求的亲和指纹（选号主键）。
+ *
+ * **身份优先，内容兜底**：
+ *   1. 宿主给了会话身份（`session`，来自 dsh-llm 的 `sessionId`）→ 直接用它。
+ *      精确、零撞车 —— 同一会话永不漂移，不同会话（含 team 各成员）天然隔离。
+ *   2. 没有身份（外部 OpenAI 客户端）→ 回落 {@link prefixFingerprint}。
+ *
+ * 为什么优先身份而不是内容指纹：DSH 的 system prompt 是同一个 agent preset
+ * 生成的几 KB 文本，内容指纹只取前 512 字符 → 各会话高度雷同 → 撞车导致
+ * 绑定互相覆盖、同会话漂移（team 多成员时实测过）。
+ *
+ * @param session 宿主会话身份；无则 undefined
+ * @param messages OpenAI 请求体的 `messages`（无身份时才用）
+ * @returns 指纹字符串；**空串 = 算不出来（无亲和，回退到块轮询）**
+ */
+export function sessionFingerprint(session: string | undefined, messages: unknown): string {
+  if (session !== undefined && session !== '') return `sid:${session}`
+  return prefixFingerprint(messages)
+}
+
+/**
+ * 算请求的前缀指纹（内容兜底）。
  * @param messages OpenAI 请求体的 `messages` 字段（未校验，来自外部输入）
  * @returns 指纹字符串；**空串 = 算不出来（无亲和，回退到块轮询）**
  */

package/src/router/types.ts

@@ -37,14 +37,10 @@ export interface ModelWithEnabled extends ModelInfo {
   custom?: boolean
 }
 
-/** 组合策略：fallback = 按顺序尝试；round-robin = 轮转。 */
-export type ComboStrategy = 'fallback' | 'round-robin'
-
-/** 组合：命名的一组模型，路由时按策略（回退/轮询）命中其中一个。 */
+/** 组合：命名的一组模型，路由时作为**降级链**按序尝试（无策略旋钮）。 */
 export interface Combo {
   id: string
   name: string
-  strategy: ComboStrategy
   models: string[]
 }
 
@@ -56,6 +52,12 @@ export interface ChatRequest {
   model: string
   /** 推理等级（reasoning effort），供应商各自决定怎么映射到上游。缺省 = 'auto'。 */
   lv?: string
+  /**
+   * 宿主盖的会话身份（dsh-llm `GenerateOptions.sessionId`），由 adapter 转成
+   * 内部头带进来。用于把用量记录**按会话归因**（「最近命中」徽章要按当前会话
+   * 显示，而不是显示别的会话的命中）。缺省 = 非宿主调用（外部 OpenAI 客户端）。
+   */
+  session?: string
 }
 
 /**

package/src/router/usage-store.ts

@@ -54,6 +54,11 @@ export interface UsageRecord {
   uid?: string
   /** 失败原因（ok=false 时）。 */
   error?: string
+  /**
+   * 宿主会话身份（有则记）。用于「最近命中」按当前会话归因 —— 徽章要显示
+   * 当前会话的命中，而不是全局最近（team 多会话下后者会张冠李戴）。
+   */
+  session?: string
 }
 
 /** 按某个维度（供应商/模型/请求名）聚合的小计。 */
@@ -389,6 +394,17 @@ export class UsageStore {
     return this.recent.slice(0, limit)
   }
 
+  /**
+   * 最近一次命中。给了 `session` 就只在该会话的记录里找（「最近命中」徽章
+   * 要显示**当前会话**的命中，team 多会话下全局最近会张冠李戴）；
+   * 不给则退回全局最近一条。
+   * @param session 宿主会话身份；undefined = 全局
+   */
+  lastHit(session?: string): UsageRecord | undefined {
+    if (session === undefined) return this.recent[0]
+    return this.recent.find((r) => r.session === session)
+  }
+
   clear(): void {
     this.days.clear()
     this.recent = []

package/src/router/usage.test.ts

@@ -674,7 +674,7 @@ test('请求路径：组合回退试了 3 个模型，只记 1 条（不是 3
   add(router, spy('s1', 'm1', { ok: false, state: 'quota', message: 'no quota' }).s)
   add(router, spy('s2', 'm2', { ok: false, state: 'quota', message: 'no quota' }).s)
   add(router, spy('s3', 'm3', { ok: true, status: 200, body: '{"usage":{"prompt_tokens":1,"completion_tokens":1}}' }).s)
-  assert.equal(router.createCombo('c1', 'fallback', ['s1,m1', 's2,m2', 's3,m3']).ok, true)
+  assert.equal(router.createCombo('c1', ['s1,m1', 's2,m2', 's3,m3']).ok, true)
   await router.chatCompletions(
     { model: 'c1', stream: false, rawBody: JSON.stringify({ model: 'c1', messages: [] }) },
     sinkRes(),