dsh-plugin-model-tuning 2.0.1 → 2.1.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 dsh-plugin contributors
-
-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.
+MIT License
+
+Copyright (c) 2026 dsh-plugin contributors
+
+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.

package/README.md

@@ -20,6 +20,9 @@
   - 系统提示角色兼容开关：`自动` / `system` / `developer`（仅 `llm-pi-ai`，
     写入模型条目的 `compat.supportsDeveloperRole`；遇到 kimi/DeepSeek 等
     报 `role 'developer' is not allowed` 时选 `system`）；
+  - 思考格式兼容开关：`自动` / `自适应 thinking`（仅 `llm-pi-ai` 且路由 `api: anthropic-messages`，
+    写入模型条目的 `compat.forceAdaptiveThinking`；见下节「Anthropic 思考格式」。
+    该模型一个推理档位都没勾选时不显示——那时请求里根本没有 `thinking`）；
   - 生图模型勾选（把该模型写入「绘图」页签的模型列表，见「绘图页签」）；
 - 顶部搜索框按模型名 / ID / 描述 / provider 过滤；
 - 修改即时保存（`remote.settings.mutate`；模型目录来自 `remote.session.modelCatalog()`）。
@@ -136,6 +139,59 @@ harness 的请求模态是**闭合集合 `text | image`**：`dsh-llm` 的 `Model
 > 「系统提示角色」开关依赖 DSH 适配层 `dsh-llm-pi-ai` 透传 `compat.supportsDeveloperRole`
 >（`0.1.0-rc.6` 默认不透传，需按本仓库 `deepseek-harness` 的 catalog.ts 补丁同步，或等上游合入）。
 
+## Anthropic 思考格式（自适应 vs 预算式）
+
+「模型参数」页的**思考格式**开关解决的是这一条报错：
+
+```
+400 {"error":{"message":"claude-opus-5-5 requires adaptive thinking; omit thinking or use
+thinking.type=adaptive and output_config.effort","type":"invalid_request_error"}}
+```
+
+- **原因**：pi-ai 只有在模型的 `compat.forceAdaptiveThinking === true` 时才发
+  `thinking: {type:"adaptive"}` + `output_config: {effort:"…"}`；否则发旧的预算式
+  `thinking: {type:"enabled", budget_tokens:N}`。只接受自适应思考的模型（Claude Opus 4.6 及更新、
+  Sonnet 5、Fable 5、Kimi K3 等）会直接 400 拒掉预算式请求。
+- **为什么手写路由会中招**：pi-ai 内置目录给它自己带的模型 ID 标了这个标记，
+  而 `dsh-llm-pi-ai` 只在「模型 ID 命中该 provider 自己的目录条目」时才继承目录 `compat`
+  （`resolveModelCompat` 要求 `base.api === api`）。手写路由（例如 `providers.ironman-claude`
+  这种目录里不存在的 key）没有任何目录条目可继承，`claude-opus-5-5` 这类目录里其实认识、
+  但挂在 `anthropic` 名下的 ID 也一样继承不到——于是请求退化成预算式。
+- **怎么修**：在该模型的「思考格式」里选**自适应 thinking**，页面把
+  `compat.forceAdaptiveThinking: true` 写进模型条目（与 `系统提示角色` 同一套写法），
+  下一次请求即生效，无需重启。Claude 4.5 及更早只认预算式，保持「自动」。
+- **另一条路（不动插件）**：把这条路由改成目录里已有的 key（例如 `providers.anthropic`
+  只覆盖 `baseURL` / `apiKeyEnv`，用 `models:` 收窄到要用的几个 ID），模型 ID 因此命中目录条目，
+  自适应标记、`supportsTemperature` 等兼容位都会自动继承。代价是 provider ID 变了，
+  老会话里记录的路由名会对不上，所以通常仍是逐个模型打勾更省事。
+
+> **已知边界**：思考强度选 `off` 时，`dsh-llm-pi-ai` 会把声明里 `off: null` 的那一项**移出**
+> `thinkingLevelMap`，pi-ai 因此发 `thinking: {type:"disabled"}`（只有把 `off` 钉成 `null` 才会
+> 整个省略该参数——那是内置目录条目的写法），本开关管不到这一段。若网关连 `disabled` 也拒绝，
+> 把该模型的「可选推理档位」全部取消（写成 `reasoningEfforts: false`，即视为无推理能力），
+> 请求里就完全不会出现 `thinking`。
+
+> **耦合点**：字段名 `forceAdaptiveThinking` 与「只在该协议的白名单内」都由上游决定
+> ——`dsh-llm-pi-ai` 的 `anthropic-messages` compat 门（`0.1.7-alpha.2` 起已含该字段，
+> `884f7b9c41` 于 2026-08-18 引入）会拒收白名单外的字段，pi-ai 的
+> `dist/api/anthropic-messages.js` 是唯一读它的地方。`tests/adaptive-thinking.test.mjs`
+> 在有 `DSH_TEST_DEPLOY_ROOT` 时直接问该部署的 pi-ai 要请求体，上游改名会在这里失败而不是在会话里变成 400。
+
+## dsh 0.2.1（alpha）适配（v2.1）
+
+- **标题 helper 换了 API。** 0.2.1-alpha 系列删掉了 `generateSessionTitleWithLlm`，改成
+  `executeSessionTitleLlm(ctx, config, request, providerId, prepared)`：提示词、输入包装、推理档位选择
+  与输出解析都交还给提供方。本插件按宿主实际导出择一：有新 API 就走新 API（提示词与解析规则复刻官方
+  `session-title-first-prompt-llm`，推理档位取路由最低档），否则回落旧 helper，0.1.7–0.2.0 不受影响。
+  2.0.x 在 0.2.1 上会因为找不到旧导出而整行激活失败（绘图与设置页一起没了）。
+- **标题注册失败不再拖垮整个插件。** `apply` 里标题路由单独兜底：失败只打一条 warn、不注册标题提供方，
+  绘图工具与设置页照常。
+- **与官方「会话标题刷新」（可选目录里的 `session-titles-bundle`）互斥。** 两者都要独占
+  `ctx.sessionTitle.register()`，后注册的一方失败——本插件这边表现为上面那条 warn。二选一。
+- **推理档位与官方 Models 页写的是同一个字段。** 0.2.1-alpha.4 起官方 Models 页可以给手工声明的 pi-ai
+  模型编辑 `reasoningEfforts`，并允许每一档发送自定义 API 值（如 `high → deep`）。本页勾选档位时保留
+  已存的值，只有新加的档位才默认用档位名；`off` 的已存值也原样保留。
+
 ## 与 DSH 版本的耦合点（0.1.7-alpha.2）
 
 - **provider 目录必须取 `llm.listConfigurableProviders()`**（返回 `LlmConfigurableProvider`
@@ -155,15 +211,20 @@ node --test tests/title-route.test.mjs            # 标题路由解析与 Config
 node --test tests/title-purpose.test.mjs          # 用途页读写规划 + locale 回归
 node --test tests/image-link.test.mjs             # 生图链接写入规划（纯函数）
 node --test tests/image.test.mjs                  # 绘图传输/工具/Remote（本地 HTTP，不外联）
+node --test tests/adaptive-thinking.test.mjs      # 思考格式开关：白名单 + 写入规划（+ 部署耦合守卫）
 DSH_TEST_DEPLOY_ROOT=<隔离部署> node --test tests/title-provider.test.mjs   # 真 helper + 假 ctx
 ```
 
 - `title-provider.test.mjs` 用**假 ctx + 真共享策略**（只 mock `ctx.llm.stream`）验证唯一注册、
   继承/指定路由、首条消息选择、辅助请求记录、失败与取消路径。`tests/_host.mjs` 要求
   `DSH_TEST_DEPLOY_ROOT` 指向隔离的 0.1.7-alpha.2 部署。
+- `adaptive-thinking.test.mjs` 的前半段是纯函数（开关只出现在 `anthropic-messages` 路由、
+  写入落在模型条目的 `compat` 上，目录路由落到 `modelOverrides`）；后半段只在有
+  `DSH_TEST_DEPLOY_ROOT` 时运行，把该部署的 pi-ai 拦在假 `fetch` 前，直接读出请求体，
+  证明「打勾 → `thinking.type=adaptive` + `output_config.effort`，不打勾 → 预算式」。
 - **这些测试不是实机验证**。实机验收：标题从会话日志读 `session/title-llm-request` 的 `route`
   与最终 `session/title` 的 `source.model`；绘图确认「模型参数」勾选 → 绘图页出现条目 →
-  直接绘图面板出图。
+  直接绘图面板出图；思考格式在模型下拉里选一档后看会话日志里那次请求的请求体。
 
 ## 安装 / 卸载
 

package/client.js

@@ -142,6 +142,27 @@ window.__ModuleLoader__.load({
     const MODALITY_CHOICES = ["auto", "text", "text-image"];
     const MODALITY_LABELS = { auto: "自动", text: "纯文本", "text-image": "文本 + 图像" };
 
+    /**
+     * The compat switch that selects Anthropic's adaptive thinking request.
+     *
+     * pi-ai sends `thinking: {type:"adaptive"}` plus `output_config.effort` only
+     * for a model whose `compat.forceAdaptiveThinking` is true; without it the
+     * request carries the legacy budget form (`thinking.type="enabled"` with
+     * `budget_tokens`). A model that requires adaptive thinking answers that
+     * legacy request with HTTP 400 — "requires adaptive thinking; omit thinking
+     * or use thinking.type=adaptive and output_config.effort". The installed
+     * catalog states the flag for the model ids it ships; a route this profile
+     * declares by hand has no catalog entry to inherit it from, so the switch
+     * has to be written on the model entry here.
+     */
+    const ADAPTIVE_THINKING_COMPAT_KEY = "forceAdaptiveThinking";
+    /**
+     * The one wire protocol whose compat takes that switch. `llm-pi-ai` refuses
+     * a compat field the model's resolved api does not offer, so the control is
+     * shown only on a route whose own configuration names this protocol.
+     */
+    const ADAPTIVE_THINKING_API = "anthropic-messages";
+
     function formatCapacity(n) {
       if (n == null || typeof n !== "number" || !Number.isFinite(n)) return "";
       if (n % 1000000 === 0) return String(n / 1000000) + "M";
@@ -327,6 +348,25 @@ window.__ModuleLoader__.load({
       return undefined;
     }
 
+    /**
+     * The compat key this page may write for one route, or null when the route
+     * cannot take it.
+     *
+     * The route's own `api` is the only place the protocol is known before a
+     * model resolves: a hand-declared route spells it out, while a catalog route
+     * omits it and resolves each model's protocol from the installed catalog.
+     * The control therefore appears exactly where the switch is both needed (no
+     * catalog entry to inherit the flag from) and accepted.
+     * @param settingsNs - the provider's settings namespace.
+     * @param profile - the route's own settings section.
+     * @returns the adaptive-thinking compat key, or null.
+     */
+    function adaptiveThinkingCompatKey(settingsNs, profile) {
+      if (settingsNs !== "llm-pi-ai") return null;
+      if (!profile || typeof profile !== "object") return null;
+      return profile.api === ADAPTIVE_THINKING_API ? ADAPTIVE_THINKING_COMPAT_KEY : null;
+    }
+
     function computeWriteOps(entry, nsView, modelId, field, value) {
       const ns = entry.settingsNs;
       const settingsPath = entry.settingsPath || [];
@@ -365,6 +405,44 @@ window.__ModuleLoader__.load({
       return { ns, ops: [{ op: "set", path: [...basePath, "models"], value: [{ id: modelId, [field]: value }] }] };
     }
 
+    /**
+     * The stored `reasoningEfforts` of one model: its `models[]` row first,
+     * then (pi-ai) its `modelOverrides` entry; undefined when neither declares it.
+     */
+    function storedReasoningEfforts(entry, nsView, modelId) {
+      const profile = at(nsView ? nsView.value : undefined, entry.settingsPath || []);
+      const models = (profile && Array.isArray(profile.models)) ? profile.models : [];
+      const row = models.find((m) => m && typeof m === "object" && m.id === modelId);
+      if (row && row.reasoningEfforts !== undefined) return row.reasoningEfforts;
+      const overrides = profile && profile.modelOverrides && typeof profile.modelOverrides === "object"
+        ? profile.modelOverrides[modelId] : undefined;
+      return overrides && typeof overrides === "object" ? overrides.reasoningEfforts : undefined;
+    }
+
+    /**
+     * The `reasoningEfforts` value for a set of checked levels.
+     *
+     * Since dsh 0.2.1-alpha.4 the official Models page also edits this field and
+     * lets each level send its own API value (a gateway spelling `high` as
+     * `deep`). Toggling a level here keeps every value already stored for the
+     * levels that stay, including a non-null `off`; only a newly added level
+     * defaults to its own name.
+     * @param levels - checked levels, in any order.
+     * @param existing - the stored value, or undefined.
+     * @returns `false` for no reasoning, else the level → wire-value dict.
+     */
+    function reasoningEffortsPayload(levels, existing) {
+      const ordered = REASONING_LEVELS.filter((level) => levels.indexOf(level) >= 0);
+      if (ordered.length === 0) return false;
+      const stored = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+      const dict = { off: stored.off !== undefined ? stored.off : null };
+      for (const level of ordered) {
+        const wire = stored[level];
+        dict[level] = typeof wire === "string" && wire !== "" ? wire : level;
+      }
+      return dict;
+    }
+
     function computeCompatWriteOps(entry, nsView, modelId, compatKey, value) {
       const ns = entry.settingsNs;
       const settingsPath = entry.settingsPath || [];
@@ -895,6 +973,7 @@ window.__ModuleLoader__.load({
             const nsView = entry ? nsByNs.get(entry.settingsNs) : undefined;
             const providerProfile = profileOf(nsView, entry ? entry.settingsPath : []);
             const reasoningEditable = !!(entry && entry.settingsNs === "llm-pi-ai");
+            const adaptiveKey = entry ? adaptiveThinkingCompatKey(entry.settingsNs, providerProfile) : null;
             const routeDefaultInput = providerProfile && Array.isArray(providerProfile.defaultInput)
               ? providerProfile.defaultInput
               : null;
@@ -904,11 +983,15 @@ window.__ModuleLoader__.load({
               const devRole = entry && entry.settingsNs === "llm-pi-ai"
                 ? readCompatField(nsView, entry.settingsPath, m.id, "supportsDeveloperRole")
                 : undefined;
+              const adaptiveThinking = adaptiveKey
+                ? readCompatField(nsView, entry.settingsPath, m.id, adaptiveKey)
+                : undefined;
               const modalityField = entry ? modalityFieldFor(entry.settingsNs) : undefined;
               const rawInput = modalityField
                 ? readModelField(nsView, entry.settingsPath, m.id, modalityField)
                 : undefined;
               const image = computeImageModelState(view, providerProfile, m.id);
+              const efforts = (m.reasoning && Array.isArray(m.reasoning.efforts)) ? m.reasoning.efforts.map((e) => ({ id: e.id, name: e.name })) : [];
               return {
                 id: m.id,
                 name: m.name,
@@ -916,6 +999,10 @@ window.__ModuleLoader__.load({
                 contextWindow: ctx != null ? ctx : null,
                 maxTokens: mx != null ? mx : null,
                 supportsDeveloperRole: devRole,
+                adaptiveThinking: adaptiveThinking === true,
+                // The flag only changes a request that carries thinking at all,
+                // so it is offered where a level can be selected.
+                adaptiveThinkingEditable: adaptiveKey !== null && efforts.length > 0,
                 modalityField: modalityField || null,
                 modality: modalityField ? modalityChoice(rawInput) : null,
                 imageAvailable: image.available,
@@ -925,7 +1012,7 @@ window.__ModuleLoader__.load({
                 imageApiKeyEnv: image.apiKeyEnv || null,
                 declared: !!(entry && entry.declared),
                 routeDefaultInput: routeDefaultInput,
-                efforts: (m.reasoning && Array.isArray(m.reasoning.efforts)) ? m.reasoning.efforts.map((e) => ({ id: e.id, name: e.name })) : [],
+                efforts,
                 defaultEffort: (m.reasoning && m.reasoning.defaultEffort != null) ? m.reasoning.defaultEffort : null,
               };
             });
@@ -1010,25 +1097,19 @@ window.__ModuleLoader__.load({
           if (kind === "reasoningLevels") {
             field = "reasoningEfforts";
             const raw = value && Array.isArray(value.levels) ? value.levels : [];
-            const levels = REASONING_LEVELS.filter((level) => raw.indexOf(level) >= 0);
-            if (levels.length === 0) {
-              payload = false;
-            } else {
-              const dict = { off: null };
-              for (const level of levels) dict[level] = level;
-              payload = dict;
-            }
+            payload = reasoningEffortsPayload(raw, storedReasoningEfforts(entry, nsView, model));
           } else if (kind === "contextWindow" || kind === "maxTokens") {
             field = kind;
             if (value != null && (typeof value !== "number" || !Number.isInteger(value) || value <= 0)) {
               throw new Error("取值必须是正整数");
             }
             payload = value;
-          } else if (kind === "supportsDeveloperRole") {
+          } else if (kind === "supportsDeveloperRole" || kind === "adaptiveThinking") {
             if (value !== null && typeof value !== "boolean") {
               throw new Error("取值必须是布尔值");
             }
-            const write = computeCompatWriteOps(entry, nsView, model, "supportsDeveloperRole", value);
+            const compatKey = kind === "supportsDeveloperRole" ? "supportsDeveloperRole" : ADAPTIVE_THINKING_COMPAT_KEY;
+            const write = computeCompatWriteOps(entry, nsView, model, compatKey, value);
             if (write) {
               const res = await api.settings.mutate({ ns: write.ns, ops: write.ops });
               if (!res.result.ok) throw new Error(res.result.error.message);
@@ -1176,6 +1257,9 @@ window.__ModuleLoader__.load({
                           : null,
                         model.imageLinked
                           ? React.createElement("span", { className: "mcfg-chip mcfg-chip-on" }, "生图模型")
+                          : null,
+                        model.adaptiveThinking
+                          ? React.createElement("span", { className: "mcfg-chip mcfg-chip-on" }, "自适应思考")
                           : null
                       )
                     ),
@@ -1215,6 +1299,7 @@ window.__ModuleLoader__.load({
                             React.createElement("input", {
                               type: "radio",
                               name: "devrole-" + model.id,
+                              disabled: !editable,
                               checked: role === "auto"
                                 ? model.supportsDeveloperRole === undefined
                                 : (role === "developer" ? model.supportsDeveloperRole === true : model.supportsDeveloperRole === false),
@@ -1236,6 +1321,29 @@ window.__ModuleLoader__.load({
                         "自动：跟随网关检测；如遇 role 'developer' is not allowed，请选 system"
                       )
                     ) : null,
+                    model.adaptiveThinkingEditable ? React.createElement("div", { className: "mcfg-reasoning" },
+                      React.createElement("span", { className: "mcfg-label" }, "思考格式（Anthropic 兼容开关）"),
+                      React.createElement("div", { className: "mcfg-levels" },
+                        ["auto", "adaptive"].map((choice) =>
+                          React.createElement("label", { key: choice, className: "mcfg-level" },
+                            React.createElement("input", {
+                              type: "radio",
+                              name: "adaptive-" + model.id,
+                              disabled: !editable,
+                              checked: choice === "auto" ? !model.adaptiveThinking : model.adaptiveThinking,
+                              onChange: () => applyChange(provider.provider, model.id, "adaptiveThinking", choice === "adaptive" ? true : null),
+                            }),
+                            React.createElement("span", null, choice === "auto" ? "自动（预算式 thinking）" : "自适应 thinking")
+                          )
+                        )
+                      ),
+                      React.createElement("div", { className: "mcfg-note" },
+                        "上面选中档位后，请求体由这里决定：自适应写 compat." + ADAPTIVE_THINKING_COMPAT_KEY
+                        + "，发出 thinking.type=adaptive 与 output_config.effort；Claude Opus 4.6 及更新、Sonnet 5、"
+                        + "Fable 5 等只接受这种，报 400 requires adaptive thinking 就切到它。"
+                        + "Claude 4.5 及更早只认预算式，保持「自动」。"
+                      )
+                    ) : null,
                     model.modalityField ? React.createElement("div", { className: "mcfg-reasoning" },
                       React.createElement("span", { className: "mcfg-label" }, "输入模态（写入 " + model.modalityField + "）"),
                       React.createElement("div", { className: "mcfg-levels" },

package/index.js

@@ -10,7 +10,8 @@
  *    patch in `cordis.patch.yml`. It is still exactly one provider:
  *    `ctx.sessionTitle.register()` throws on a second registration, so a
  *    competing generator cannot coexist. Everything except the route is
- *    delegated to the public shared policy `generateSessionTitleWithLlm` from
+ *    delegated to the public shared policy (`executeSessionTitleLlm`, or
+ *    `generateSessionTitleWithLlm` before dsh 0.2.1) from
  *    `@deepseek-ai/dsh-session-title-llm`, resolved from the RUNNING
  *    deployment (see hostRequire) — never from this package's directory, which
  *    for a linked workspace package would risk a second copy of the host's
@@ -140,7 +141,79 @@ function hostRequire() {
   return undefined
 }
 
+/** Title-service package that owns `normalizeSessionTitle`; resolved next to the helper. */
+const TITLE_SERVICE_PACKAGE = '@deepseek-ai/dsh-session-title'
+
+/**
+ * Language-aware system instruction, mirroring the shipped first-prompt
+ * provider (dsh ≥ 0.2.1 hands prompt ownership to each provider).
+ * @param budget - the live title budget.
+ * @returns the system prompt.
+ */
+export function titleSystemPrompt(budget) {
+  return [
+    'Create a concise title for an AI coding-assistant session from the supplied human messages.',
+    'Return only the title on one line, **in plain text of natural language**, with no quotes, prefix, explanation, Markdown, XML, or terminal control codes. No code is allowed.',
+    'Use the language of the messages.',
+    `Aim for about ${budget.targetWords} words in non-CJK languages or ${budget.targetCjkCharacters} CJK characters.`,
+    'If the messages give little to name, still return a short best-effort title, such as Greeting, instead of explaining.',
+  ].join('\n')
+}
+
+/** Asterisk emphasis wrapping a whole line, such as `**Title**`. */
+const EMPHASIS_WRAPPER = /^(?<marker>\*{1,3})(?<inner>\S(?:.*\S)?)\k<marker>$/u
+
+/**
+ * Take the title from model output: the first non-empty line, without
+ * asterisk emphasis wrapping that whole line (same rule as the shipped provider).
+ * @param text - the joined text blocks.
+ * @returns the raw title line.
+ */
+export function titleFromOutput(text) {
+  const line = text.split(/\r?\n/u).map(item => item.trim()).find(item => item.length > 0) ?? ''
+  const groups = EMPHASIS_WRAPPER.exec(line)?.groups
+  const marker = groups?.marker
+  const inner = groups?.inner
+  return marker === undefined || inner === undefined || inner.includes(marker) ? line : inner
+}
+
+/**
+ * Adapt the prepared-request API (`executeSessionTitleLlm`, dsh ≥ 0.2.1) to the
+ * one-call shape this plugin drives.
+ * @param execute - the host's `executeSessionTitleLlm`.
+ * @param normalize - the host's `normalizeSessionTitle`.
+ * @returns `(ctx, budget, request, selected, providerId) => { title, messageSeqs, model }`.
+ */
+export function preparedTitleGenerator(execute, normalize) {
+  return async (ctx, budget, request, selected, providerId) => {
+    const config = { maxInputBytes: budget.maxInputBytes, maxOutputTokens: budget.maxOutputTokens, timeoutMs: budget.timeoutMs }
+    const messageSeqs = selected.map(message => message.seq)
+    const response = await execute(ctx, config, request, providerId, {
+      system: titleSystemPrompt(budget),
+      input: `Generate the session title from this JSON array of human messages:\n${JSON.stringify(selected)}`,
+      messageSeqs,
+      // A title needs no deliberation: take the route's least effort.
+      selectReasoningEffort: model => model.reasoning?.efforts?.[0]?.id,
+    })
+    if (response.finish.kind === 'tool-calls' || response.blocks.some(block => block.type === 'tool-call')) {
+      throw new Error('session-title-llm: title output must contain text only')
+    }
+    if (response.finish.kind === 'max-tokens') {
+      throw new Error('session-title-llm: title output reached maxOutputTokens')
+    }
+    const text = response.blocks.filter(block => block.type === 'text').map(block => block.text).join(' ')
+    const title = normalize(titleFromOutput(text), Number.MAX_SAFE_INTEGER)
+    if (title.length === 0) throw new Error('session-title-llm: title model produced no text')
+    return { title, messageSeqs, model: response.model }
+  }
+}
+
 let helperPromise
+/**
+ * Load a title generator from the running deployment: the prepared-request
+ * API when the host has it (≥ 0.2.1), else the one-call
+ * `generateSessionTitleWithLlm` (0.1.7 – 0.2.0).
+ */
 function loadTitleHelper() {
   helperPromise ??= (async () => {
     const require = hostRequire()
@@ -149,12 +222,17 @@ function loadTitleHelper() {
         `model-tuning: 无法从宿主解析 ${HELPER_PACKAGE}；本插件必须与提供该包的部署一起运行。`,
       )
     }
-    const loaded = await import(pathToFileURL(require.resolve(HELPER_PACKAGE)).href)
-    const generate = loaded.generateSessionTitleWithLlm
-    if (typeof generate !== 'function') {
-      throw new Error(`model-tuning: ${HELPER_PACKAGE} 未导出 generateSessionTitleWithLlm`)
+    const helperPath = require.resolve(HELPER_PACKAGE)
+    const loaded = await import(pathToFileURL(helperPath).href)
+    if (typeof loaded.executeSessionTitleLlm === 'function') {
+      const service = await import(pathToFileURL(createRequire(helperPath).resolve(TITLE_SERVICE_PACKAGE)).href)
+      if (typeof service.normalizeSessionTitle !== 'function') {
+        throw new Error(`model-tuning: ${TITLE_SERVICE_PACKAGE} 未导出 normalizeSessionTitle`)
+      }
+      return preparedTitleGenerator(loaded.executeSessionTitleLlm, service.normalizeSessionTitle)
     }
-    return generate
+    if (typeof loaded.generateSessionTitleWithLlm === 'function') return loaded.generateSessionTitleWithLlm
+    throw new Error(`model-tuning: ${HELPER_PACKAGE} 既没有 executeSessionTitleLlm 也没有 generateSessionTitleWithLlm`)
   })()
   return helperPromise
 }
@@ -189,7 +267,7 @@ export function titleBudgetOf(config) {
  * @param config - the live Config (route and budget are re-read per generation).
  */
 export async function registerTitleProvider(ctx, config) {
-  const generateSessionTitleWithLlm = await loadTitleHelper()
+  const generateTitle = await loadTitleHelper()
   validateTitleModel({ titleMode: config.titleMode.get(), titleProvider: config.titleProvider.get(), titleModel: config.titleModel.get() })
   titleBudgetOf(config)
   ctx.sessionTitle.register({
@@ -200,7 +278,7 @@ export async function registerTitleProvider(ctx, config) {
         titleMode: config.titleMode.get(), titleProvider: config.titleProvider.get(), titleModel: config.titleModel.get(),
       }, request)
       const selected = request.messages.slice(0, 1)
-      return await generateSessionTitleWithLlm(ctx, titleBudgetOf(config), { ...request, route }, selected, TITLE_PROVIDER_ID)
+      return await generateTitle(ctx, titleBudgetOf(config), { ...request, route }, selected, TITLE_PROVIDER_ID)
     },
   })
 }
@@ -361,6 +439,13 @@ export function registerImageTools(ctx, config) {
  * @param config - the unified Config described above.
  */
 export async function apply(ctx, config) {
-  await registerTitleProvider(ctx, config)
+  // The title route leans on a host helper whose API has changed between
+  // releases. If it breaks again, lose only title routing — never the image
+  // tools and settings page that ride on the same row.
+  try {
+    await registerTitleProvider(ctx, config)
+  } catch (error) {
+    ctx.logger?.warn?.(`model-tuning: 标题路由未启用（${error instanceof Error ? error.message : String(error)}）；绘图与设置页照常工作`)
+  }
   registerImageTools(ctx, config)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-model-tuning",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "license": "MIT",
   "keywords": ["dsh-plugin", "deepseek-harness", "dsh", "model", "settings", "reasoning", "context", "session-title", "image-generation"],
   "publishConfig": { "registry": "https://registry.npmjs.org" },