dsh-llm-router 0.1.0

package/LICENSE

@@ -0,0 +1,31 @@
+MIT License
+
+Copyright (c) 2026 zhanghao3693
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+DATA DISCLAIMER
+
+The pricing and discount dataset bundled with this plugin is compiled from
+publicly available vendor information and is provided for informational
+purposes only. Vendor promotions change frequently and without notice.
+Always confirm current pricing on the official vendor page before relying on
+it for cost decisions. See the "数据说明" section of README.md.

package/README.md

@@ -0,0 +1,113 @@
+# dsh-llm-router
+
+一个 DeepSeek Harness（dsh）的 **`auto` 路由 provider**：注册一个名为 `auto`
+的虚拟模型，按请求内容自动挑选后端模型，并在失败时按链回退。
+
+## 它解决什么问题
+
+在 dsh 里，每个 provider 对应一个固定模型。想「看图用视觉模型、长文用长上下文模型、
+其余用便宜的」就得手动切来切去。本插件把这个选择自动化：
+
+```
+请求进入 auto
+   ├─ 含图片            → visionBackend
+   ├─ 输入超阈值字符数   → longContextBackend
+   └─ 其余              → defaultBackend
+                          ↓ 任一后端「产出首个内容前」失败
+                        按 fallbacks 链依次重试
+```
+
+**回退只在「首个内容块产出之前」发生。** 一旦后端已吐出内容，它就该自己负责到底——
+中途失败会如实报错，不会重试（否则用户会看到重复的半个回答）。
+
+## 安装
+
+```bash
+dsh plugin --profile web add dsh-llm-router
+```
+
+安装后 dsh 里会多出 `auto` 这个 provider，把它选为当前模型即可。
+
+## ⚠️ 安装后必须做的事：配置你自己的后端
+
+**默认配置里的 provider 名是作者本机环境的**，别人装了不一定存在。
+不改配置就使用，大概率路由失败（找不到对应 provider）。
+
+在你的 profile patch 层覆盖（`~/.dsh/profiles/<profile>/cordis.patch.yml`）：
+
+```yaml
+- id: llm-router
+  config:
+    defaultBackend:
+      provider: <你的 provider id>
+      model: <模型名>
+    visionBackend:
+      provider: <支持图片的 provider>
+      model: <模型名>
+    longContextBackend:
+      provider: <支持长上下文的 provider>
+      model: <模型名>
+    fallbacks:
+      - provider: <备选1>
+        model: <模型名>
+      - provider: <备选2>
+        model: <模型名>
+```
+
+完整可配项与默认值：
+
+| 字段 | 默认值 | 说明 |
+|---|---|---|
+| `defaultBackend` | `deepseek-official` / `deepseek-v4-pro` | 常规请求 |
+| `visionBackend` | `zai-coding-cn` / `glm-5v-turbo` | 含图请求（**不回退**，见下） |
+| `longContextBackend` | `longcat` / `LongCat-2.0` | 超长输入 |
+| `longContextCharThreshold` | `200000` | 触发长上下文的字符数 |
+| `fallbacks` | 6 项（kimi / 智谱 / MiniMax / LongCat） | 回退链 |
+| `advertisedContextWindow` | `1000000` | 对外宣称的上下文窗口 |
+| `defaultReasoningEffort` | `high` | 默认推理档位 |
+
+**视觉请求刻意不回退** —— 链上只有 `visionBackend` 一个候选。原因是其他后端不接图片，
+回退过去只会拿到一个含义不同的报错，不如让失败原因直白。
+
+## 路由日志
+
+插件注册 `GET /api/llm-router/routes?sessionId=&limit=`，返回最近的路由决策
+（内存环形缓冲，最多 200 条，不落盘）：
+
+```json
+{ "routes": [ { "id": 12, "kind": "vision", "provider": "zai-coding-cn",
+                "model": "glm-5v-turbo", "fallbackIndex": 0,
+                "affiliate": { "name": "智谱 BigModel", "badge": "2000万Tokens" } } ],
+  "total": 12 }
+```
+
+`kind` ∈ `default` / `long-context` / `vision`；`fallbackIndex` 为 0 表示首个候选就成功。
+
+## 关于 `affiliate` 字段（如实披露）
+
+`affiliate` 仅在**已选定后端之后**填入，表示该后端对应的平台与作者有推广关系。
+它**只为界面提示而存在，不参与任何路由决策**，且这一点是用结构保证的：
+
+- 查询点在 `decide()` 与回退循环**定论之后**，时序上不可能影响本次选择；
+- 选择逻辑的各函数体内不含任何返利相关标识符；
+- 该字段不含 `weight` / `score` / `priority` 之类排序语义。
+
+可以自行验证：把 `AFFILIATE_HINTS` 改成给所有 provider 都挂上返利，
+`decide()` 的输出对同一组输入**逐条不变**。
+
+## 已知边界
+
+- **回退判定只看「首个内容前」的失败**（配额、限流、连接错、缺凭证等）。
+  已产出内容后的中断不回退，见上文说明。
+- 路由日志是**进程内内存**，重启即清空，不适合当审计账本。
+- `longContextCharThreshold` 按**字符数**估算，不是精确 token 数。
+- 视觉后端不回退，故 `visionBackend` 必须配一个真实可用的多模态模型。
+
+## 兼容性
+
+- 需要 `@deepseek-ai/dsh`（peer dependency，`*`）。
+- 已验证 `dsh` 0.1.5 线。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,19 @@
+# dsh-llm-router profile patch layer
+#
+# 这个文件是「命令安装能否生效」的关键：`dsh plugin add` 只有在包的 package.json
+# 声明了 `dsh.bundle.patch` 时，才会把本插件并入 profile 的 layer 栈；
+# 否则它只被当成一个普通依赖装进去，**进程不会加载它**，用户会看到「装成功但没反应」。
+#
+# id 必须与 host 入口里的插件名一致（lib/index.js 中 `export const name = "llm-router"`）。
+# name 是 npm 包名，dsh 由它解析出 host 入口（main）。
+#
+# 这里刻意**不写 config** —— 后端配置必须由使用者按自己的 provider 设置。
+# 请在你的 profile patch 层用 id 定向覆盖：
+#   - id: llm-router
+#     config:
+#       defaultBackend: { provider: <你的 provider>, model: <模型名> }
+#       ...
+# 详见 README「安装后必须做的事」。
+- insert:
+    - id: llm-router
+      name: 'dsh-llm-router'

