lark-remote 0.5.3 → 0.5.5

package/dist/router/config/dsh.js

@@ -1,82 +1,176 @@
 /**
  * DshConfigBuilder — /config card fields for the DSH agent.
  *
- * DSH (DeepSeek Harness) is an HTTP-only agent. Beyond the Web Host base URL it
- * exposes three runtime-configurable knobs — preset, model, reasoning effort.
+ * DSH (DeepSeek Harness) is an HTTP-only agent. The card exposes the Web Host
+ * base URL plus preset/provider/model/reasoning-effort knobs. The launch token
+ * is a YAML-only fallback and is never rendered or saved through the card.
  *
- * 清单来源分两期：
- * - 动态清单（当前实现）：打开 /config 前通过 `llm.models` / `agentPreset.list`
- *   预取（Router 调 `prefetch()`），失败/离线回退下方固定兜底清单，卡不依赖
+ * 清单来源：
+ * - 动态清单：打开 /config 前通过 `session/modelCatalog` / `agentPresets/list`
+ *   预取（Router 调 `prefetch()`），失败/离线回退固定兜底清单，卡不依赖
  *   DSH 服务在线。
- * - 三个可选字段用空字符串哨兵表示「跟随服务端默认」：select 的 value `''`
- *   在 handleFieldChange 中被转成 undefined patch（router 删除键），config.yaml
- *   不写该键 = 服务端默认。
+ * - provider / model / reasoningEffort 用空字符串哨兵表示「跟随默认」：select
+ *   的 value `''` 在 handleFieldChange 中被转成 undefined patch（router 删除
+ *   键），config.yaml 不写该键 = 服务端默认。
+ * - provider 没有哨兵：旧配置没有 provider 时按 `deepseek-official` 生效，
+ *   与 runner 的兼容规则一致。provider 清单不硬编码，来自服务端目录。
  */
 import { DEFAULT_DSH_HOST } from '../../config/index.js';
 import { DshClient } from '../../runner/dsh/client.js';
 import { getLogger } from '../../logger/index.js';
-/** 固定兜底 preset 清单（DSH rc.7 实测；动态拉取失败时使用）。 */
+/** 旧配置没有 provider 时的生效值（与 DshRunner 的兼容规则一致）。 */
+const LEGACY_PROVIDER = 'deepseek-official';
+/** 固定兜底 preset 清单（DSH 0.2.x 实测；动态拉取失败时使用）。 */
 const FALLBACK_PRESET_OPTIONS = [
     { text: 'standard（标准模式）', value: 'standard' },
     { text: 'minimal（极简模式）', value: 'minimal' },
-    { text: 'code（PTC 模式）', value: 'code' },
+    { text: 'ptc（PTC 模式）', value: 'ptc' },
     { text: 'cordis（创造模式）', value: 'cordis' },
 ];
-/** 固定兜底模型清单（DSH rc.7 实测；动态拉取失败时使用）。 */
-const FALLBACK_MODEL_OPTIONS = ['deepseek-v4-flash', 'deepseek-v4-pro'];
-/** 固定兜底推理档位（llm.models 实际档位；动态拉取失败时使用）。 */
+/** 固定兜底模型清单（DSH 0.2.x 实测；动态拉取失败时使用）。 */
+const FALLBACK_MODEL_OPTIONS = ['deepseek-flash', 'deepseek-v4-pro'];
+/** 固定兜底推理档位（session/modelCatalog 实际档位；动态拉取失败时使用）。 */
 const FALLBACK_EFFORT_OPTIONS = ['off', 'low', 'high', 'max'];
