dsh-acp-enhanced 0.3.5 → 0.3.6

package/README-zh.md

@@ -20,7 +20,10 @@ ACP 线上。
 ### 模型与权限
 
 - **模型切换**：实时 `provider/model` 目录下拉（按 ACP 规范分组线格式）
-- **推理强度**：`reasoning_effort` 下拉——仅当当前路由暴露可选 efforts 时出现
+- **推理强度**：`reasoning_effort` 下拉——仅当当前路由暴露可选 efforts 时出现；
+  每个模型都会记住它上次使用的强度（按 profile 持久化），切回时自动恢复，
+  首次切换的模型则回退到它自己的默认值——没有默认值时取第一个可选值，
+  绝不出现空的 "unknown" 选择
 - **权限预设**：read-only / workspace-write / full-access 三种会话模式
 - **审批**：工具调用弹出原生 allow-once / reject-once 审批
 
@@ -196,7 +199,7 @@ dsh plugin --profile acp-enhanced add dsh-web-search-openrouter
 |---|---|
 | `exec: dsh: not found`（status 127） | 用随附 `dsh-acp-zed.sh` 启动器（自定位 node/dsh） |
 | `no API key for provider route "xxx"` | 写入 `~/.dsh/.credentials.yaml`，或在 agent_servers 里设 `env.DEEPSEEK_API_KEY` |
-| 无法切换模型 | 保存的 `reasoning_effort` 默认值（或会话当前 effort）被带到新模型上；0.3.3 起新模型不支持的 effort 会自动回退为该模型默认值，不再让整个切换失败。另检查：是否选到了不可路由的"幽灵 provider"——本桥默认过滤（只广播 `config.provider` 的模型），确认 profile 的 provider 指向真实路由 |
+| 无法切换模型 | 保存的 `reasoning_effort` 默认值（或会话当前 effort）被带到新模型上。0.3.6 起本桥按模型记住上次使用的强度（随 profile 持久化）：不被新模型支持的 effort 会被该模型记忆值替换——没有记忆则回退其默认值，再无默认则取第一个可选值，既不会切换失败也不会出现 "unknown"。另检查：是否选到了不可路由的"幽灵 provider"——本桥默认过滤（只广播 `config.provider` 的模型），确认 profile 的 provider 指向真实路由 |
 | 上下文用量不显示 | 选到了不可路由的"幽灵 provider"；本桥默认过滤（只广播 `config.provider` 的模型），确认 profile 的 provider 指向真实路由 |
 | 需要详细诊断 | `ACP_DEBUG=1 dsh --profile acp-enhanced`（stderr 生命周期 trace） |
 

package/README.md

@@ -23,7 +23,9 @@ over the ACP wire.
 
 - **Model switching**: live `provider/model` catalog dropdown (ACP grouped-select wire shape)
 - **Reasoning effort**: `reasoning_effort` dropdown — only when the routed model exposes
-  selectable efforts
+  selectable efforts; each model remembers the effort it last used (persisted per profile),
+  so switching back restores it, and a first-time model falls back to its own default — or
+  its first offered effort — instead of an empty "unknown" selection
 - **Permission presets**: read-only / workspace-write / full-access session modes
 - **Approval**: native allow-once / reject-once prompts per tool call
 
@@ -215,7 +217,7 @@ dsh plugin --profile acp-enhanced add dsh-web-search-openrouter
 |---|---|
 | `exec: dsh: not found` (status 127) | Use the shipped `dsh-acp-zed.sh` launcher (locates node/dsh itself) |
 | `no API key for provider route "xxx"` | Write `~/.dsh/.credentials.yaml`, or set `env.DEEPSEEK_API_KEY` on the agent_servers entry |
