dsh-router-core 0.4.5 → 0.4.7

package/lib/types/suppliers/contract.d.ts

@@ -13,6 +13,7 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { ChatRequest, ModelInfo, SupplierAccount } from '../router/types.ts';
 import type { SupplierConfigStore } from '../supplier-config.ts';
 import type { CredentialStore } from '../credential-store.ts';
+import type { ProtocolId } from '../protocol/types.ts';
 /** 供应商配置：loader 注入的运行时环境。 */
 export interface SupplierEnv {
     /** 数据目录（state.json / keys.json 所在目录）。 */
@@ -45,9 +46,16 @@ export interface SupplierEnv {
  * `source` 是**可选标签**，声明这个供应商是从哪儿来的。核心用它把 `/health` 的
  * `source` 报准（面板按它分「内置 / 插件」两组，面板和插件页都看这个值）。
  * 不声明 = `external`（独立安装的供应商插件的现状，一个字段都不用改）。
+ *
+ * `wire` 是**协议标签**（可选）：这个供应商的上游说哪种协议。缺省
+ * `'chat'`（= OpenAI Chat Completions，今天所有供应商的现状，一个都不用改）。
+ * 声明成别种时，核心在把 `req` 交给插件前把规范请求体翻成它的协议，
+ * 并把它的响应流翻回规范形态 —— 插件看到的仍是「OpenAI SSE」，
+ * 于是**契约不变、已有插件全都不动**。详见 `protocol/`。
  */
 export type SupplierFactory = ((env: SupplierEnv) => SupplierModule) & {
     source?: 'builtin';
+    wire?: ProtocolId;
 };
 /**
  * 账户此刻的状态 —— 插件**解读**上游信号后的语义状态。
@@ -111,11 +119,17 @@ export type ChatOnceResult =
     status: number;
     body: string;
 }
-/** 失败：核心据此做冷却/换号。 */
+/**
+ * 失败：核心据此做冷却/换号。
+ * `resetAt` = 上游自己声明的重置时刻（epoch ms，可选）：限流类错误带它时
+ * 核心冷却到该点，而不是指数退避——频率配额的重置是小时级的，5min 上限的
+ * 退避只会到点回来再撞（2026-10-15 的 6004 事故：11 个号轮流被打冷）。
+ */
  | {
     ok: false;
     state: AccountState;
     message: string;
+    resetAt?: number;
 };
 /** 供应商模块 —— 契约（核心必须，差异化可选）。 */
 export interface SupplierModule {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "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": {
@@ -105,7 +105,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.4"
+    "@deepseek-ai/schemastery": "^3.18.5"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
@@ -113,8 +113,8 @@
     "@deepseek-ai/dsh-client-ui-primitives": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-client-ui-slots": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-llm": "^0.2.0-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-settings": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.0-rc.2",
     "cordis": "^4.0.0-rc.7",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
@@ -134,13 +134,13 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^26.6.2",
+    "@types/node": "^26.6.5",
     "@types/react": "~19.3.0",
     "@types/react-dom": "~19.3.0",
     "cordis": "4.0.0-rc.10",
-    "react": "^19.3.0",
+    "react": "^19.3.1",
     "react-dom": "19.3.0",
-    "tsdown": "^0.23.0",
+    "tsdown": "^0.23.1",
     "typescript": "^7.0.2",
     "vite": "8.3.0",
     "vite-plugin-css-injected-by-js": "^5.0.2"

package/src/client/ExtDetail.tsx

@@ -16,10 +16,11 @@
  * 名称/副行，下面跟扩展说明卡与未就绪横幅。有 `api()` 支持的自定义扩展可在未来
  * 按需加独立面板，此处不内置任何具体扩展的专属视图。
  */
-import { useEffect, useState } from 'react'
+import { Fragment, useEffect, useState } from 'react'
 import { Switch } from '@deepseek-ai/dsh-client-ui-primitives'
 import { ROUTER_API_BASE, type ExtControlItem, type RouterExtItem, type RouterExtResponse } from '../shared.ts'
 import { extPanel } from './ext-panels.ts'
+import { groupControlRows } from './group-controls.ts'
 import { Modal } from './Modal.tsx'
 
 /**
@@ -436,14 +437,30 @@ function ExtControls({ item }: { item: RouterExtItem }): JSX.Element {
             它只剩两个字，却仍占一行 —— 页面进来第一眼是「子开关」这三个字而不是
             那些规则本身。列表自带每条的标题与开关，不需要再套一层说明。 */}
         <ul className="dshr-compRows">
-          {controls.map((c, index) => (
+          {/* 分组渲染（`ExtControl.group`）：无组节（准则分类）平铺在前 ——
+              没用 group 的扩展拿到的就是原来的平铺列表，行为不变；有组的
+              条目（宿主段落）每组前插一行组标题。组的先后与组内顺序都来自
+              服务端 `rows`（= prompt 序），这里不重排。 */}
+          {groupControlRows(controls).map((g) => (
+            <Fragment key={g.label ?? '__plain__'}>
+              {g.label !== undefined && (
+                <li className="dshr-extGroupTitle">{g.label}</li>
+              )}
+              {g.items.map((c) => {
+                // 下标永远对 `controls`（= 服务端 rows）取：分组只影响**渲染
+                // 顺序**，拖动落盘的 ids 必须基于原列表 —— 段落行不可拖（见下），
+                // 可拖的准则全在无组节，原下标与视图位置天然一致。
+                const index = controls.indexOf(c)
+                const sortable = c.sortable !== false
+                return (
             <li
               key={c.id}
               className={`dshr-compRow${dragIndex === index ? ' dshr-linkRowDragging' : ''}`}
-              draggable
-              onDragStart={(e) => { setDragIndex(index); e.dataTransfer.effectAllowed = 'move' }}
-              onDragOver={(e) => { e.preventDefault(); e.dataTransfer.dropEffect = 'move' }}
+              draggable={sortable}
+              onDragStart={(e) => { if (!sortable) return; setDragIndex(index); e.dataTransfer.effectAllowed = 'move' }}
+              onDragOver={(e) => { if (!sortable) return; e.preventDefault(); e.dataTransfer.dropEffect = 'move' }}
               onDrop={(e) => {
+                if (!sortable) { setDragIndex(null); return }
                 e.preventDefault()
                 if (dragIndex === null || dragIndex === index) { setDragIndex(null); return }
                 const next = [...controls]
@@ -511,6 +528,9 @@ function ExtControls({ item }: { item: RouterExtItem }): JSX.Element {
                 onChange={(next) => { void toggle(c.id, next) }}
               />
             </li>
+                )
+              })}
+            </Fragment>
           ))}
         </ul>
         {withBody.length === 0 && (

package/src/client/group-controls.test.ts

@@ -0,0 +1,53 @@
+/**
+ * 详情页 controls 分组的判据（`group-controls.ts`）。
+ *
+ * 关键是**向后兼容不可退**：没用 `group` 字段的扩展（ext-test 等）必须
+ * 拿到"一个无组节、顺序不变"的结果 —— 分组是新能力的**叠加**，不是重排。
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { groupControlRows } from './group-controls.ts'
+import type { ExtControlItem } from '../shared.ts'
+
+function row(id: string, extra: Partial<ExtControlItem> = {}): ExtControlItem {
+  return { id, title: id, on: true, custom: false, overridden: false, ...extra }
+}
+
+test('★ 全部无组 ⇒ 单一个无组节（旧扩展的面板展示与改动前一致）', () => {
+  const groups = groupControlRows([row('a'), row('b')])
+  assert.equal(groups.length, 1)
+  assert.equal(groups[0]!.label, undefined)
+  assert.deepEqual(groups[0]!.items.map((i) => i.id), ['a', 'b'], '无组条目顺序被改了')
+})
+
+test('★ 无组节恒排最前，且不产出空的无组节', () => {
+  const groups = groupControlRows([row('a'), row('t1', { group: '工具说明' })])
+  assert.deepEqual(groups.map((g) => g.label), [undefined, '工具说明'])
+  const onlyGrouped = groupControlRows([row('t1', { group: '工具说明' })])
+  assert.deepEqual(onlyGrouped.map((g) => g.label), ['工具说明'], '只有分组条目时不该冒出一个空的无组节')
+})
+
+test('组的先后 = 首次出现序（不按字母重排）', () => {
+  const groups = groupControlRows([
+    row('h', { group: '开场身份' }),
+    row('w', { group: '工具说明' }),
+    row('e', { group: '工具说明' }),
+    row('p', { group: '计划模式' }),
+  ])
+  assert.deepEqual(groups.map((g) => g.label), ['开场身份', '工具说明', '计划模式'])
+  assert.deepEqual(groups[1]!.items.map((i) => i.id), ['w', 'e'], '组内顺序被重排 ⇒ 面板序与 prompt 序脱钩')
+})
+
+test('同名组跨位置仍归一组（不因中间夹了别的组而拆开）', () => {
+  const groups = groupControlRows([
+    row('w1', { group: '工具说明' }),
+    row('h', { group: '开场身份' }),
+    row('w2', { group: '工具说明' }),
+  ])
+  const tool = groups.find((g) => g.label === '工具说明')!
+  assert.deepEqual(tool.items.map((i) => i.id), ['w1', 'w2'])
+})
+
+test('空输入 ⇒ 空数组', () => {
+  assert.deepEqual(groupControlRows([]), [])
+})

package/src/client/group-controls.ts

@@ -0,0 +1,43 @@
+/**
+ * 扩展详情页 controls 的**分组**纯逻辑（客户端，可单测）。
+ *
+ * 分组是**归属信息**，不是样式：一条扩展同时管两类东西时（分层提示词 =
+ * 准则分类 + 宿主系统提示词段落），平铺成一长列无从分辨哪条是谁的。
+ *
+ * 两条规则：
+ *   ① **无组节恒排最前** —— 没用 `group` 字段的扩展（ext-test 等）拿到的
+ *      分组结果就是原来的平铺列表（一个无名节），面板行为一个像素不变；
+ *   ② 组的先后 = 组名在 `rows` 里的**首次出现序**，组内保持原顺序 ——
+ *      不按字母重排：`rows` 的顺序来自服务端（段落按 prompt 序），重排
+ *      就会把"面板顺序 ≈ 模型看到的顺序"这条对应关系打断。
+ */
+import type { ExtControlItem } from '../shared.ts'
+
+/** 一个分组：`label === undefined` 表示"无组节"（平铺条目）。 */
+export interface ControlGroup {
+  label?: string
+  items: ExtControlItem[]
+}
+
+/** 按 `group` 分组；空输入返回空数组（不产出空的无组节）。 */
+export function groupControlRows(rows: readonly ExtControlItem[]): ControlGroup[] {
+  const plain: ExtControlItem[] = []
+  const groups: ControlGroup[] = []
+  const byLabel = new Map<string, ExtControlItem[]>()
+  for (const c of rows) {
+    if (c.group === undefined) {
+      plain.push(c)
+      continue
+    }
+    let items = byLabel.get(c.group)
+    if (!items) {
+      items = []
+      byLabel.set(c.group, items)
+      groups.push({ label: c.group, items })
+    }
+    items.push(c)
+  }
+  const out: ControlGroup[] = []
+  if (plain.length > 0) out.push({ items: plain })
+  return [...out, ...groups]
+}

package/src/client/router.css

@@ -3360,6 +3360,25 @@ html[data-dsh-router-active]:not([data-dsh-taskboard-active]):not(
     list-style: none;
 }
 
+/* 分组标题行 —— `ExtControl.group` 的渲染落点，插在 `.dshr-compRows` 里
+   的非交互 <li>（无拖把/开关，不可点）。与 `compTitle` 的区别：那是详情页
+   主标题（页头），这是**组**名（次要色 + 小字号）。左右 14px 对齐
+   `.dshr-compRow` 的行内缩，组名与行文字左缘一致。 */
+.dshr-extGroupTitle {
+    margin: 14px 0 2px;
+    padding: 0 14px;
+    color: var(--dsw-alias-label-tertiary);
+    font-size: 12px;
+    font-weight: 500;
+    line-height: 18px;
+    list-style: none;
+}
+
+/* 全部分组的扩展：首个渲染节点就是组标题，去掉上边距避免顶双空。 */
+.dshr-extGroupTitle:first-child {
+    margin-top: 0;
+}
+
 .dshr-compRow {
     display: flex;
     align-items: center;
@@ -3489,7 +3508,7 @@ html[data-dsh-router-active]:not([data-dsh-taskboard-active]):not(
     overflow-wrap: anywhere;
     /* 保留换行：子开关的**原文**是这个类的另一个用法（2026-09-29 合并进来），
        它是多行段落。状态文案都是单行，所以这条对它们没有副作用。
-       ⇒ 原来的 `.dshr-compRowBody` 整块删掉：14 条规则的正文不需要左边框 +
+       ⇒ 原来的 `.dshr-compRowBody` 整块删掉：各条规则的正文不需要左边框 +
        缩进那种「引用块」的额外装饰（用户要求），层级只靠颜色就够。 */
     white-space: pre-wrap;
 }

package/src/ext/contract.ts

@@ -68,7 +68,7 @@ export interface RouterExt {
    * 扩展自带的**子开关**（可选；不声明 = 只有总开关）。
    *
    * 为什么需要：有些扩展的「开/关」不是一件事而是**几件独立的事** —— 例如分层
-   * 提示词有 14 个准则分类，每条都该能单独关。硬塞进一个总开关 = 要么全给、
+   * 提示词的准则分类，每条都该能单独关。硬塞进一个总开关 = 要么全给、
    * 要么全不给。
    *
    * ⚠️ **与总开关的关系**：子开关是**叠加**在总开关之上的，总开关关 ⇒ 全部子开关
@@ -179,6 +179,25 @@ export interface ExtControl {
   readonly custom?: boolean
   /** 文本被用户改过（决定「还原」按钮是否可点）。 */
   readonly overridden?: boolean
+  /**
+   * 分组名（可选；缺省 = 无组）—— 面板按它把控制条**分节**渲染，组间插一条
+   * 组标题行，组内顺序照旧。**无组的条目照旧平铺** ⇒ 没用这个字段的扩展
+   * （ext-test 等）面板行为一个像素都不变。
+   *
+   * 为什么要有：一条扩展同时管两类东西时（分层提示词 = 准则分类 + 宿主段落），
+   * 平铺成一长列会让"哪条是准则、哪条是宿主的段"无从分辨 —— 分组是**归属
+   * 信息**，不是样式。
+   */
+  readonly group?: string
+  /**
+   * 这一条参与拖动排序（可选；缺省 = 参与，保持既有行为）。
+   *
+   * 为什么需要显式关掉：排序落盘只认扩展自己的条目 id（`setControlOrder`
+   * 过滤未知 id）—— 宿主段落的 id 不在其中，拖它只会被静默丢弃 ⇒ 看起来能拖、
+   * 松手弹回，是假交互。**由扩展逐条声明**，与 `editable` 同一理由：能力在
+   * 实现方手里，由它说哪条有。
+   */
+  readonly sortable?: boolean
 }
 
 /** 面板/API 用的一条扩展器信息 = 核心存的开关 + 插件报的运行时事实。 */

package/src/ext-prompt/assembly.test.ts

@@ -18,6 +18,7 @@ import { SystemPrompt, renderPrompt, type PromptAssembly } from '@deepseek-ai/ds
 import { mountPromptSection, PROMPT_SECTION_NAME } from './mount.ts'
 import { renderPromptText } from './render.ts'
 import { PROMPT_CATEGORIES } from './content.ts'
+import { createSectionCache, disabledSectionNames, filterSections } from './sections.ts'
 
 /** 起一个真 systemPrompt 并挂上本扩展。 */
 async function assemble(
@@ -77,3 +78,65 @@ test('装配结果与 renderPromptText 的内容一致（渲染逻辑只有一
   const expected = renderPromptText(true, undefined)
   assert.ok(text.includes(expected), '装配结果里找不到 renderPromptText 的输出 ⇒ 两处实现漂移了')
 })
+
+// ── 段落总控：真宿主装配链上的"关了就没了"（2026-10-21）──────────
+/**
+ * ⚠️ 这里才是段落总控的**终局判据**。前面 `section-filter.test.ts` 验的是
+ * "监听器按规则返回了什么"，而"宿主真把那个返回值当成最终装配"是**另一件事**
+ * —— 宿主源码里 waterfall 之后还有 complete-section 恢复、runtime-context
+ * 抑制等收尾，任何一处改动都可能让我们删的段回来。只有跑真 `assemble()`
+ * 才能钉住。
+ */
+async function assembleWithSections(
+  opts: { masterOn?: boolean; data?: unknown },
+): Promise<{ names: string[]; text: string; dispose: () => void }> {
+  const ctx = new Context()
+  new SystemPrompt(ctx, { includeHarnessIdentity: true, personaPrefix: 'PERSONA-PREFIX-SENTINEL' })
+  let enabled = true
+  const cache = createSectionCache()
+  // 与 index.ts 的监听器**同一形状**：先 next()、喂清单、再按落盘过滤
+  const offAssemble = ctx.on('system-prompt/assemble', async (assembly, _c, next) => {
+    const result = await next()
+    cache.update(result.sections)
+    if ((opts.masterOn ?? enabled) !== true) return result
+    const off = disabledSectionNames(opts.data as never)
+    if (off.size === 0) return result
+    return { ...result, sections: filterSections(result.sections, off) }
+  })
+  // 本扩展自己的准则段（带正文哨兵，便于断言它没被段开关删掉）
+  const dispose = mountPromptSection({
+    getSystemPrompt: () => ctx.systemPrompt,
+    isEnabled: () => true,
+    readData: () => undefined,
+  })
+  await new Promise((r) => setTimeout(r, 10))
+  const a = await ctx.systemPrompt.assemble({})
+  return {
+    names: a.sections.map((s) => s.name),
+    text: renderPrompt(a),
+    dispose: () => { offAssemble(); dispose(); void ctx },
+  }
+}
+
+test('★ 真装配链：关掉某段落 ⇒ 它真的不在最终 prompt 里', async () => {
+  const on = await assembleWithSections({})
+  // 宿主自带的段（关掉 includeHarnessIdentity 也仍在表里的话更好，但优先用我们自己的）
+  assert.ok(on.names.includes(PROMPT_SECTION_NAME), `准则段不在装配里：${on.names.join(', ')}`)
+  const target = on.names.find((n) => n === 'deployment:persona-prefix')
+  assert.ok(target !== undefined, `找不到宿主 persona 段，实际段名：${on.names.join(', ')}`)
+  on.dispose()
+
+  const off = await assembleWithSections({ data: { sections: { [target]: false } } })
+  assert.equal(off.names.includes(target), false, `真装配链里 ${target} 关了却还在`)
+  assert.equal(off.text.includes('PERSONA-PREFIX-SENTINEL'), false, '段没了但正文还在 ⇒ 过滤没生效')
+  // 反向：别的段与准则不能陪葬
+  assert.ok(off.names.includes(PROMPT_SECTION_NAME), '关别人的段时把准则段一起删了')
+  off.dispose()
+})
+
+test('★ 真装配链：总开关关 ⇒ 一个段都不动（扩展关 = 不干预宿主）', async () => {
+  const r = await assembleWithSections({ masterOn: false, data: { sections: { 'deployment:persona-prefix': false } } })
+  assert.ok(r.names.includes('deployment:persona-prefix'), '总开关关掉后仍在过滤 ⇒ 关了还生效')
+  assert.ok(r.text.includes('PERSONA-PREFIX-SENTINEL'), '总开关关掉后 persona 正文不见了')
+  r.dispose()
+})

package/src/ext-prompt/content.ts

@@ -20,6 +20,12 @@
  *      —— 它没有终止条件，每次收口都必然能再找出一件存量，等于无限循环。
  *   ② 固化：由"每次用户可见损失都必须固化"降级为"只对数据丢失/安全这类真损失
  *      补检查"，并删掉「不固化的教训等于决定再犯一次」这句无界义务。
+ *
+ * ⚠️ 2026-10-17 用户点名的两处改动：
+ *   ① **删掉「固化」分类**（整条移除，id `hardening` 不复存在）。用户已存的
+ *      `categories`/`text`/`order` 里残留的 `hardening` 键无须迁移 ——
+ *      `resolveCategories` 规则 2 会忽略不认识的 id。
+ *   ② 身份气质：「默认中文」→「回复、思考过程必须使用中文」。
  */
 
 /** 一个可独立开关的提示词分类。 */
@@ -45,7 +51,7 @@ export const PROMPT_CATEGORIES: readonly PromptCategory[] = [
     title: '身份气质',
     defaultOn: true,
     body:
-      '身份气质：大肥鱼 🐋(资深开发者)；懒=高效不是马虎；安静、克制、直接；默认中文，直接给能跑的东西。',
+      '身份气质：大肥鱼 🐋(资深开发者)；懒=高效不是马虎；安静、克制、直接；回复、思考过程必须使用中文，直接给能跑的东西。',
   },
   {
     id: 'scope',
@@ -80,14 +86,6 @@ export const PROMPT_CATEGORIES: readonly PromptCategory[] = [
       '②反查重复：新旧成两份就并成一处；③反查形状：该合的合、该归档的归位。' +
       '做完那块区域该比动手前更整或更少。',
   },
-  {
-    id: 'hardening',
-    title: '固化',
-    defaultOn: true,
-    body:
-      '固化：只对数据丢失/安全这类真损失补检查——会变红(注入违规必须失败)、可重放(一条命令)、' +
-      '归属清晰(失败信息指向违规处)；普通 bug 修好即止，不额外造闸门。',
-  },
   {
     id: 'verdifiable',
     title: '可判定',
@@ -155,7 +153,7 @@ export const PROMPT_CATEGORIES: readonly PromptCategory[] = [
  *
  * ⚠️ 拆分时差点丢它：原文是 `[…] ·身份气质：…`，标题挂在方括号里、
  *   **不属于任何单条分类**，按分隔符切分时自然被丢掉
- *   （只在 `content.ts` 头注出现过、没进任何 `body`）。⇒ 模型会看到 14 条
+ *   （只在 `content.ts` 头注出现过、没进任何 `body`）。⇒ 模型会看到一堆
  *   **没有名字**的规则，而"这套东西叫什么、为什么存在"恰恰是它需要的上下文。
  *
  * 形状：**不属于任何分类** ⇒ 不可被单条开关关掉（它一关，准则就无名无姓）。