package/lib/index.js

@@ -0,0 +1,491 @@
+import { LlmAdapter, contentHasImage } from "@deepseek-ai/dsh-llm";
+
+/**
+ * dsh-llm-router — the "auto" provider route.
+ *
+ * One LlmAdapter owns the route `auto` with the single model id `auto`.
+ * On every request the adapter classifies the task from the assembled
+ * GenerateOptions:
+ *
+ *   - any image block          -> visionBackend (the only vision-capable model)
+ *   - input over the threshold -> longContextBackend (1M-token models)
+ *   - otherwise                -> defaultBackend
+ *
+ * and then streams the request through that backend. If a backend fails
+ * with a terminal failure BEFORE any content chunk was emitted (quota,
+ * rate limit, transport error, missing credential, ...), the adapter moves
+ * to the next candidate in the fallback chain instead of surfacing the
+ * failure. Once one byte of content has been yielded the backend owns the
+ * stream — a mid-stream failure surfaces normally, because retrying after
+ * partial output has no durable attempt boundary.
+ *
+ * Routing decisions are logged through `ctx.logger`. Backend replay state
+ * is stripped at the router boundary (the historical provider is `auto`,
+ * the serving provider is the backend — replay must not impersonate it).
+ */
+
+export const name = "llm-router";
+export const inject = ["llm", "webServer"];
+
+const PROVIDER = "auto";
+const MODEL = "auto";
+
+/* -------------------------------------------------------- route log */
+
+/** In-memory circular buffer of recent routing decisions (shared across all requests). */
+const MAX_ROUTE_LOG = 200;
+/** @type {{ id: number, ts: number, sessionId: string, kind: string, provider: string, model: string, fallbackIndex: number, affiliate: object|null }[]} */
+const routeLog = [];
+let routeIdCounter = 0;
+
+/**
+ * 返利提示表 —— **仅供参考展示，绝不参与路由决策**。
+ *
+ * 为什么内联查表，而不是运行时调用 dsh-client-ui-model-clock 的
+ * `/api/model-clock/affiliate/resolve`：
+ *   1. 本插件可能在 `tui` / `headless` profile 下运行 —— 那里没有 webServer，
+ *      调不到对方的路由；而内联表在任何 profile 下都可用。
+ *   2. 端口未知：web 场景监听 8787，换 profile 就变；靠环境变量传端口比内联表更脆弱。
+ *   3. 查表**没有失败模式** —— 不会超时、不会被限流、不依赖对端是否安装。
+ *
+ * 代价是可能与权威源漂移。权威源是 dsh-client-ui-model-clock 的
+ * `config/affiliate.json`；该校验脚本 `verify-router-hint-sync.mjs`
+ * （放在 model-clock 仓库）会逐条比对两边，不一致即报错。
+ * **改返利配置后必须重跑它。**
+ *
+ * ⚠️ 用词纪律：这是「提示」不是「推荐」。
+ * 提示只能说「该平台有注册福利」，不得暗示「应该选它」。
+ * 选择逻辑（`decide()` 的能力分类 + 配置里的 fallback 顺序）**完全不受影响** ——
+ * 返利不得影响模型选择，这是本插件的硬约束。
+ */
+const AFFILIATE_HINTS = new Map([
+  ["zai-coding-cn", { name: "智谱 BigModel", badge: "2000万Tokens", itemId: "zhipu-bigmodel-glm53" }],
+  ["longcat", { name: "LongCat AI", badge: "送2000万Tokens", itemId: "longcat-ai" }],
+]);
+
+/**
+ * 查该 provider 是否对应一个作者有推广关系的平台。
+ *
+ * 纯函数、无 IO —— 调用它不会产生任何失败模式。
+ * 返回 null 表示「没有推广关系」，也覆盖「没配到」的情况，两者对调用方无区别。
+ *
+ * @param {string} provider dsh 的 provider id（不是厂商名，两套命名不同）
+ * @returns {{name: string, badge: string, itemId: string}|null}
+ */
+function lookupAffiliate(provider) {
+  if (typeof provider !== "string" || !provider) return null;
+  return AFFILIATE_HINTS.get(provider) ?? null;
+}
+
+function recordRoute(sessionId, kind, provider, model, fallbackIndex, affiliate) {
+  const entry = {
+    id: ++routeIdCounter,
+    ts: Date.now(),
+    sessionId: (typeof sessionId === "string") ? sessionId : "",
+    kind,
+    provider,
+    model,
+    fallbackIndex: fallbackIndex ?? 0,
+    /**
+     * 该 backend 对应的平台是否与作者有推广关系（只用于界面提示）。
+     *
+     * 刻意与 `provider` / `model` 平级而非嵌套进 `decision` ——
+     * 它在语义上属于「记录到的附加信息」，不属于「选择结果」。
+     * 任何消费端都应只把它当作展示素材，不得据此重排或推荐模型。
+     */
+    affiliate: affiliate ?? null,
+  };
+  routeLog.push(entry);
+  while (routeLog.length > MAX_ROUTE_LOG) routeLog.shift();
+  return entry;
+}
+
+/** Query recent routes, optionally filtered by sessionId (prefix match). */
+function queryRoutes(options) {
+  const { sessionId, limit = 50 } = options ?? {};
+  let list = routeLog;
+  if (sessionId) {
+    list = list.filter((r) => r.sessionId === sessionId || r.sessionId.startsWith(sessionId));
+  }
+  return list.slice(-limit).reverse(); // newest first
+}
+
+/* ---------------------------------------------------------------- config */
+
+const DEFAULT_CONFIG = {
+  defaultBackend: { provider: "deepseek-official", model: "deepseek-v4-pro" },
+  visionBackend: { provider: "zai-coding-cn", model: "glm-5v-turbo" },
+  longContextBackend: { provider: "longcat", model: "LongCat-2.0" },
+  longContextCharThreshold: 200000,
+  fallbacks: [
+    { provider: "kimi-coding", model: "kimi-for-coding" },
+    { provider: "zai-coding-cn", model: "glm-5-turbo" },
+    { provider: "zai-coding-cn", model: "glm-5.2" },
+    { provider: "zai-coding-cn", model: "glm-4.5-air" },
+    { provider: "minimax-cn", model: "MiniMax-M2.7" },
+    { provider: "longcat", model: "LongCat-2.0" },
+  ],
+  advertisedContextWindow: 1000000,
+  defaultReasoningEffort: "high",
+};
+
+/** Accept `{provider, model}` objects and `"provider/model"` strings. */
+function normalizeBackend(value, fallback) {
+  if (typeof value === "string") {
+    const slash = value.indexOf("/");
+    if (slash > 0) {
+      const provider = value.slice(0, slash).trim();
+      const model = value.slice(slash + 1).trim();
+      if (provider && model) return { provider, model };
+    }
+    return fallback;
+  }
+  if (
+    value !== null && typeof value === "object" &&
+    typeof value.provider === "string" && value.provider.length > 0 &&
+    typeof value.model === "string" && value.model.length > 0
+  ) {
+    return { provider: value.provider, model: value.model };
+  }
+  return fallback;
+}
+
+function resolveConfig(config) {
+  const c = config ?? {};
+  const fallbacks = Array.isArray(c.fallbacks)
+    ? dedupe(c.fallbacks.map((entry) => normalizeBackend(entry, null)).filter(Boolean))
+    : DEFAULT_CONFIG.fallbacks.map((entry) => ({ ...entry }));
+  return {
+    defaultBackend: normalizeBackend(c.defaultBackend, DEFAULT_CONFIG.defaultBackend),
+    visionBackend: normalizeBackend(c.visionBackend, DEFAULT_CONFIG.visionBackend),
+    longContextBackend: normalizeBackend(c.longContextBackend, DEFAULT_CONFIG.longContextBackend),
+    longContextCharThreshold:
+      Number.isFinite(c.longContextCharThreshold) && c.longContextCharThreshold > 0
+        ? c.longContextCharThreshold
+        : DEFAULT_CONFIG.longContextCharThreshold,
+    fallbacks,
+    advertisedContextWindow:
+      Number.isFinite(c.advertisedContextWindow) && c.advertisedContextWindow > 0
+        ? c.advertisedContextWindow
+        : DEFAULT_CONFIG.advertisedContextWindow,
+    defaultReasoningEffort:
+      typeof c.defaultReasoningEffort === "string"
+        ? c.defaultReasoningEffort
+        : DEFAULT_CONFIG.defaultReasoningEffort,
+  };
+}
+
+/* --------------------------------------------------------- classification */
+
+function backendKey(backend) {
+  return `${backend.provider}/${backend.model}`;
+}
+
+function dedupe(backends) {
+  const seen = new Set();
+  const result = [];
+  for (const backend of backends) {
+    if (!backend) continue;
+    const key = backendKey(backend);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(backend);
+  }
+  return result;
+}
+
+function requestHasImage(options) {
+  for (const message of options.messages ?? []) {
+    if (contentHasImage(message.content ?? [])) return true;
+  }
+  return false;
+}
+
+function blocksChars(blocks) {
+  let chars = 0;
+  for (const block of blocks ?? []) {
+    if (block.type === "text" || block.type === "reasoning") {
+      chars += block.text?.length ?? 0;
+    } else if (block.type === "tool-call") {
+      chars += (block.name?.length ?? 0) + (block.arguments?.length ?? 0);
+    } else if (block.type === "tool-result") {
+      if (typeof block.content === "string") chars += block.content.length;
+      else if (Array.isArray(block.content)) chars += blocksChars(block.content);
+    }
+  }
+  return chars;
+}
+
+function estimateInputChars(options) {
+  let chars = options.system?.length ?? 0;
+  for (const message of options.messages ?? []) {
+    chars += blocksChars(message.content ?? []);
+  }
+  return chars;
+}
+
+/**
+ * Pick the candidate chain for one request.
+ * Vision requests do not fall back: no other configured model takes images.
+ */
+function decide(options, config) {
+  if (requestHasImage(options)) {
+    return { kind: "vision", backends: dedupe([config.visionBackend]) };
+  }
+  const chars = estimateInputChars(options);
+  if (chars >= config.longContextCharThreshold) {
+    return {
+      kind: "long-context",
+      backends: dedupe([config.longContextBackend, config.defaultBackend, ...config.fallbacks]),
+    };
+  }
+  return { kind: "default", backends: dedupe([config.defaultBackend, ...config.fallbacks]) };
+}
+
+/* ---------------------------------------------------------------- helpers */
+
+function toFailure(error) {
+  if (error !== null && typeof error === "object" && typeof error.code === "string") {
+    return { message: String(error.message ?? error.code), code: error.code };
+  }
+  return { message: String(error?.message ?? error), code: "TRANSPORT" };
+}
+
+function failureFinish(code, message) {
+  return { type: "finish", reason: { kind: "error", failure: { message, code } } };
+}
+
+function abortedFinish() {
+  return {
+    type: "finish",
+    reason: { kind: "aborted", failure: { message: "aborted", code: "ABORTED" } },
+  };
+}
+
+/** Strip backend replay state: it belongs to the backend adapter, not to `auto`. */
+function sanitizeFinish(chunk) {
+  if (chunk?.type === "finish" && chunk.replayState !== undefined) {
+    return { type: "finish", reason: chunk.reason };
+  }
+  return chunk;
+}
+
+/* ----------------------------------------------------------------- adapter */
+
+class RouterAdapter extends LlmAdapter {
+  constructor(ctx, config) {
+    super();
+    this.ctx = ctx;
+    this.config = config;
+  }
+
+  providerInfo(provider) {
+    return { id: provider, name: "Auto" };
+  }
+
+  listModels(provider) {
+    return Promise.resolve([
+      {
+        provider,
+        id: MODEL,
+        name: "Auto",
+        description: "按任务自动路由：图片 / 长上下文 / 默认，失败自动切换后备模型",
+        inputModalities: ["text", "image"],
+      },
+    ]);
+  }
+
+  resolveModel(provider, model) {
+    return Promise.resolve({
+      provider,
+      id: model,
+      name: model === MODEL ? "Auto" : model,
+      inputModalities: ["text", "image"],
+      context: { contextWindow: this.config.advertisedContextWindow },
+      reasoning: {
+        efforts: [
+          { id: "off", name: "Off" },
+          { id: "high", name: "High" },
+          { id: "max", name: "Max" },
+        ],
+        defaultEffort: this.config.defaultReasoningEffort,
+      },
+    });
+  }
+
+  /** Drop a reasoning effort the chosen backend cannot serve. */
+  async clampEffort(backendOptions) {
+    const effort = backendOptions.reasoningEffort;
+    if (effort === undefined) return;
+    try {
+      const info = await this.ctx.llm.resolveModelInfo(
+        backendOptions.provider,
+        backendOptions.model,
+        backendOptions.signal,
+      );
+      const efforts = info?.reasoning?.efforts ?? [];
+      if (!efforts.some((entry) => entry.id === effort)) {
+        this.ctx.logger?.warn(
+          "llm-router: backend %s/%s does not serve reasoning effort %s — using its own default",
+          backendOptions.provider,
+          backendOptions.model,
+          effort,
+        );
+        delete backendOptions.reasoningEffort;
+      }
+    } catch {
+      // Metadata lookup failed (e.g. unregistered route): pass the effort
+      // through and let the backend request fail or serve on its own.
+    }
+  }
+
+  async *stream(options) {
+    const decision = decide(options, this.config);
+    this.ctx.logger?.info(
+      "llm-router: %s request -> %s",
+      decision.kind,
+      decision.backends.map(backendKey).join(" -> "),
+    );
+    let lastFailure = null;
+    for (const backend of decision.backends) {
+      if (backend.provider === PROVIDER) {
+        yield failureFinish("NO_ROUTE", "llm-router: a routing loop was configured (auto -> auto)");
+        return;
+      }
+      if (options.signal?.aborted) {
+        yield abortedFinish();
+        return;
+      }
+      const backendOptions = { ...options, provider: backend.provider, model: backend.model };
+      await this.clampEffort(backendOptions);
+      let iterator;
+      try {
+        iterator = this.ctx.llm.stream(backendOptions)[Symbol.asyncIterator]();
+      } catch (error) {
+        lastFailure = toFailure(error);
+        this.ctx.logger?.warn(
+          "llm-router: backend %s failed to open (%s) — trying next",
+          backendKey(backend),
+          lastFailure.code,
+        );
+        continue;
+      }
+      let closed = false;
+      const close = async () => {
+        if (closed) return;
+        closed = true;
+        await iterator.return?.().catch(() => {});
+      };
+      let adopted = false;
+      try {
+        const first = await iterator.next();
+        if (first.done) {
+          lastFailure = { message: `llm-router: ${backendKey(backend)} produced no output`, code: "EMPTY_RESPONSE" };
+          await close();
+          continue;
+        }
+        const chunk = sanitizeFinish(first.value);
+        if (chunk.type === "finish" && (chunk.reason.kind === "error" || chunk.reason.kind === "aborted")) {
+          lastFailure = chunk.reason.failure;
+          await close();
+          this.ctx.logger?.warn(
+            "llm-router: backend %s failed cleanly (%s) — trying next",
+            backendKey(backend),
+            lastFailure.code,
+          );
+          continue;
+        }
+        adopted = true;
+        // Record which backend actually served this request.
+        const fallbackIdx = decision.backends.indexOf(backend);
+        /**
+         * 返利提示**只在「已选中」之后查询** —— 这个时序是刻意的：
+         * 查询发生在 decide() 与 fallback 循环都已定论之后，
+         * 所以它在结构上不可能影响本次选择（不是「小心不去用它」，而是「用不到」）。
+         */
+        const affiliate = lookupAffiliate(backend.provider);
+        recordRoute(options.sessionId ?? "", decision.kind, backend.provider, backend.model, fallbackIdx, affiliate);
+        this.ctx.logger?.info(
+          "llm-router: [%s] %s -> %s/%s (fallback #%d)",
+          options.sessionId ?? "?",
+          decision.kind,
+          backend.provider,
+          backend.model,
+          fallbackIdx,
+        );
+        if (affiliate) {
+          this.ctx.logger?.info(
+            "llm-router: [%s] 提示：%s 是作者有推广关系的平台（%s）。仅为展示提示，未参与本次选择。",
+            options.sessionId ?? "?",
+            affiliate.name,
+            affiliate.badge,
+          );
+        }
+        yield chunk;
+        for await (const rest of iterator) {
+          yield sanitizeFinish(rest);
+        }
+        closed = true;
+        return;
+      } catch (error) {
+        if (adopted) throw error; // mid-stream failure after content: surface it
+        lastFailure = toFailure(error);
+        this.ctx.logger?.warn(
+          "llm-router: backend %s failed during open (%s) — trying next",
+          backendKey(backend),
+          lastFailure.code,
+        );
+        continue;
+      } finally {
+        if (!closed) await close();
+      }
+    }
+    yield failureFinish(
+      lastFailure?.code ?? "NO_ROUTE",
+      lastFailure?.message ?? "llm-router: no backend route available",
+    );
+  }
+}
+
+/* ----------------------------------------------------------------- plugin */
+
+export function apply(ctx, config) {
+  const resolved = resolveConfig(config);
+  ctx.logger?.info(
+    "llm-router: auto route ready — default=%s vision=%s longContext=%s (threshold=%d chars, fallbacks=%d)",
+    backendKey(resolved.defaultBackend),
+    backendKey(resolved.visionBackend),
+    backendKey(resolved.longContextBackend),
+    resolved.longContextCharThreshold,
+    resolved.fallbacks.length,
+  );
+  // Registration is disposed with this plugin's fiber.
+  ctx.llm.registerAdapter([PROVIDER], new RouterAdapter(ctx, resolved));
+
+  // HTTP API: expose recent routing decisions for the route-badge client plugin.
+  ctx.effect(() => ctx.webServer.register({
+    kind: "prefix",
+    path: "/api/llm-router/routes",
+    handler: async (req, res) => {
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        res.writeHead(405, { Allow: "GET, HEAD" });
+        res.end();
+        return;
+      }
+      const url = new URL(req.url, "http://localhost");
+      const sessionId = url.searchParams.get("sessionId") || "";
+      const limit = Math.min(200, Math.max(1, parseInt(url.searchParams.get("limit") || "50", 10) || 50));
+      const routes = queryRoutes({ sessionId, limit });
+      const body = JSON.stringify({ routes, total: routeLog.length });
+      res.writeHead(200, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": Buffer.byteLength(body),
+        "Cache-Control": "no-store",
+        "Access-Control-Allow-Origin": "*",
+      });
+      res.end(req.method === "HEAD" ? undefined : body);
+    },
+  }), "llm-router: /api/llm-router/routes");
+}
+
+export { RouterAdapter, decide, resolveConfig, lookupAffiliate, AFFILIATE_HINTS };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "dsh-llm-router",
+  "version": "0.1.0",
+  "description": "Task-aware automatic model router (auto route) for the DeepSeek Harness: picks a backend model per request (vision / long-context / default) and falls back across configured models on clean pre-content failures.",
+  "type": "module",
+  "author": "zhanghao3693",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhanghao3693/dsh-llm-router.git"
+  },
+  "homepage": "https://github.com/zhanghao3693/dsh-llm-router",
+  "bugs": {
+    "url": "https://github.com/zhanghao3693/dsh-llm-router/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "cordis",
+    "plugin",
+    "llm-router",
+    "model-routing",
+    "auto-route",
+    "fallback"
+  ],
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib/index.js",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "engines": {
+      "dsh": ">=0.1.0-rc.5"
+    }
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "*",
+    "@deepseek-ai/dsh": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-llm": "*"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh": {
+      "optional": true
+    }
+  }
+}