-/** 「跟随服务端默认」哨兵值：select value 用空串，保存时转 undefined 删除键。 */
+/** 固定兜底权限预设（DSH 0.2.x 实测；动态拉取失败时使用）。 */
+const FALLBACK_PERMISSION_OPTIONS = [
+    { text: 'read-only（只读）', value: 'read-only' },
+    { text: 'workspace-write（工作区可写）', value: 'workspace-write' },
+    { text: 'danger-full-access（完全访问，关闭审批）', value: 'danger-full-access' },
+];
+/** 「跟随默认」哨兵值：select value 用空串，保存时转 undefined 删除键。 */
 const DEFAULT_SENTINEL = '';
 export class DshConfigBuilder {
-    /** 最近一次预取用的 host；host 变更时缓存失效（下一张卡重新拉取）。 */
+    /** 最近一次预取用的 host；host 变更时缓存失效。 */
     prefetchHost;
     modelCatalog;
     presets;
+    permissionCatalog;
     /** 可注入 client 工厂（测试用）；默认生产实现。 */
     clientFactory;
     constructor(clientFactory) {
-        this.clientFactory = clientFactory ?? ((base) => new DshClient(base));
+        this.clientFactory =
+            clientFactory ??
+                ((base, token, credentialsFile) => new DshClient(base, {
+                    token,
+                    credentialsFile,
+                    // 卡片预取是交互路径：DSH 卡死时最多等 5 秒后回退固定清单。
+                    requestTimeoutMs: 5_000,
+                }));
     }
-    /** 异步预取模型/预设目录（§4.2 二期动态清单）。失败/离线静默回退固定兜底清单，
-     *  卡不依赖 DSH 服务在线；同一 host 只拉一次，避免每次刷卡重复请求。 */
-    async prefetch(host) {
+    /**
+     * 异步预取模型/预设目录。失败/离线静默回退固定兜底清单，卡不依赖 DSH
+     * 服务在线。`force` 用于打开 /config 时强制刷新（在 DSH Web UI 新增
+     * provider 后不需要重启 lark-remote）。三个请求并行，最坏等待一个超时。
+     */
+    async prefetch(host, token, credentialsFile, options = {}) {
         const base = (host ?? DEFAULT_DSH_HOST).replace(/\/$/, '');
-        if (!base || base === this.prefetchHost)
+        const key = `${base}\u0000${token ?? ''}\u0000${credentialsFile ?? ''}`;
+        if (!base || (!options.force && key === this.prefetchHost))
             return;
-        const client = this.clientFactory(base);
-        try {
-            this.modelCatalog = await client.listModels();
+        const client = this.clientFactory(base, token, credentialsFile);
+        const [models, presets, permissions] = await Promise.allSettled([
+            client.listModels(),
+            client.listPresets(),
+            client.listPermissionPresets(),
+        ]);
+        if (models.status === 'fulfilled') {
+            this.modelCatalog = models.value;
         }
-        catch (err) {
-            getLogger().warn(`[dsh-config] llm.models prefetch failed (falling back to fixed catalog): ${err.message}`);
+        else {
+            getLogger().warn(`[dsh-config] session/modelCatalog prefetch failed (falling back to fixed catalog): ${models.reason.message}`);
             this.modelCatalog = undefined;
         }
-        try {
-            this.presets = await client.listPresets();
+        if (presets.status === 'fulfilled') {
+            this.presets = presets.value;
         }
-        catch (err) {
-            getLogger().warn(`[dsh-config] agentPreset.list prefetch failed (falling back to fixed presets): ${err.message}`);
+        else {
+            getLogger().warn(`[dsh-config] agentPresets/list prefetch failed (falling back to fixed presets): ${presets.reason.message}`);
             this.presets = undefined;
         }
-        this.prefetchHost = base;
+        if (permissions.status === 'fulfilled') {
+            this.permissionCatalog = permissions.value;
+        }
+        else {
+            getLogger().warn(`[dsh-config] permissionPresets/catalog prefetch failed (falling back to fixed presets): ${permissions.reason.message}`);
+            this.permissionCatalog = undefined;
+        }
+        this.prefetchHost = key;
     }
     /** 同步注入 catalog/presets（测试用，替代异步 prefetch；标记 prefetchHost 使
      *  后续 prefetch 短路，避免测试误触发网络请求）。 */
-    setCatalog(catalog, presets) {
+    setCatalog(catalog, presets, permissionCatalog) {
         this.modelCatalog = catalog;
         if (presets)
             this.presets = presets;
+        if (permissionCatalog)
+            this.permissionCatalog = permissionCatalog;
         this.prefetchHost = 'injected';
     }
-    /** 展平 llm.models 各 provider group 的模型 id；无 catalog 时回退固定清单。 */
-    modelOptions() {
+    /** Provider 下拉：目录 groups + 当前值兜底；离线时只保留当前值。 */
+    providerOptions(currentProvider, configured) {
+        const options = [];
         if (this.modelCatalog) {
-            const ids = this.modelCatalog.groups.flatMap((g) => g.models.map((m) => m.id));
-            if (ids.length > 0)
-                return ids;
+            for (const group of this.modelCatalog.groups) {
+                options.push({
+                    text: group.name && group.name !== group.id ? `${group.name}（${group.id}）` : group.id,
+                    value: group.id,
+                });
+            }
+        }
+        if (!options.some((option) => option.value === currentProvider)) {
+            const source = configured ? '当前配置' : '默认';
+            options.push({
+                text: this.modelCatalog
+                    ? `${currentProvider}（${source}，服务端未列出）`
+                    : `${currentProvider}（${source}，离线未校验）`,
+                value: currentProvider,
+            });
         }
-        return FALLBACK_MODEL_OPTIONS;
+        return options;
+    }
+    /**
+     * 当前 provider 的模型清单。目录在线但该 provider 不在目录中时返回空列表
+     * （不把 DeepSeek 模型冒充成其他 provider 的模型）；目录离线时用固定兜底。
+     */
+    modelOptionsFor(provider) {
+        if (!this.modelCatalog)
+            return FALLBACK_MODEL_OPTIONS;
+        const group = this.modelCatalog.groups.find((entry) => entry.id === provider);
+        if (!group)
+            return [];
+        return group.models.map((model) => ({
+            text: model.name && model.name !== model.id ? `${model.name}（${model.id}）` : model.id,
+            value: model.id,
+        }));
+    }
+    modelValues(provider) {
+        return this.modelOptionsFor(provider).map((option) => typeof option === 'string' ? option : option.value);
+    }
+    /** Provider 的默认模型：目录默认值属于该 provider 时优先，否则首个模型。 */
+    defaultModelFor(provider) {
+        const group = this.modelCatalog?.groups.find((entry) => entry.id === provider);
+        if (!group || group.models.length === 0)
+            return undefined;
+        const defaultModel = this.modelCatalog?.default?.provider === provider
+            ? this.modelCatalog.default.model
+            : undefined;
+        return defaultModel && group.models.some((model) => model.id === defaultModel)
+            ? defaultModel
+            : group.models[0].id;
+    }
+    /**
+     * 模型可用的推理档位。目录在线时严格按模型声明：模型没有 reasoning 元数据
+     * 就返回空（只留「跟随模型默认」），避免把 A 模型的档位塞给 B 模型。
+     */
+    effortOptionsFor(provider, model) {
+        if (!this.modelCatalog)
+            return FALLBACK_EFFORT_OPTIONS;
+        const group = this.modelCatalog.groups.find((entry) => entry.id === provider);
+        if (!group)
+            return [];
+        const target = model ?? this.defaultModelFor(provider);
+        const entry = target ? group.models.find((candidate) => candidate.id === target) : undefined;
+        return entry?.reasoning?.efforts.map((effort) => effort.id) ?? [];
     }
     /** preset 清单；无 presets 时回退固定清单。显示名优先用 preset.yml 的 name。 */
     presetOptions() {
@@ -87,28 +181,60 @@ export class DshConfigBuilder {
         }
         return FALLBACK_PRESET_OPTIONS;
     }
-    /** 模型在 catalog 中声明的推理档位；无 catalog/模型不在目录时回退固定档位。 */
-    effortOptionsForModel(model) {
-        if (model && this.modelCatalog) {
-            for (const group of this.modelCatalog.groups) {
-                const entry = group.models.find((m) => m.id === model);
-                if (entry?.reasoning && entry.reasoning.efforts.length > 0) {
-                    return entry.reasoning.efforts.map((e) => e.id);
-                }
-            }
+    /** 权限预设清单；配置默认只允许 defaultOptions（auto 只适用于当前会话）。 */
+    permissionOptions() {
+        const entries = this.permissionCatalog?.defaultOptions;
+        if (entries && entries.length > 0) {
+            return entries.map((p) => ({
+                text: p.value === 'read-only'
+                    ? 'read-only（只读）'
+                    : p.value === 'workspace-write'
+                        ? 'workspace-write（工作区可写）'
+                        : p.value === 'danger-full-access'
+                            ? 'danger-full-access（完全访问，关闭审批）'
+                            : p.name && p.name !== p.value
+                                ? `${p.value}（${p.name}）`
+                                : p.value,
+                value: p.value,
+            }));
         }
-        return FALLBACK_EFFORT_OPTIONS;
+        return FALLBACK_PERMISSION_OPTIONS;
+    }
+    /** “跟随服务端默认”文案带上实际默认值，避免用户不知道默认是什么。 */
+    permissionDefaultText() {
+        const current = this.permissionCatalog?.defaultPreset;
+        return current ? `跟随服务端默认（当前 ${current}）` : '跟随服务端默认';
     }
     buildFields(displayConfig) {
         const dsh = displayConfig.agents?.dsh;
         const currentHost = dsh?.host ?? DEFAULT_DSH_HOST;
         const currentPreset = dsh?.agentPreset ?? DEFAULT_SENTINEL;
+        const currentPermission = dsh?.permissionPreset ?? DEFAULT_SENTINEL;
+        const configuredProvider = dsh?.provider;
+        const currentProvider = configuredProvider ?? LEGACY_PROVIDER;
         const currentModel = dsh?.model ?? DEFAULT_SENTINEL;
         const currentEffort = dsh?.reasoningEffort ?? DEFAULT_SENTINEL;
-        const modelOptions = this.modelOptions();
-        const isCustomModel = currentModel !== DEFAULT_SENTINEL && !modelOptions.includes(currentModel);
-        const effortOptions = this.effortOptionsForModel(currentModel === DEFAULT_SENTINEL ? undefined : currentModel);
-        return [
+        const providerOptions = this.providerOptions(currentProvider, configuredProvider !== undefined);
+        const modelOptions = this.modelOptionsFor(currentProvider);
+        const isCustomModel = currentModel !== DEFAULT_SENTINEL &&
+            !this.modelValues(currentProvider).includes(currentModel);
+        const permissionOptions = [...this.permissionOptions()];
+        if (currentPermission !== DEFAULT_SENTINEL &&
+            !permissionOptions.some((option) => option.value === currentPermission)) {
+            permissionOptions.push({
+                text: `${currentPermission}（当前配置，服务端未列出）`,
+                value: currentPermission,
+            });
+        }
+        const effortOptions = this.effortOptionsFor(currentProvider, currentModel || undefined).map((value) => ({ text: value, value }));
+        if (currentEffort !== DEFAULT_SENTINEL &&
+            !effortOptions.some((option) => option.value === currentEffort)) {
+            effortOptions.push({
+                text: `${currentEffort}（当前配置，模型未列出）`,
+                value: currentEffort,
+            });
+        }
+        const fields = [
             {
                 key: 'agents.dsh.host',
                 label: 'DSH Web Host',
@@ -117,17 +243,35 @@ export class DshConfigBuilder {
             },
             {
                 key: 'agents.dsh.agentPreset',
-                label: '预设模式',
+                label: '预设模式（工具集）',
                 type: 'select',
                 options: [{ text: '跟随服务端默认', value: DEFAULT_SENTINEL }, ...this.presetOptions()],
                 currentValue: currentPreset,
             },
+            {
+                key: 'agents.dsh.permissionPreset',
+                label: '权限预设（沙箱 + 审批）',
+                type: 'select',
+                options: [
+                    { text: this.permissionDefaultText(), value: DEFAULT_SENTINEL },
+                    ...permissionOptions,
+                ],
+                currentValue: currentPermission,
+            },
+            {
+                key: 'agents.dsh.provider',
+                label: 'Provider（模型服务商）',
+                type: 'select',
+                options: providerOptions,
+                currentValue: currentProvider,
+            },
             {
                 key: 'agents.dsh.model',
                 label: '使用模型',
                 type: 'select',
-                options: [{ text: '跟随服务端默认', value: DEFAULT_SENTINEL }, ...modelOptions],
-                currentValue: isCustomModel ? undefined : currentModel,
+                options: [{ text: '跟随该 Provider 默认', value: DEFAULT_SENTINEL }, ...modelOptions],
+                // 自定义模型不在下拉里：让下拉停在哨兵，模型名由下方输入框承载。
+                currentValue: isCustomModel ? DEFAULT_SENTINEL : currentModel,
             },
             // 自定义模型名输入框（与 codex/claude 一致的行为）
             {
@@ -140,40 +284,85 @@ export class DshConfigBuilder {
                 key: 'agents.dsh.reasoningEffort',
                 label: '推理强度',
                 type: 'select',
-                options: [{ text: '跟随服务端默认', value: DEFAULT_SENTINEL }, ...effortOptions],
+                options: [{ text: '跟随模型默认', value: DEFAULT_SENTINEL }, ...effortOptions],
                 currentValue: currentEffort,
             },
         ];
+        const failures = this.modelCatalog?.failures ?? [];
+        if (failures.length > 0) {
+            fields.push({
+                key: 'agents.dsh.providerFailures',
+                label: `⚠️ Provider 目录异常：${failures
+                    .map((failure) => `${failure.id}（${failure.message}）`)
+                    .join('；')}`,
+                type: 'note',
+            });
+        }
+        return fields;
     }
     handleFieldChange(key, value, config) {
+        // provider 没有哨兵：切换时联动 model/effort，避免 provider 与 model 来自
+        // 不同目录（selectModel 会以 session/model-unavailable 失败）。
+        if (key === 'agents.dsh.provider' && typeof value === 'string') {
+            return this.providerChangePatches(value, config);
+        }
         const patches = [];
-        // 空串哨兵「跟随服务端默认」→ undefined patch（router 删除键）
+        // 空串哨兵「跟随默认」→ undefined patch（router 删除键）
         const effective = value === DEFAULT_SENTINEL ? undefined : value;
         patches.push({ key, value: effective });
-        // 模型变更时，若当前档位不被新模型支持，重置（参照 kimi/codex 语义）
+        // 模型变更时，把 provider 固定到当前 provider（旧配置只有 model 时，
+        // 第一次选模型即完成迁移），并按新模型重置不被支持的档位。
         if (key === 'agents.dsh.model' && typeof value === 'string') {
-            const effortPatch = this.effortPatchForModel(config, effective);
+            const newModel = effective;
+            const provider = config.agents?.dsh?.provider ?? LEGACY_PROVIDER;
+            if (newModel) {
+                patches.push({ key: 'agents.dsh.provider', value: provider });
+            }
+            const effortPatch = this.effortPatchForModel(config, provider, newModel);
             if (effortPatch)
                 patches.push(effortPatch);
         }
         return patches;
     }
-    /** 切到 newModel 后的档位补丁：当前档位仍被新模型支持 → 不产出；否则用新模型
-     *  目录中位；无目录/空列表 → undefined（清空 = 跟随服务端默认）。 */
-    effortPatchForModel(config, newModel) {
+    /** 切 provider 后的联动：provider → 新 provider 的默认/首个模型 → 合法档位。 */
+    providerChangePatches(provider, config) {
+        const patches = [
+            { key: 'agents.dsh.provider', value: provider },
+        ];
+        if (!this.modelCatalog)
+            return patches;
+        const group = this.modelCatalog.groups.find((entry) => entry.id === provider);
+        if (!group)
+            return patches;
+        const currentModel = config.agents?.dsh?.model;
+        const keepModel = currentModel !== undefined && group.models.some((model) => model.id === currentModel);
+        const nextModel = keepModel ? currentModel : this.defaultModelFor(provider);
+        if (nextModel !== currentModel) {
+            patches.push({ key: 'agents.dsh.model', value: nextModel });
+        }
+        const effortPatch = this.effortPatchForModel(config, provider, nextModel);
+        if (effortPatch)
+            patches.push(effortPatch);
+        return patches;
+    }
+    /**
+     * 切到 (provider, newModel) 后的档位补丁：当前档位仍被新模型支持 → 不产出；
+     * 否则用新模型目录中位；目录离线 → 不产出（保留现状，由服务端校验）；
+     * 模型无 reasoning 元数据 → 清空档位（跟随模型默认）。
+     */
+    effortPatchForModel(config, provider, newModel) {
         const currentEffort = config.agents?.dsh?.reasoningEffort;
         if (!newModel) {
-            // 模型被清空（跟随默认）→ 档位一并清空跟随默认
             return currentEffort ? { key: 'agents.dsh.reasoningEffort', value: undefined } : null;
         }
-        const supported = this.effortOptionsForModel(newModel);
+        if (!this.modelCatalog)
+            return null;
+        const supported = this.effortOptionsFor(provider, newModel);
         if (currentEffort && supported.includes(currentEffort))
             return null;
         // 新模型目录中位档位；偶数长度取偏高位（off/low → low，符合 DSH 默认 high 语义）
         const middle = supported[Math.floor(supported.length / 2)];
-        return middle
-            ? { key: 'agents.dsh.reasoningEffort', value: middle }
-            : { key: 'agents.dsh.reasoningEffort', value: undefined };
+        return { key: 'agents.dsh.reasoningEffort', value: middle };
     }
 }
 //# sourceMappingURL=dsh.js.map

package/dist/router/config/opencode.js

@@ -5,18 +5,27 @@ import { loadOpencodeConfig } from '../../config/opencode-config.js';
 import { DEFAULT_TURN_IDLE_TIMEOUT_MINUTES } from '../../config/index.js';
 import { resetModelPatch } from './common/model-patch.js';
 const MODE_OPTIONS = [
-    { text: 'build（默认，逐项审批）', value: 'build' },
+    { text: 'build（默认，按 opencode 权限配置）', value: 'build' },
     { text: 'plan（规划模式）', value: 'plan' },
 ];
+/** Keep the currently configured value selectable even when the CLI failed and
+ *  we are showing the static fallback catalog. */
+function withCurrent(options, current) {
+    if (current === undefined || options.includes(current))
+        return options;
+    return [current, ...options];
+}
 export class OpencodeConfigBuilder {
     buildFields(displayConfig) {
         const fields = [];
         // 从 opencode models 命令动态读取 provider 和 model
-        const opencodeCfg = loadOpencodeConfig();
-        const providerNames = opencodeCfg.providerNames;
-        // 根据 displayConfig 中已选的 provider 过滤 model 选项
+        const binary = displayConfig.agents?.opencode?.acp?.binary;
+        const opencodeCfg = loadOpencodeConfig(binary);
         const currentProvider = displayConfig.agents?.opencode?.providerID;
-        const modelOptions = opencodeCfg.modelOptions(currentProvider);
+        const currentModel = displayConfig.agents?.opencode?.modelID;
+        const providerNames = withCurrent(opencodeCfg.providerNames, currentProvider);
+        // 根据 displayConfig 中已选的 provider 过滤 model 选项
+        const modelOptions = withCurrent(opencodeCfg.modelOptions(currentProvider), currentModel);
         fields.push({
             key: 'agents.opencode.providerID',
             label: 'Provider',
@@ -56,7 +65,8 @@ export class OpencodeConfigBuilder {
         patches.push({ key, value });
         // provider 变更时，重置 model 为新 provider 的首个模型
         if (key === 'agents.opencode.providerID' && typeof value === 'string') {
-            const opencodeCfg = loadOpencodeConfig();
+            const binary = config.agents?.opencode?.acp?.binary;
+            const opencodeCfg = loadOpencodeConfig(binary);
             const currentModel = config.agents?.opencode?.modelID;
             const modelPatch = resetModelPatch('agents.opencode.modelID', currentModel, opencodeCfg.modelOptions(value));
             if (modelPatch)

package/dist/router/config/types.d.ts

@@ -51,8 +51,11 @@ export interface AgentConfigCardBuilder {
     }>;
     /**
      * 可选的异步预取钩子：卡片渲染前拉取动态选项（如 DSH 的模型/预设目录）。
-     * host 为该 agent 的当前连接地址；实现内部应缓存（同一 host 只拉一次），
-     * 失败静默回退固定兜底，不阻断卡片渲染。非异步预取的 agent 可不实现。
+     * host 为该 agent 的当前连接地址；实现内部默认按 host 缓存，`force` 用于
+     * 打开 /config 时强制刷新（外部新增 provider 后无需重启）。失败静默回退
+     * 固定兜底，不阻断卡片渲染。非异步预取的 agent 可不实现。
      */
-    prefetch?(host?: string): Promise<void>;
+    prefetch?(host?: string, token?: string, credentialsFile?: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
 }

package/dist/router/index.d.ts

@@ -664,6 +664,7 @@ export declare class CommandRouter {
      * DSH /config 卡片构建前异步预取模型/预设目录（§4.2 动态清单）。
      * 只在 defaultAgent 为 dsh 时生效；其他 agent 无 prefetch 钩子直接跳过。
      * 预取失败不阻断——DshConfigBuilder 内部已回退固定兜底清单。
+     * `force` 在打开 /config 时使用：DSH Web UI 刚新增的 provider 立即出现。
      */
     private prefetchConfigCardCatalogs;
     /** Build an interactive config card with CardKit 2.0 tabs + batch save */

package/dist/router/index.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import YAML from 'yaml';
 import { getConfigDir, getConfigValue, setConfigValue, setConfigValues, mapAgentKey, getAgentConfig, } from '../config/index.js';
 import { syncAgentChoices } from '../runner/index.js';
+import { resolveDshCredentialsFile } from '../runner/dsh/auth.js';
 import { WorkspaceStore } from '../workspace/index.js';
 import { OrderStore } from '../order/index.js';
 import { resolveAlias } from '../order/alias-resolve.js';
@@ -2144,7 +2145,8 @@ export class CommandRouter {
             k === 'agents.opencode' ||
             k.startsWith('agents.opencode.') ||
             k === 'opencode' ||
-            k.startsWith('opencode.'));
+            k.startsWith('opencode.') ||
+            k === 'agents.dsh.permissionPreset');
         if (hasApprovalConfigChange) {
             this.bridge.syncActiveApprovalModes();
         }
@@ -3848,8 +3850,9 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
     async cmdConfig(args, ctx) {
         // Ensure probe cache is populated before building the card.
         await probeAllAgents();
-        // 动态清单预取（DSH 模型/预设目录）：卡渲染前拉取，失败回退兜底清单
-        await this.prefetchConfigCardCatalogs();
+        // 动态清单预取（DSH 模型/预设目录）：卡渲染前强制刷新，DSH Web UI 刚新增
+        // 的 provider 立即可见；失败回退兜底清单。
+        await this.prefetchConfigCardCatalogs(true);
         // Check if this is a direct set command: /config <key> <value>
         // Command-style set: immediate write to disk, clear pendingConfig
         if (args.length >= 2) {
@@ -3900,13 +3903,18 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
      * DSH /config 卡片构建前异步预取模型/预设目录（§4.2 动态清单）。
      * 只在 defaultAgent 为 dsh 时生效；其他 agent 无 prefetch 钩子直接跳过。
      * 预取失败不阻断——DshConfigBuilder 内部已回退固定兜底清单。
+     * `force` 在打开 /config 时使用：DSH Web UI 刚新增的 provider 立即出现。
      */
-    async prefetchConfigCardCatalogs() {
+    async prefetchConfigCardCatalogs(force = false) {
         if (this.config.defaultAgent !== 'dsh')
             return;
         const builder = getConfigBuilder('dsh');
         const dshConf = getAgentConfig(this.config, 'dsh');
-        await builder.prefetch?.(dshConf?.host);
+        const credentialsFile = dshConf?.credentialsFile?.trim() ||
+            (dshConf?.dshHome?.trim()
+                ? resolveDshCredentialsFile(process.env, dshConf.dshHome)
+                : undefined);
+        await builder.prefetch?.(dshConf?.host, dshConf?.token, credentialsFile, { force });
     }
     /** Build an interactive config card with CardKit 2.0 tabs + batch save */
     buildConfigCard() {

package/dist/runner/codex/app-server/translator.js

@@ -222,6 +222,11 @@ export class CodexAppServerTranslator {
         this.threadId = params.threadId;
         this.turnId = params.turn.id;
         this.turnStatus = params.turn.status ?? 'inProgress';
+        // 单 turn 用量从零开始累计：turn 内每次采样都会发一条
+        // `thread/tokenUsage/updated`，本 run 的用量是这些增量之和（不是最后一条）。
+        // resume 后服务端重放的上一 turn 用量若在此之后到达，由 handleTokenUsageUpdated
+        // 的 turnId 闸门挡掉。
+        this.usage = { inputTokens: 0, outputTokens: 0 };
         this.textByItem.clear();
         this.reasoningByItem.clear();
         this.toolOutputByItem.clear();
@@ -455,22 +460,31 @@ export class CodexAppServerTranslator {
         ];
     }
     handleTokenUsageUpdated(params) {
+        // 归属闸门：resume 之后服务端可能重放上一 turn 的 tokenUsage（turnId 不同），
+        // 计入会把上一 turn 的消耗算成本 run。本轮 turnId 由 turn/started 确立。
+        if (params.turnId && this.turnId && params.turnId !== this.turnId) {
+            return [];
+        }
         const last = params.tokenUsage.last;
         // 协议原生 inputTokens 含 cached（total = input + output），而 lark-remote 的
         // 卡片契约是 ccusage 口径「input_tokens 表示未命中缓存的输入」（design §9.21）。
         // 在入口归一，否则 done 卡 Input 会等于 Context、cache% 分母重复计数、
         // Total 被 max(total, input+output+cache) 抬高一倍（实测 364K → 727K）。
         // jsonl 链路有同一处减法（session/codex/rollout-reader.ts buildUsageFromScan）。
+        // 单 turn 口径：一个 turn 内每次采样各发一条通知（实测 7 次工具往返 = 7 条），
+        // 本 run 是这些增量之和——只取最后一条会把多步 run 低报（实测 3,648 output 显示成 679）。
         const cachedInputTokens = last.cachedInputTokens === undefined
             ? undefined
             : Math.min(last.cachedInputTokens, last.inputTokens);
-        this.usage = {
-            inputTokens: last.inputTokens - (cachedInputTokens ?? 0),
-            outputTokens: last.outputTokens,
-            cachedInputTokens,
-            totalTokens: last.totalTokens,
-            contextLimit: params.tokenUsage.modelContextWindow,
-        };
+        this.usage.inputTokens += last.inputTokens - (cachedInputTokens ?? 0);
+        this.usage.outputTokens += last.outputTokens;
+        if (cachedInputTokens !== undefined) {
+            this.usage.cachedInputTokens = (this.usage.cachedInputTokens ?? 0) + cachedInputTokens;
+        }
+        if (last.totalTokens !== undefined) {
+            this.usage.totalTokens = (this.usage.totalTokens ?? 0) + last.totalTokens;
+        }
+        this.usage.contextLimit = params.tokenUsage.modelContextWindow ?? this.usage.contextLimit;
         return [];
     }
     /**

package/dist/runner/common/acp/base-acp-runner.d.ts

@@ -53,12 +53,24 @@ export declare abstract class BaseAcpRunner<TTranslator extends BaseAcpTranslato
      * matches. Failures are non-fatal (warn only).
      */
     protected abstract applyTurnSettings(client: JsonRpcClient, sessionId: string): Promise<void>;
+    /**
+     * session/new|resume retry policy. Default: no retry. Agents whose ACP
+     * server sits behind a separately-starting service (opencode v2) override
+     * this to absorb a transient `ServiceUnavailableError` without failing the
+     * whole turn.
+     */
+    protected sessionSetupRetryDelaysMs(): number[];
+    /** Whether a failed session/new|resume is safe to retry. */
+    protected isRetryableSessionSetupError(_err: unknown): boolean;
+    /** Final error surfaced to the user after retries are exhausted. */
+    protected enrichSessionSetupError(err: unknown): Error;
     /**
      * Dispatch the compact prompt result once fired. kimi: background
      * compaction — poll wire.jsonl for a NEW terminal record before translating
      * (§5.2). opencode: synchronous — standard prompt-settle translation.
      */
     protected abstract onCompactPromptFired(promptPromise: Promise<SessionPromptResult>, translator: TTranslator, sessionId: string, opts: SpawnOptions, baselineTotalCount: number): void;
+    private withSessionSetupRetry;
     protected currentSessionId(): string | null;
     protected cancelCurrentTurn(): Promise<void>;
     protected clearTurnState(): void;