-| Cannot switch models | The saved `reasoning_effort` default (or the session's current effort) is carried onto the new model; since 0.3.3 an unsupported effort resets to the model's default instead of failing the switch. Also check: a "phantom provider" route was picked — this bridge filters them by default (only `config.provider`'s models are advertised), so point the profile's provider at a real route |
+| Cannot switch models | The saved `reasoning_effort` default (or the session's current effort) is carried onto the new model. Since 0.3.6 the bridge remembers the last effort per model (per-profile JSON): an unsupported carried effort is replaced by that model's remembered effort, else its own default, else its first offered effort — never an "unknown" dropdown, never a failed switch. Also check: a "phantom provider" route was picked — this bridge filters them by default (only `config.provider`'s models are advertised), so point the profile's provider at a real route |
 | Context usage missing | A "phantom provider" route was picked; this bridge filters them by default (only `config.provider`'s models are advertised) — point the profile's provider at a real route |
 | Need detailed diagnostics | `ACP_DEBUG=1 dsh --profile acp-enhanced` (stderr lifecycle trace) |
 

package/lib/index.js

@@ -36,9 +36,10 @@
  */
 
 import { randomUUID } from 'node:crypto'
-import { rm } from 'node:fs/promises'
+import { readFileSync } from 'node:fs'
+import { rm, writeFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
-import { isAbsolute, dirname, resolve } from 'node:path'
+import { isAbsolute, dirname, join, resolve } from 'node:path'
 import { Readable, Writable } from 'node:stream'
 import Schema from '@deepseek-ai/schemastery'
 import { AgentSideConnection, ndJsonStream, PROTOCOL_VERSION, RequestError } from '@agentclientprotocol/sdk'
@@ -52,6 +53,55 @@ import { acpPromptToText, promptHasUnsupportedContent, sanitizeWireTitle, turnEn
  *  handshake can never drift from the released package version. */
 const AGENT_VERSION = createRequire(import.meta.url)('../package.json').version
 
+/** State-kept per-model reasoning-effort memory (`provider/model` → effort
+ *  id). A model switch carries the session's current effort onto the new
+ *  model; when the target does not offer it, the effort this bridge last
+ *  successfully applied to that route is restored instead — and switching
+ *  back restores the effort that model had before, so the editor's dropdown
+ *  never falls back to an empty ("unknown") selection. Persisted as a small
+ *  JSON file next to the profile (the shipped Zed launcher exports
+ *  DSH_ACP_PROFILE_DIR); without that variable the memory simply lives for
+ *  the process. */
+const effortMemoryFile = process.env.DSH_ACP_PROFILE_DIR !== undefined && process.env.DSH_ACP_PROFILE_DIR.length > 0
+  ? join(process.env.DSH_ACP_PROFILE_DIR, 'dsh-acp-enhanced-effort-memory.json')
+  : undefined
+
+function loadEffortMemory() {
+  if (effortMemoryFile === undefined) return {}
+  try {
+    const parsed = JSON.parse(readFileSync(effortMemoryFile, 'utf8'))
+    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      console.warn(`acp-enhanced: effort memory unreadable (${effortMemoryFile}): ${String(error)}`)
+    }
+  }
+  return {}
+}
+
+const effortMemory = loadEffortMemory()
+
+function writeEffortMemory() {
+  if (effortMemoryFile === undefined) return
+  writeFile(effortMemoryFile, JSON.stringify(effortMemory, null, 2)).catch((error) => {
+    console.warn(`acp-enhanced: effort memory write failed (${effortMemoryFile}): ${String(error)}`)
+  })
+}
+
+/** The effort last successfully applied to a route, when one was recorded. */
+function rememberedEffort(provider, model) {
+  const effort = effortMemory[`${provider}/${model}`]
+  return typeof effort === 'string' && effort.length > 0 ? effort : undefined
+}
+
+/** Record the effort applied to a route, persisting when possible. */
+function rememberEffort(provider, model, effort) {
+  const key = `${provider}/${model}`
+  if (effortMemory[key] === effort) return
+  effortMemory[key] = effort
+  writeEffortMemory()
+}
+
 export const name = 'acp-enhanced'
 /** The bridge creates and owns agents; every other concern is carried by the composition. */
 export const inject = ['agents', 'llm', 'approval', 'tools', 'commands', 'systemPrompt']
@@ -858,7 +908,11 @@ export function apply(ctx, config) {
         name: 'Reasoning effort',
         description: 'Reasoning level applied to model requests for this session.',
         category: 'thought_level',
-        currentValue: selected.reasoningEffort ?? modelInfo?.reasoning?.defaultEffort ?? '',
+        // The chain mirrors applySelection: selected effort, the model's own
+        // default, then the first offered effort — a non-empty selection
+        // unless the model declares no reasoning at all. This backstop keeps
+        // the editor's dropdown from ever showing an "unknown" effort.
+        currentValue: selected.reasoningEffort ?? modelInfo?.reasoning?.defaultEffort ?? efforts[0]?.id ?? '',
         options: efforts.map((effort) => ({
           value: effort.id,
           name: effort.name,
@@ -901,28 +955,49 @@ export function apply(ctx, config) {
 
   /** Resolve and apply a new model/effort selection to the session. */
   async function applySelection(record, next) {
-    let resolved
+    // Per-model effort restoration. An explicit effort (Zed re-applies its
+    // saved default_config_options on every session, and a model switch
+    // carries the session's current effort onto the newly picked model) wins
+    // when the target offers it. Unsupported efforts are not just dropped:
+    // the effort last successfully applied to this route is restored, and a
+    // first-time route falls back to its own default — or, when it declares
+    // none, to the FIRST effort it offers — so the selection never carries an
+    // empty effort that renders as "unknown" in the editor's dropdown. A
+    // model without reasoning metadata resolves without an effort.
+    let info
     try {
-      resolved = await llm.resolveCallConfig(next)
-    } catch (error) {
-      // A reasoning effort can outlive the model that supported it: Zed
-      // re-applies its saved `default_config_options` on every session, and
-      // switching models carries the session's current effort onto the newly
-      // picked model, which may not offer it (glm-* and gpt-5.6-luna reject
-      // "max"). Rejecting the whole switch snapped Zed's dropdown back and
-      // made model switching itself appear broken, so drop the stale effort
-      // and resolve against the target model's own default instead. Any other
-      // failure (unknown route, missing credential) still surfaces.
-      if (error?.code !== 'UNSUPPORTED_REASONING_EFFORT' || next.reasoningEffort === undefined) throw error
-      logger.warn(`acp-enhanced: dropped reasoning effort "${next.reasoningEffort}" for ${next.provider}/${next.model} (unsupported); using the model default`)
-      resolved = await llm.resolveCallConfig({ ...next, reasoningEffort: undefined })
+      info = await llm.resolveModelInfo(next.provider, next.model)
+    } catch {
+      info = undefined
     }
+    const efforts = info?.reasoning?.efforts ?? []
+    let candidate = next.reasoningEffort
+    if (candidate !== undefined && !efforts.some((effort) => effort.id === candidate)) {
+      logger.warn(`acp-enhanced: dropped reasoning effort "${candidate}" for ${next.provider}/${next.model} (unsupported)`)
+      candidate = undefined
+    }
+    if (candidate === undefined && efforts.length > 0) {
+      const remembered = rememberedEffort(next.provider, next.model)
+      candidate = remembered !== undefined && efforts.some((effort) => effort.id === remembered)
+        ? remembered
+        : info?.reasoning?.defaultEffort ?? efforts[0].id
+    }
+    const resolved = await llm.resolveCallConfig(
+      candidate === undefined
+        ? { provider: next.provider, model: next.model }
+        : { ...next, reasoningEffort: candidate },
+    )
     const selected = {
       provider: resolved.provider,
       model: resolved.model,
       ...resolved.reasoningEffort === undefined ? {} : { reasoningEffort: resolved.reasoningEffort },
     }
     record.selection.current = selected
+    // Remember the effective effort for this route so a later switch back
+    // restores it (a model without reasoning metadata records nothing).
+    if (selected.reasoningEffort !== undefined) {
+      rememberEffort(selected.provider, selected.model, selected.reasoningEffort)
+    }
     // Persist as the default only when the chosen route is one this bridge is
     // wired to serve. On a single-provider machine the default route is the
     // routable one, so switching within it always persists; a stray cross-provider

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-acp-enhanced",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Enhanced ACP server for DeepSeek Harness: block-level streaming, usage/stat telemetry (cache hit rate, token speed, input/output tokens, context length, turns, tool timing), model & reasoning-effort switching, and permission-preset control over the ACP wire (Zed-friendly)",
   "keywords": [
     "dsh",

package/scripts/dsh-acp-zed.sh

@@ -61,4 +61,15 @@ if [ -z "${DEEPSEEK_API_KEY:-}" ]; then
   fi
 fi
 
+# Derive the profile root from this launcher's own location:
+#   …/profiles/<name>/node_modules/<pkg>/scripts/dsh-acp-zed.sh
+# — three levels above this script is the profile dir. pwd -L keeps the
+# logical path (pnpm lays out node_modules as symlinks), so the climb lands
+# on the profile root. The bridge persists small per-model state (the last
+# reasoning effort per model) next to the profile's own files.
+if [ -z "${DSH_ACP_PROFILE_DIR:-}" ]; then
+  ACP_LAUNCHER_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -L)"
+  export DSH_ACP_PROFILE_DIR="$(cd "${ACP_LAUNCHER_DIR}/../../.." && pwd -L)"
+fi
+
 exec "${DASH_BIN}" --profile acp-enhanced "$@"