@ai-workbench/remote-agent 0.8.10 → 0.8.12

package/dist/model-catalog.js

@@ -1,24 +1,29 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { spawn } from 'node:child_process';
 import { LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { sameTarget, validateTarget } from "./provider.js";
 import { ModelConfigurationError } from "./model-configuration.js";
-import { sanitizeObservation } from "./conversation-details.js";
+import { runCatalog, CatalogSshError, catalogSafeText } from "./catalog-ssh.js";
+export { runCatalog } from "./catalog-ssh.js";
 const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
 const text = (value) => typeof value === 'string' && value.trim().length > 0;
-function fail(reason) { throw new LlmError('无法获取模型列表：' + reason, 'MODEL_CATALOG_UNAVAILABLE'); }
+class CatalogError extends LlmError {
+    diagnostic;
+    constructor(reason, diagnostic) { super('无法获取模型列表：' + reason, 'MODEL_CATALOG_UNAVAILABLE'); this.diagnostic = diagnostic + '（诊断代码：MODEL_CATALOG_UNAVAILABLE）'; }
+}
+const safe = catalogSafeText;
+function fail(reason, diagnostic = reason) { throw new CatalogError(reason, diagnostic); }
 function freeze(value) { if (value && typeof value === 'object') {
     for (const item of Object.values(value))
         freeze(item);
     Object.freeze(value);
 } return value; }
+export function catalogDiagnostic(issues) {
+    return issues.length ? '以下模型未加入可选列表：\n' + issues.map(issue => `模型「${issue.modelName}」：${issue.reason}（诊断代码：${issue.code}）`).join('\n') : undefined;
+}
+/** Defaults are provider declarations, never catalog order or display names. */
+export function declaredDefault(agent, models) {
+    const selected = models.filter(model => agent.loginProvider === 'claude' ? model.value === 'default' : object(model.source) && model.source.isDefault === true);
+    return selected.length === 1 ? selected[0] : undefined;
+}
 export function parseHostCatalog(input, provider, username) {
     let wire;
     try {
@@ -32,115 +37,69 @@ export function parseHostCatalog(input, provider, username) {
     if (wire.ok === false) {
         const error = object(wire.error) ? wire.error : undefined;
         const code = typeof error?.code === 'string' && /^[A-Z][A-Z0-9_]*$/.test(error.code) ? error.code : 'PROTOCOL_INVALID';
-        const reason = text(error?.message) ? sanitizeObservation({ kind: 'session', severity: 'warning', code, summary: error.message, payload: {} }).summary : '主机未提供失败说明';
-        fail('主机目录查询失败（' + code + '）：' + reason);
+        const reason = text(error?.message) ? safe(error.message) : '主机未提供失败说明';
+        fail('主机目录查询失败，请到设置 → 模型查看诊断。', `主机目录查询失败（诊断代码：${code}）：${reason}`);
     }
     if (wire.ok !== true || wire.permissionProbe !== false || !object(wire.subject) || wire.subject.username !== username || !Number.isSafeInteger(wire.subject.uid) || !text(wire.observedAt) || !object(wire.source) || !object(wire.settings) || !Array.isArray(wire.models))
         fail('主机目录缺少完整元数据');
-    const ids = new Set(), values = new Set();
-    for (const model of wire.models) {
-        if (!object(model) || !text(model.id) || !text(model.value) || !text(model.name) || (model.resolvedModel !== null && !text(model.resolvedModel)) || !object(model.source) || !object(model.reasoning))
-            fail('主机模型条目不完整');
-        if (provider === 'codex' && model.resolvedModel !== model.value)
-            fail('Codex目录具体型号与模型值不一致');
-        if (ids.has(model.id) || values.has(model.value))
-            fail('主机目录含重复模型标识或值');
-        ids.add(model.id);
-        values.add(model.value);
+    const ids = new Map(), values = new Map();
+    for (const model of wire.models)
+        if (object(model)) {
+            if (text(model.id))
+                ids.set(model.id, (ids.get(model.id) ?? 0) + 1);
+            if (text(model.value))
+                values.set(model.value, (values.get(model.value) ?? 0) + 1);
+        }
+    const models = [], issues = [];
+    for (const [index, model] of wire.models.entries()) {
+        const modelName = object(model) && text(model.name) ? safe(model.name) : object(model) && text(model.id) ? safe(model.id) : `第 ${index + 1} 项（缺少模型名称）`;
+        const reject = (reason, code = 'MODEL_CATALOG_ITEM_INVALID') => issues.push({ modelName, reason, code });
+        if (!object(model) || !text(model.id) || !text(model.value) || !text(model.name) || (model.resolvedModel !== null && !text(model.resolvedModel)) || !object(model.source) || !object(model.reasoning)) {
+            reject('模型标识、名称或能力资料不完整');
+            continue;
+        }
+        if ((ids.get(model.id) ?? 0) > 1 || (values.get(model.value) ?? 0) > 1) {
+            reject('模型标识或发送值重复，无法确定对应关系', 'MODEL_CATALOG_DUPLICATE');
+            continue;
+        }
+        if (provider === 'codex' && model.resolvedModel !== model.value) {
+            reject('具体型号与发送模型值不一致');
+            continue;
+        }
         const r = model.reasoning;
-        if (!Array.isArray(r.options) || typeof r.defaultKnown !== 'boolean' || (r.defaultValue !== null && !text(r.defaultValue)) || (!r.defaultKnown && r.defaultValue !== null))
-            fail('主机推理等级或默认值无效');
+        if (!Array.isArray(r.options) || typeof r.defaultKnown !== 'boolean' || (r.defaultValue !== null && !text(r.defaultValue)) || (!r.defaultKnown && r.defaultValue !== null)) {
+            reject('推理档位或默认档位资料无效', 'MODEL_REASONING_INVALID');
+            continue;
+        }
         const efforts = new Set();
+        let invalid = false;
         for (const effort of r.options) {
-            if (!object(effort) || !text(effort.value) || !text(effort.name) || efforts.has(effort.value))
-                fail('主机推理等级条目无效或重复');
+            if (!object(effort) || !text(effort.value) || !text(effort.name) || efforts.has(effort.value)) {
+                invalid = true;
+                break;
+            }
             efforts.add(effort.value);
         }
-        if (r.defaultKnown && (r.defaultValue === null || !efforts.has(r.defaultValue)))
-            fail('主机默认推理等级缺少对应选项');
+        if (invalid) {
+            reject('推理档位缺少名称、值无效或重复', 'MODEL_REASONING_INVALID');
+            continue;
+        }
+        if (r.defaultKnown && (r.defaultValue === null || !efforts.has(r.defaultValue))) {
+            reject('默认推理档位不在该模型提供的选项中', 'MODEL_REASONING_DEFAULT_INVALID');
+            continue;
+        }
+        models.push(model);
     }
-    if (!wire.models.length)
-        fail('主机返回的完整模型目录为空');
-    return freeze(structuredClone(wire.models));
+    return freeze(structuredClone({ models, issues }));
 }
-/** Only the public L sshArgs function chooses SSH trust and transport arguments. */
-export const runCatalog = async (target, command, signal, maxBytes) => {
-    let argv;
-    try {
-        const moduleName = '@ai-workbench/connect';
-        const l = await import(__rewriteRelativeImportExtension(moduleName));
-        if (typeof l.sshArgs !== 'function')
-            fail('远程主机连接组件缺少可信 SSH 能力');
-        argv = l.sshArgs(target);
-    }
-    catch (error) {
-        if (error instanceof LlmError)
-            throw error;
-        fail('远程主机连接组件缺少可信 SSH 能力');
-    }
-    signal.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const child = spawn('ssh', ['-n', ...argv, command], { stdio: ['ignore', 'pipe', 'pipe'] });
-        const parts = [];
-        let total = 0, stderr = 0;
-        let failure;
-        const abort = () => { failure = new ModelConfigurationError('连接已改变或目录查询已取消'); child.kill('SIGTERM'); };
-        signal.addEventListener('abort', abort, { once: true });
-        const receive = (buffer, output) => { if (failure)
-            return; total += buffer.length; if (total > maxBytes) {
-            failure = new ModelConfigurationError('目录响应超过 acpMaxMessageBytes，未截断返回');
-            child.kill('SIGTERM');
-            return;
-        } if (output)
-            parts.push(buffer);
-        else
-            stderr += buffer.length; };
-        child.stdout.on('data', (b) => receive(b, true));
-        child.stderr.on('data', (b) => receive(b, false));
-        child.on('error', () => { failure = new ModelConfigurationError('可信 SSH 进程启动失败'); });
-        child.on('close', code => {
-            signal.removeEventListener('abort', abort);
-            if (failure) {
-                reject(failure);
-                return;
-            }
-            let output;
-            try {
-                output = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(parts));
-            }
-            catch {
-                reject(new ModelConfigurationError('主机目录响应不是有效 UTF-8，未替换模型值'));
-                return;
-            }
-            // S publishes its typed failure JSON on stdout even on nonzero exit.
-            if (code !== 0) {
-                try {
-                    const wire = JSON.parse(output);
-                    if (wire?.ok === false) {
-                        resolve(output);
-                        return;
-                    }
-                }
-                catch { }
-                reject(new ModelConfigurationError('可信 SSH 或主机目录命令失败（退出码 ' + String(code) + '）'));
-                return;
-            }
-            if (stderr) {
-                reject(new ModelConfigurationError('目录命令返回了非预期诊断输出'));
-                return;
-            }
-            resolve(output);
-        });
-        if (signal.aborted)
-            abort();
-    });
-};
-/** No cache: every query binds to L's current object, host-user and generation. */
+/** Share only pending work; settled results are never cached. */
 export class ModelCatalog {
     get;
     maxBytes;
     run;
     changed;
+    diagnostic;
+    loaded;
     api;
     unsubscribe;
     signature;
@@ -148,11 +107,16 @@ export class ModelCatalog {
     disposed = false;
     initialized = false;
     active = new Set();
-    constructor(get, maxBytes, run = runCatalog, changed = () => { }) {
+    flights = new Map();
+    serial = 0;
+    latest = new Map();
+    constructor(get, maxBytes, run = runCatalog, changed = () => { }, diagnostic = () => { }, loaded = () => { }) {
         this.get = get;
         this.maxBytes = maxBytes;
         this.run = run;
         this.changed = changed;
+        this.diagnostic = diagnostic;
+        this.loaded = loaded;
         this.refresh();
     }
     refresh() {
@@ -160,11 +124,10 @@ export class ModelCatalog {
         const state = api?.getConnectionState?.();
         const info = api?.getContractInfo?.();
         const targets = info?.modelCatalogTarget === 1 && api?.getModelCatalogTarget ? ['codex', 'claude'].map(brand => api.getModelCatalogTarget(brand)) : undefined;
-        const login = api?.getLoginPromptState?.();
         // L's same-epoch recovery wording is presentation metadata, not an execution change.
         const executionState = state && { instanceId: state.instanceId, epoch: state.epoch, phase: state.phase, needCode: state.need?.code };
         const executionTargets = targets?.map(result => result.ok ? result : { ok: false, code: result.error.code });
-        const signature = JSON.stringify({ state: executionState, capability: info?.modelCatalogTarget, targets: executionTargets, logins: login?.logins, authorizing: login?.phase === 'authorizing' });
+        const signature = JSON.stringify({ state: executionState, capability: info?.modelCatalogTarget, targets: executionTargets });
         const switched = api !== this.api;
         const changed = this.initialized && (switched || signature !== this.signature);
         this.initialized = true;
@@ -183,9 +146,12 @@ export class ModelCatalog {
         this.signature = signature;
         if (changed) {
             this.revision++;
+            this.latest.clear();
             for (const controller of this.active)
                 controller.abort();
             this.active.clear();
+            this.diagnostic('claude', undefined);
+            this.diagnostic('codex', undefined);
             this.changed();
         }
     }
@@ -198,7 +164,7 @@ export class ModelCatalog {
             fail('当前没有已验证的远程主机连接');
         const result = api.getModelCatalogTarget(agent.loginProvider);
         if (!result.ok)
-            fail(result.error.message);
+            fail('远程主机连接暂未提供可信的模型目录目标，请到设置 → 模型查看诊断。', `模型目录目标不可用（诊断代码：${safe(result.error.code)}）：${safe(result.error.message)}`);
         const target = result.value;
         if (target.version !== 1 || target.purpose !== 'model-catalog' || target.scope !== 'host-user' || target.provider !== agent.loginProvider || target.instanceId !== state.instanceId || target.epoch !== state.epoch)
             fail('模型目录目标与当前连接或品牌不匹配');
@@ -210,45 +176,121 @@ export class ModelCatalog {
         }
         return structuredClone(target);
     }
+    assertFlight(flight) {
+        if (flight.controller.signal.aborted || this.disposed || this.get() !== flight.api || flight.revision !== this.revision)
+            fail('连接已改变，原模型目录已失效');
+        const agent = { loginProvider: flight.target.provider }, current = this.trusted(agent, flight.api);
+        if (current.instanceId !== flight.target.instanceId || current.epoch !== flight.target.epoch || current.provider !== flight.target.provider || !sameTarget(current.target, flight.target.target))
+            fail('可信目标或连接代次已改变，原模型目录已失效');
+    }
+    failure(error) {
+        // Each consumer needs its own Error identity for its original input/signal proof.
+        return new CatalogError(error instanceof CatalogError || error instanceof ModelConfigurationError ? error.message.replace(/^无法获取模型列表：/, '') : '目录查询失败，请到设置 → 模型查看诊断。', error instanceof CatalogError ? error.diagnostic : error instanceof CatalogSshError ? error.diagnostic : error instanceof Error ? `${error instanceof LlmError ? error.code : 'MODEL_CATALOG_QUERY_FAILED'}：${safe(error.message)}` : 'MODEL_CATALOG_QUERY_FAILED：目录查询失败，根因未查明');
+    }
+    start(agent, api, target, max, key) {
+        const deferred = Promise.withResolvers(), controller = new AbortController();
+        const flight = { key, api, target, revision: this.revision, serial: ++this.serial, controller, pending: true, users: 0, promise: deferred.promise };
+        this.latest.set(agent.loginProvider, flight.serial);
+        this.flights.set(key, flight);
+        this.active.add(controller);
+        const current = () => !this.disposed && flight.revision === this.revision && api === this.get() && this.latest.get(agent.loginProvider) === flight.serial && !controller.signal.aborted;
+        const query = async () => {
+            try {
+                this.assertFlight(flight);
+                const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, controller.signal, max);
+                this.assertFlight(flight);
+                const parsed = parseHostCatalog(output, agent.loginProvider, target.target.username), diagnostic = catalogDiagnostic(parsed.issues);
+                if (!parsed.models.length)
+                    fail('当前没有可选模型，请到设置 → 模型查看诊断。', diagnostic ?? '主机返回的完整模型目录为空（诊断代码：MODEL_CATALOG_EMPTY）');
+                if (current())
+                    this.diagnostic(agent.loginProvider, diagnostic);
+                if (current())
+                    await this.loaded(agent, parsed.models, () => this.assertFlight(flight));
+                this.assertFlight(flight);
+                return parsed.models;
+            }
+            catch (error) {
+                const failure = this.failure(error);
+                if (current())
+                    this.diagnostic(agent.loginProvider, failure.diagnostic);
+                throw failure;
+            }
+        };
+        const settled = () => { flight.pending = false; if (this.flights.get(key) === flight)
+            this.flights.delete(key); if (!flight.users)
+            this.active.delete(controller); };
+        void query().then(models => { settled(); deferred.resolve(models); }, error => { settled(); deferred.reject(error); });
+        return flight;
+    }
     async read(agent, signal) {
-        let controller;
+        let flight, released = false;
+        const release = () => { if (released || !flight)
+            return; released = true; flight.users--; if (!flight.users) {
+            if (flight.pending)
+                flight.controller.abort();
+            else
+                this.active.delete(flight.controller);
+        } };
         try {
             if (this.disposed)
                 fail('远程模型插件已关闭');
+            signal?.throwIfAborted();
             this.refresh();
             const api = this.get();
             if (!api)
                 fail('远程主机连接组件没有装好');
-            const target = freeze(this.trusted(agent, api)), revision = this.revision;
-            const max = this.maxBytes();
+            const target = freeze(this.trusted(agent, api)), max = this.maxBytes();
             if (!Number.isSafeInteger(max) || max < 1)
                 fail('acpMaxMessageBytes 设置无效');
-            controller = new AbortController();
-            this.active.add(controller);
-            const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-            const assertCurrent = () => { if (combined.aborted || this.disposed || this.get() !== api || revision !== this.revision)
-                fail('连接已改变，原模型目录已失效'); const current = this.trusted(agent, api); if (current.instanceId !== target.instanceId || current.epoch !== target.epoch || current.provider !== target.provider || !sameTarget(current.target, target.target))
-                fail('可信目标或连接代次已改变，原模型目录已失效'); };
-            assertCurrent();
-            const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, combined, max);
+            const key = JSON.stringify([agent.loginProvider, target.instanceId, target.epoch]);
+            flight = this.flights.get(key);
+            if (flight && (flight.api !== api || flight.revision !== this.revision || !sameTarget(flight.target.target, target.target) || flight.controller.signal.aborted)) {
+                const closing = flight;
+                closing.controller.abort();
+                flight = undefined;
+                // Closing work owns the tuple until SSH/runner actually settles. This new
+                // caller waits for cleanup, then begins its own query; it never uses old data.
+                const waiting = new AbortController(), revision = this.revision;
+                this.active.add(waiting);
+                const waitSignal = signal ? AbortSignal.any([signal, waiting.signal]) : waiting.signal;
+                try {
+                    await new Promise((resolve, reject) => { const abort = () => { waitSignal.removeEventListener('abort', abort); reject(new ModelConfigurationError('目录查询已取消')); }; waitSignal.addEventListener('abort', abort, { once: true }); closing.promise.then(() => { }, () => { }).then(() => { waitSignal.removeEventListener('abort', abort); resolve(); }); if (waitSignal.aborted)
+                        abort(); });
+                }
+                finally {
+                    this.active.delete(waiting);
+                }
+                if (revision !== this.revision || this.get() !== api)
+                    fail('连接已改变，原模型目录已失效');
+                return this.read(agent, signal);
+            }
+            flight ??= this.start(agent, api, target, max, key);
+            flight.users++;
+            const own = flight, combined = signal ? AbortSignal.any([signal, own.controller.signal]) : own.controller.signal;
+            const assertCurrent = () => { if (combined.aborted)
+                fail('目录查询已取消'); this.assertFlight(own); };
+            const models = await new Promise((resolve, reject) => {
+                const abort = () => { combined.removeEventListener('abort', abort); reject(new ModelConfigurationError('目录查询已取消')); };
+                combined.addEventListener('abort', abort, { once: true });
+                own.promise.then(value => { combined.removeEventListener('abort', abort); resolve(value); }, error => { combined.removeEventListener('abort', abort); reject(error); });
+                if (combined.aborted)
+                    abort();
+            });
             assertCurrent();
-            const models = parseHostCatalog(output, agent.loginProvider, target.target.username);
-            const own = controller;
-            return { target, models, signal: combined, assertCurrent, release: () => this.active.delete(own) };
+            return { target: own.target, models, signal: combined, assertCurrent, release };
         }
         catch (error) {
-            if (controller)
-                this.active.delete(controller);
-            if (error instanceof LlmError)
-                throw error;
-            if (error instanceof ModelConfigurationError)
-                fail(error.message.replace(/^无法获取模型列表：/, ''));
-            fail('目录查询失败，根因未查明');
+            release();
+            const failure = this.failure(error);
+            if (!flight && !this.disposed)
+                this.diagnostic(agent.loginProvider, failure.diagnostic);
+            throw failure;
         }
     }
-    dispose() { this.disposed = true; this.unsubscribe?.(); for (const controller of this.active)
+    dispose() { this.disposed = true; this.unsubscribe?.(); this.flights.clear(); for (const controller of this.active)
         controller.abort(); this.active.clear(); }
 }
 export function modelInfo(provider, model) {
-    return { provider, id: model.id, name: model.name, inputModalities: ['text', 'image'], reasoning: { efforts: model.reasoning.options.map(option => ({ id: ReasoningEffortId(option.value), name: option.name })), ...(model.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { defaultEffort: ReasoningEffortId(model.reasoning.defaultValue) } : {}) }, catalog: model };
+    // Official rc.2 represents no reasoning levels by absence, and rejects an empty efforts array.
+    return { provider, id: model.id, name: model.name, inputModalities: ['text', 'image'], ...(model.reasoning.options.length ? { reasoning: { efforts: model.reasoning.options.map(option => ({ id: ReasoningEffortId(option.value), name: option.name })), ...(model.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { defaultEffort: ReasoningEffortId(model.reasoning.defaultValue) } : {}) } } : {}), catalog: model };
 }

package/dist/model-defaults.d.ts

@@ -0,0 +1,29 @@
+import type { AgentDefinition } from './agents.ts';
+import { type HostModel } from './model-catalog.ts';
+export interface DefaultSelection {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+/** Public agentDefaultModel service; writes below use the atomic config editor. */
+export interface DefaultModelService {
+    currentSelection(): DefaultSelection;
+}
+interface DefaultEntry {
+    options: {
+        name?: string;
+    };
+}
+/** Public rc.2 configEditor.entries/edit subset; no ownerContext/private config access. */
+export interface DefaultConfigEditor {
+    entries(): readonly DefaultEntry[];
+    edit(entry: DefaultEntry, change: (current: Record<string, unknown>, inherited: Record<string, unknown>) => Record<string, unknown>): Promise<void>;
+}
+export type DefaultSelectionWriter = (expected: DefaultSelection, next: DefaultSelection, assertCurrent: () => void) => Promise<void>;
+/** The editor invokes the guard synchronously under its profile lock after reconciliation. */
+export declare function createDefaultSelectionWriter(service: DefaultModelService, getEditor: () => DefaultConfigEditor | undefined): DefaultSelectionWriter;
+export declare function createModelDefaults(service: DefaultModelService, report: (provider: string, message: string | undefined) => void, write?: DefaultSelectionWriter): {
+    observe(agent: AgentDefinition, models: readonly HostModel[], assertCurrent?: () => void): Promise<void>;
+    dispose(): void;
+};
+export {};

package/dist/model-defaults.js

@@ -0,0 +1,62 @@
+import { declaredDefault } from "./model-catalog.js";
+const same = (a, b) => a.provider === b.provider && a.model === b.model && a.reasoningEffort === b.reasoningEffort;
+/** The editor invokes the guard synchronously under its profile lock after reconciliation. */
+export function createDefaultSelectionWriter(service, getEditor) {
+    return async (expected, next, assertCurrent) => {
+        const editor = getEditor();
+        const entries = editor?.entries().filter(entry => entry.options.name === '@deepseek-ai/dsh-agent-default-model');
+        if (!editor || entries?.length !== 1)
+            throw Error('缺少唯一可原子编辑的官方默认模型设置');
+        await editor.edit(entries[0], current => {
+            assertCurrent();
+            if (!same(expected, service.currentSelection()))
+                throw Error('员工已改变模型选择，本次默认更新已撤回');
+            const updated = { ...current, provider: next.provider, model: next.model };
+            Reflect.deleteProperty(updated, 'reasoningEffort');
+            if (next.reasoningEffort !== undefined)
+                Object.assign(updated, { reasoningEffort: next.reasoningEffort });
+            return updated;
+        });
+    };
+}
+export function createModelDefaults(service, report, write) {
+    let disposed = false, queue = Promise.resolve();
+    return {
+        observe(agent, models, assertCurrent = () => { }) {
+            const snapshot = { ...service.currentSelection() };
+            const job = queue.then(async () => {
+                if (disposed || snapshot.provider !== agent.id || !same(snapshot, service.currentSelection()))
+                    return;
+                if (snapshot.model !== 'remote' && models.some(model => model.id === snapshot.model)) {
+                    report(agent.id, undefined);
+                    return;
+                }
+                const model = declaredDefault(agent, models);
+                const notice = model ? undefined : '提供方没有声明唯一的默认模型，请先选择模型。（诊断代码：MODEL_DEFAULT_UNAVAILABLE）';
+                const next = { provider: agent.id, model: model?.id ?? '', ...(model?.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { reasoningEffort: model.reasoning.defaultValue } : {}) };
+                try {
+                    const guard = () => { assertCurrent(); if (disposed)
+                        throw Error('默认设置消费已撤回'); };
+                    guard();
+                    if (!same(snapshot, next)) {
+                        if (!write)
+                            throw Error('缺少原子配置能力');
+                        await write(snapshot, next, guard);
+                    }
+                    if (disposed)
+                        return;
+                    if (!same(next, service.currentSelection()))
+                        throw Error('未确认官方默认模型设置已保存');
+                    report(agent.id, notice);
+                }
+                catch {
+                    if (!disposed)
+                        report(agent.id, (notice ? notice + '\n' : '') + '未能确认默认模型设置已更新，员工新选择不会被迟到的自动更新覆盖；请在模型菜单选择当前目录中的模型。（诊断代码：MODEL_DEFAULT_SAVE_FAILED）');
+                }
+            });
+            queue = job;
+            return job;
+        },
+        dispose() { disposed = true; },
+    };
+}

package/dist/model-input-retention.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@deepseek-ai/cordis';
+export interface ModelInputRetentionOptions {
+    isOurProvider: (provider: string) => boolean;
+    diagnostic: (provider: string, message: string | undefined) => void;
+    diagnosticForAttempt?: (position: {
+        sessionId: string;
+        turn: number;
+        step: number;
+    }) => ((provider: string, code: string) => Promise<void>);
+    preflightDiagnostic?: (provider: string, message: string | undefined) => void;
+}
+/** Mark only at the actual X adapter's preparation catch, then rethrow the same
+ * error. One error object can prove only its first preparation, for that signal.
+ * Public request config is an intermediate proposal and is not route evidence. */
+export declare function markModelPreparationFailure(provider: string, error: unknown, signal?: AbortSignal): void;
+/**
+ * Retain a claimed human batch only after a known, undispatched metadata prepare
+ * failure. Restoration uses the public durable inbox without sending or waking
+ * the agent. This cannot cover errors before pre-step/request, or unknown core
+ * admission failures; it never manufactures transcript messages or model routes.
+ */
+export declare function installModelInputRetention(ctx: Context, options: ModelInputRetentionOptions): void;