@ai-workbench/remote-agent 0.8.12 → 0.8.14

package/dist/model-catalog.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { sameTarget, validateTarget } from "./provider.js";
 import { ModelConfigurationError } from "./model-configuration.js";
@@ -92,6 +93,45 @@ export function parseHostCatalog(input, provider, username) {
     }
     return freeze(structuredClone({ models, issues }));
 }
+function changedCatalogFields(previous, next, switched) {
+    const before = previous ? JSON.parse(previous) : {}, after = JSON.parse(next), fields = [];
+    if (switched)
+        fields.push('api-instance');
+    for (const [key, label] of [['instanceId', 'connection-instance'], ['epoch', 'connection-epoch'], ['phase', 'connection-phase'], ['needCode', 'connection-need-code']])
+        if (JSON.stringify(before.state?.[key]) !== JSON.stringify(after.state?.[key]))
+            fields.push(label);
+    if (before.capability !== after.capability)
+        fields.push('catalog-capability');
+    for (const [index, label] of [[0, 'codex-target'], [1, 'claude-target']])
+        if (JSON.stringify(before.targets?.[index]) !== JSON.stringify(after.targets?.[index]))
+            fields.push(label);
+    return fields.length ? fields : ['other-metadata'];
+}
+function catalogChanges(previous, next, switched) {
+    const before = previous ? JSON.parse(previous) : {}, after = JSON.parse(next), changes = [];
+    const scalar = (value) => typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ? value : null;
+    const compare = (field, old, current) => { if (JSON.stringify(old) !== JSON.stringify(current))
+        changes.push({ field, before: scalar(old), after: scalar(current) }); };
+    const fingerprint = (value) => value === undefined ? null : createHash('sha256').update(JSON.stringify(value)).digest('hex');
+    if (switched)
+        changes.push({ field: 'catalog.api-replaced', before: false, after: true });
+    for (const [key, name] of [['instanceId', 'instance-id'], ['epoch', 'epoch'], ['phase', 'phase'], ['needCode', 'need-code']])
+        compare('connection.' + name, before.state?.[key], after.state?.[key]);
+    compare('catalog.capability', before.capability, after.capability);
+    for (const [index, provider] of [[0, 'codex'], [1, 'claude']]) {
+        const a = before.targets?.[index], b = after.targets?.[index], prefix = 'catalog.' + provider + '.';
+        compare(prefix + 'ok', a?.ok, b?.ok);
+        compare(prefix + 'error-code', a?.code, b?.code);
+        for (const [key, name] of [['instanceId', 'instance-id'], ['epoch', 'epoch'], ['provider', 'provider']])
+            compare(prefix + name, a?.value?.[key], b?.value?.[key]);
+        // Protect executable argv, trust/config paths and arbitrary future metadata: values are digests.
+        compare(prefix + 'target-sha256', fingerprint(a?.value?.target), fingerprint(b?.value?.target));
+        compare(prefix + 'metadata-sha256', fingerprint(a), fingerprint(b));
+    }
+    if (!changes.length)
+        changes.push({ field: 'catalog.signature-sha256', before: fingerprint(before), after: fingerprint(after) });
+    return changes;
+}
 /** Share only pending work; settled results are never cached. */
 export class ModelCatalog {
     get;
@@ -100,6 +140,7 @@ export class ModelCatalog {
     changed;
     diagnostic;
     loaded;
+    revoking;
     api;
     unsubscribe;
     signature;
@@ -107,16 +148,20 @@ export class ModelCatalog {
     disposed = false;
     initialized = false;
     active = new Set();
+    presentation;
+    presentationNeedCode;
+    information = new Set();
     flights = new Map();
     serial = 0;
     latest = new Map();
-    constructor(get, maxBytes, run = runCatalog, changed = () => { }, diagnostic = () => { }, loaded = () => { }) {
+    constructor(get, maxBytes, run = runCatalog, changed = () => { }, diagnostic = () => { }, loaded = () => { }, revoking = () => { }) {
         this.get = get;
         this.maxBytes = maxBytes;
         this.run = run;
         this.changed = changed;
         this.diagnostic = diagnostic;
         this.loaded = loaded;
+        this.revoking = revoking;
         this.refresh();
     }
     refresh() {
@@ -125,11 +170,19 @@ export class ModelCatalog {
         const info = api?.getContractInfo?.();
         const targets = info?.modelCatalogTarget === 1 && api?.getModelCatalogTarget ? ['codex', 'claude'].map(brand => api.getModelCatalogTarget(brand)) : undefined;
         // 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 executionState = state && { instanceId: state.instanceId, epoch: state.epoch, phase: state.phase };
         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 });
         const switched = api !== this.api;
         const changed = this.initialized && (switched || signature !== this.signature);
+        const presentation = createHash('sha256').update(JSON.stringify({ need: { code: state?.need?.code, message: state?.need?.message, requires: state?.need?.requires }, recovery: state?.recovery && { phase: state.recovery.phase, message: state.recovery.message, startedAt: state.recovery.startedAt, administratorAfterMs: state.recovery.administratorAfterMs } })).digest('hex');
+        if (this.initialized && !changed && presentation !== this.presentation) {
+            const entry = { kind: 'session', severity: 'info', code: 'CATALOG_SCOPE_INFORMATION', summary: '连接说明已变化；主机身份、连接代际和可信目标未变，本轮继续。', payload: { reason: 'CATALOG_PRESENTATION_CHANGED', before: { needCode: this.presentationNeedCode ?? null, presentationSha256: this.presentation ?? null }, after: { needCode: state?.need?.code ?? null, presentationSha256: presentation } } };
+            for (const listener of this.information)
+                listener(entry);
+        }
+        this.presentation = presentation;
+        this.presentationNeedCode = state?.need?.code;
         this.initialized = true;
         if (switched) {
             this.unsubscribe?.();
@@ -143,8 +196,10 @@ export class ModelCatalog {
             this.unsubscribe = () => { for (const stop of off)
                 stop(); };
         }
+        const changedFields = changed ? changedCatalogFields(this.signature, signature, switched) : [], changes = changed ? catalogChanges(this.signature, signature, switched) : [];
         this.signature = signature;
         if (changed) {
+            this.revoking(changedFields, changes);
             this.revision++;
             this.latest.clear();
             for (const controller of this.active)
@@ -224,8 +279,10 @@ export class ModelCatalog {
     }
     async read(agent, signal) {
         let flight, released = false;
+        const listeners = new Set();
         const release = () => { if (released || !flight)
-            return; released = true; flight.users--; if (!flight.users) {
+            return; released = true; for (const listener of listeners)
+            this.information.delete(listener); listeners.clear(); flight.users--; if (!flight.users) {
             if (flight.pending)
                 flight.controller.abort();
             else
@@ -277,7 +334,8 @@ export class ModelCatalog {
                     abort();
             });
             assertCurrent();
-            return { target: own.target, models, signal: combined, assertCurrent, release };
+            return { target: own.target, models, signal: combined, assertCurrent, release, onInformation: listener => { if (released)
+                    return () => { }; listeners.add(listener); this.information.add(listener); return () => { listeners.delete(listener); this.information.delete(listener); }; } };
         }
         catch (error) {
             release();
@@ -288,7 +346,7 @@ export class ModelCatalog {
         }
     }
     dispose() { this.disposed = true; this.unsubscribe?.(); this.flights.clear(); for (const controller of this.active)
-        controller.abort(); this.active.clear(); }
+        controller.abort(); this.active.clear(); this.information.clear(); }
 }
 export function modelInfo(provider, model) {
     // Official rc.2 represents no reasoning levels by absence, and rejects an empty efforts array.

package/dist/model-configuration.d.ts

@@ -31,17 +31,29 @@ export declare class ModelConfigurationError extends Error {
     readonly code = "MODEL_CATALOG_UNAVAILABLE";
     constructor(reason: string, options?: ErrorOptions);
 }
+export type ConfigurationInformation = 'PICKER_INCOMPLETE' | 'CONFIG_UI_METADATA_INVALID' | 'UNRELATED_CONFIG_IGNORED' | 'OPTIONAL_CATEGORY_OMITTED' | 'SAME_SELECTION_UPDATE';
+type Inform = (reason: ConfigurationInformation) => void;
+type Roles = {
+    model?: string;
+    effort?: string;
+};
 /** Pure ACP configuration state. All IDs and values come from the given peer data. */
 export declare class ModelConfiguration {
     private readonly rpcSet;
+    private readonly inform;
     private state;
     private parsed?;
     private revision;
     private busy;
-    constructor(options: SessionConfigOption[], rpcSet: ModelConfigurationSetter);
+    private known;
+    constructor(options: SessionConfigOption[], rpcSet: ModelConfigurationSetter, inform?: Inform, routing?: Roles);
     get models(): readonly ModelCatalogValue[];
     get snapshot(): ModelConfigurationSnapshot;
+    private prepare;
+    private apply;
     update(options: SessionConfigOption[]): void;
+    /** A different ACP session cannot inherit selector-role discovery or ACKs. */
+    invalidate(clearRoles?: boolean): void;
     private fail;
     private checkAckRevision;
     private set;
@@ -49,3 +61,4 @@ export declare class ModelConfiguration {
     /** Call immediately before prompt; an idle/new/load/resume update withdraws the ACK. */
     assertSelection(model: string, effort?: string): void;
 }
+export {};

package/dist/model-configuration.js

@@ -6,86 +6,103 @@ export class ModelConfigurationError extends Error {
     }
 }
 function unavailable(reason) { throw new ModelConfigurationError(reason); }
-function record(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
+function record(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }
 function text(value) { return typeof value === 'string' && value.trim().length > 0; }
-function label(value) {
-    if (!text(value.name))
-        unavailable('配置名称为空或无效');
-    if (value.description !== undefined && value.description !== null && typeof value.description !== 'string')
-        unavailable('配置说明无效');
+function label(value, inform) {
+    if (!text(value.name) || value.description !== undefined && value.description !== null && typeof value.description !== 'string')
+        inform('CONFIG_UI_METADATA_INVALID');
 }
-function select(option) {
-    if (!text(option.currentValue) || !Array.isArray(option.options) || !option.options.length)
-        unavailable('选择器缺少实际当前值或可选列表');
-    const values = [];
-    const seen = new Set();
+/** Picker entries are presentation, not an exhaustive list of legal setter values. */
+function select(option, inform) {
+    if (option.type !== 'select' || !text(option.currentValue))
+        unavailable('模型或推理配置没有有效的选择器与实际当前值');
+    const values = [], seen = new Set(), groups = new Set();
+    let flat = false, grouped = false;
     const add = (value) => {
-        if (!record(value) || !text(value.value) || 'group' in value || 'options' in value)
-            unavailable('可选值格式无效');
-        label(value);
+        if (!record(value) || !text(value.value)) {
+            inform('CONFIG_UI_METADATA_INVALID');
+            return;
+        }
+        label(value, inform);
         if (seen.has(value.value))
-            unavailable('选择器包含重复可选值');
+            inform('CONFIG_UI_METADATA_INVALID');
         seen.add(value.value);
-        values.push({ value: value.value, name: value.name, ...(value.description === undefined ? {} : { description: value.description }) });
+        values.push({ value: value.value, name: typeof value.name === 'string' ? value.name : '', ...(typeof value.description === 'string' || value.description === null ? { description: value.description } : {}) });
     };
-    const grouped = record(option.options[0]) && 'group' in option.options[0];
-    const groups = new Set();
-    for (const entry of option.options) {
-        if (grouped) {
-            if (!record(entry) || !text(entry.group) || 'value' in entry || !Array.isArray(entry.options) || !entry.options.length)
-                unavailable('分组选择器格式无效或分组为空');
-            label(entry);
-            if (groups.has(entry.group))
-                unavailable('选择器包含重复分组标识');
-            groups.add(entry.group);
-            for (const value of entry.options)
-                add(value);
+    if (!Array.isArray(option.options) || !option.options.length)
+        inform('PICKER_INCOMPLETE');
+    else
+        for (const entry of option.options) {
+            if (record(entry) && 'group' in entry) {
+                grouped = true;
+                if (flat)
+                    inform('CONFIG_UI_METADATA_INVALID');
+                if (typeof entry.group !== 'string' || groups.has(entry.group))
+                    inform('CONFIG_UI_METADATA_INVALID');
+                if (typeof entry.group === 'string')
+                    groups.add(entry.group);
+                label(entry, inform);
+                if (!Array.isArray(entry.options)) {
+                    inform('CONFIG_UI_METADATA_INVALID');
+                    continue;
+                }
+                if (!entry.options.length)
+                    inform('PICKER_INCOMPLETE');
+                for (const value of entry.options)
+                    add(value);
+            }
+            else {
+                flat = true;
+                if (grouped)
+                    inform('CONFIG_UI_METADATA_INVALID');
+                add(entry);
+            }
         }
-        else
-            add(entry);
-    }
     if (!seen.has(option.currentValue))
-        unavailable('实际当前值不在远端可选列表中');
+        inform('PICKER_INCOMPLETE');
     return { id: option.id, currentValue: option.currentValue, values };
 }
-function parse(options) {
+function parse(options, known, inform) {
     if (!Array.isArray(options) || !options.length)
-        unavailable('远端没有提供完整配置列表');
-    const ids = new Set();
-    const models = [];
-    const efforts = [];
-    for (const option of options) {
-        if (!record(option) || !text(option.id))
-            unavailable('配置标识为空或无效');
-        label(option);
-        if (ids.has(option.id))
-            unavailable('配置列表包含重复标识');
-        ids.add(option.id);
-        if (option.category !== undefined && option.category !== null && typeof option.category !== 'string')
-            unavailable('配置类别无效');
-        if (option.type === 'select') {
-            const selector = select(option);
-            if (option.category === 'model')
-                models.push(selector);
-            if (option.category === 'thought_level')
-                efforts.push(selector);
+        unavailable('远端没有提供可核对的模型配置入口');
+    const entries = options.filter(record), counts = new Map();
+    for (const option of entries) {
+        label(option, inform);
+        if (text(option.id))
+            counts.set(option.id, (counts.get(option.id) ?? 0) + 1);
+    }
+    const role = (category, id, required) => {
+        let candidates = entries.filter(option => option.category === category);
+        const known = id ? entries.filter(option => option.id === id) : [];
+        if (known.length) {
+            if (candidates.some(option => option.id !== id))
+                unavailable('同一会话的模型或推理配置入口存在冲突，不能改用另一个入口的值作回执');
+            candidates = known;
+            if (known[0].category !== category)
+                inform('OPTIONAL_CATEGORY_OMITTED');
         }
-        else if (option.type === 'boolean') {
-            if (typeof option.currentValue !== 'boolean')
-                unavailable('布尔配置当前值无效');
-            if (option.category === 'model' || option.category === 'thought_level')
-                unavailable('模型或推理等级配置不是选择器');
+        if (candidates.length !== 1) {
+            if (!required && !candidates.length)
+                return;
+            unavailable(candidates.length ? '模型或推理配置入口不唯一' : '没有可靠的模型配置入口，不能猜测配置标识');
         }
-        else
-            unavailable('配置类型无法识别');
-    }
-    if (models.length !== 1)
-        unavailable(models.length ? '模型选择器不唯一' : '没有可识别的模型选择器');
-    if (efforts.length > 1)
-        unavailable('推理等级选择器不唯一');
-    return { model: models[0], effort: efforts[0] };
+        const option = candidates[0];
+        if (!text(option.id) || (counts.get(option.id) ?? 0) !== 1)
+            unavailable('模型或推理配置标识无效或重复');
+        return select(option, inform);
+    };
+    const model = role('model', known.model, true), effort = role('thought_level', known.effort, false);
+    if (model.id === effort?.id)
+        unavailable('模型和推理等级不能共用同一个配置入口');
+    for (const option of options)
+        if (!record(option) || option.id !== model.id && option.id !== effort?.id) {
+            if (!record(option) || !text(option.id) || !['select', 'boolean'].includes(option.type))
+                inform('UNRELATED_CONFIG_IGNORED');
+        }
+    return { model, effort };
+}
+function sameSelection(a, b) {
+    return !!a && !!b && a.model.id === b.model.id && a.model.currentValue === b.model.currentValue && a.effort?.id === b.effort?.id && a.effort?.currentValue === b.effort?.currentValue;
 }
 function freeze(value, seen = new WeakSet()) {
     if (value !== null && typeof value === 'object' && !seen.has(value)) {
@@ -99,12 +116,17 @@ function freeze(value, seen = new WeakSet()) {
 /** Pure ACP configuration state. All IDs and values come from the given peer data. */
 export class ModelConfiguration {
     rpcSet;
+    inform;
     state;
     parsed;
     revision = 0;
     busy = false;
-    constructor(options, rpcSet) {
+    known = {};
+    constructor(options, rpcSet, inform = () => { }, routing) {
         this.rpcSet = rpcSet;
+        this.inform = inform;
+        if (routing)
+            this.known = { ...routing };
         this.update(options);
     }
     get models() {
@@ -113,30 +135,36 @@ export class ModelConfiguration {
         return this.state.models;
     }
     get snapshot() { return this.state; }
+    prepare(options) {
+        const copy = structuredClone(options), parsed = parse(copy, this.known, this.inform);
+        return { copy: copy, parsed };
+    }
+    apply({ copy, parsed }) {
+        const same = sameSelection(this.parsed, parsed), confirmed = same && this.state?.confirmed === true;
+        if (!same)
+            this.revision++;
+        else
+            this.inform('SAME_SELECTION_UPDATE');
+        this.parsed = parsed;
+        this.known = { model: parsed.model.id, ...parsed.effort ? { effort: parsed.effort.id } : {} };
+        this.state = freeze({ configOptions: copy, models: parsed.model.values, modelConfigId: parsed.model.id, model: parsed.model.currentValue,
+            ...(parsed.effort ? { effortConfigId: parsed.effort.id, effort: parsed.effort.currentValue } : {}), effortAvailable: !!parsed.effort, confirmed });
+    }
     update(options) {
-        this.revision++;
-        let copy = [];
         try {
-            // The wire is JSON data; clone before validation so caller mutations cannot race ACK checks.
-            const copied = structuredClone(options);
-            if (Array.isArray(copied))
-                copy = copied;
-            const parsed = parse(copied);
-            this.parsed = parsed;
-            this.state = freeze({
-                configOptions: copy, models: parsed.model.values,
-                modelConfigId: parsed.model.id, model: parsed.model.currentValue,
-                ...(parsed.effort ? { effortConfigId: parsed.effort.id, effort: parsed.effort.currentValue } : {}),
-                effortAvailable: !!parsed.effort, confirmed: false,
-            });
+            this.apply(this.prepare(options));
         }
         catch (cause) {
             const error = cause instanceof ModelConfigurationError ? cause : new ModelConfigurationError('配置数据无法复制或解析', { cause });
+            this.revision++;
             this.parsed = undefined;
-            this.state = freeze({ configOptions: copy, models: [], effortAvailable: false, confirmed: false, failure: { code: error.code, message: error.message } });
+            this.state = freeze({ configOptions: [], models: [], effortAvailable: false, confirmed: false, failure: { code: error.code, message: error.message } });
             throw error;
         }
     }
+    /** A different ACP session cannot inherit selector-role discovery or ACKs. */
+    invalidate(clearRoles = true) { if (clearRoles)
+        this.known = {}; this.update([]); }
     fail(error) {
         this.state = freeze({ ...this.state, confirmed: false, failure: { code: error.code, message: error.message } });
     }
@@ -145,7 +173,7 @@ export class ModelConfiguration {
             unavailable(`${stage}回执之后收到其他配置更新，原选择未获确认`);
     }
     async set(id, value, stage) {
-        const revision = this.revision;
+        const revision = this.revision, modelId = this.parsed?.model.id, effortId = this.parsed?.effort?.id;
         let response;
         try {
             response = await this.rpcSet(id, value);
@@ -153,11 +181,16 @@ export class ModelConfiguration {
         catch (cause) {
             throw new ModelConfigurationError(`${stage}配置请求失败，未获得远端确认`, { cause });
         }
-        if (revision !== this.revision)
-            unavailable(`${stage}配置请求期间收到其他配置更新，无法确认回执顺序`);
         if (!record(response) || !Array.isArray(response.configOptions))
             unavailable(`${stage}配置回执缺少完整配置列表`);
-        this.update(response.configOptions);
+        const prepared = this.prepare(response.configOptions);
+        if (prepared.parsed.model.id !== modelId || stage === '推理等级' && prepared.parsed.effort && prepared.parsed.effort.id !== effortId)
+            unavailable('配置回执改用了其他入口，原请求没有得到确认');
+        // Notifications can precede their own setter ACK. Only a conflicting real
+        // selection, rather than unrelated/same-value UI updates, invalidates it.
+        if (revision !== this.revision && !sameSelection(this.parsed, prepared.parsed))
+            unavailable(`${stage}配置请求期间收到不同的实际配置，无法确认回执顺序`);
+        this.apply(prepared);
         return this.revision;
     }
     async select(model, effort) {
@@ -169,7 +202,7 @@ export class ModelConfiguration {
             if (!this.parsed)
                 unavailable('当前远端配置列表无效');
             if (!this.parsed.model.values.some(entry => entry.value === model))
-                unavailable('所选模型不在实际远端列表中');
+                this.inform('PICKER_INCOMPLETE');
             let ackRevision = await this.set(this.parsed.model.id, model, '模型');
             this.checkAckRevision(ackRevision, '模型');
             if (this.state.model !== model)
@@ -179,7 +212,7 @@ export class ModelConfiguration {
                 if (!selector)
                     unavailable('远端没有提供实际推理等级选择器');
                 if (!selector.values.some(entry => entry.value === effort))
-                    unavailable('所选推理等级不在模型回执的实际列表中');
+                    this.inform('PICKER_INCOMPLETE');
                 ackRevision = await this.set(selector.id, effort, '推理等级');
                 this.checkAckRevision(ackRevision, '推理等级');
                 if (this.state.model !== model)

package/dist/presentation.js

@@ -17,7 +17,7 @@ export function employeeFailure(code, brand = 'codex') {
         TECHNICAL_DETAILS_UNAVAILABLE: '技术详情暂不可用，请更新远程主机连接组件。',
         REMOTE_DETAIL_STORAGE_FAILED: '技术详情保存失败，本轮已停止，请联系管理员检查。',
         REMOTE_DETAIL_DELIVERY_UNKNOWN: '技术详情的持久结果无法核对，本轮已停止。',
-        REMOTE_DETAIL_SCOPE_INVALID: '无法核对当前会话的技术详情，本轮已停止；我需要更新后的远程主机连接组件。',
+        REMOTE_DETAIL_SCOPE_INVALID: '无法核对本次输入与当前会话的关联，本轮已停止；请联系管理员核对技术详情。',
         EMPLOYEE_CONTEXT_UNAVAILABLE: '我需要远程主机连接组件提供当前本机工作区，本轮未执行。',
         EMPLOYEE_ENDPOINT_UNAVAILABLE: '我需要员工电脑的执行连接就绪，本轮未执行；请联系管理员检查连接组件。',
         EMPLOYEE_CONTEXT_CHANGED: '本机文件夹或连接已改变，原工具已停止；请在当前工作区重新开始。',
@@ -61,8 +61,9 @@ export function employeeFailure(code, brand = 'codex') {
         ACP_CLIENT_LOST: '我需要管理员核对并结束遗留的主机会话；当前保留原进程，没有代答旧审批。',
         ONESHOT_CONTEXT_REQUIRED: '首版单次模式不支持图片或系统与开发者上下文，请改用会话模式。',
         MODEL_CONFIGURATION_UNSUPPORTED: '单次模式不支持确认当前模型与推理等级，本轮未发送；请改用会话模式。',
+        INPUT_DELIVERY_UNCONFIRMED: '上一轮输入的处理结果尚未确认；没有自动重发，你的原话仍保留，请先核对技术详情。',
         MODEL_SELECTION_REQUIRED: '旧远端恢复记录没有明确模型选择，本轮未发送；请新建会话并选择模型。',
-        MODEL_RESOLUTION_UNCONFIRMED: '所选模型的具体型号尚未获得当前会话确认，本轮未发送；请重新选择模型或联系管理员。',
+        MODEL_RESOLUTION_UNCONFIRMED: '主机目录尚未给出所选模型的唯一具体型号，本轮未发送；你的原话仍保留，请联系管理员核对模型目录。',
         REMOTE_CLEANUP_UNCONFIRMED: '原主机会话的清理结果尚未确认，已阻断继续发送；请联系管理员核对，不能自动重开。',
     };
     if (messages[code])

package/dist/provider.d.ts

@@ -1,3 +1,4 @@
+import type { CloseCause, CloseDiagnostics } from './close-diagnostics.ts';
 import type { AgentApp } from '@agentclientprotocol/sdk';
 import type { AgentApp as ExtendedAgentApp } from '@agentclientprotocol/sdk/unstable';
 import type { ConnectState, ConnectNeed, ConnectApi as LConnectApi, ConnectionState, LoginPromptState } from '@ai-workbench/connect/api';
@@ -36,7 +37,7 @@ export interface Runtime {
     broker?: BrokerTransport;
     oneShot?: OneShotRuntime;
     loginRequired?: () => Promise<void>;
-    dispose?: () => Promise<void>;
+    dispose?: (cause?: CloseCause) => Promise<void>;
     binding?: {
         bindingId: string;
         workspaceId: string;
@@ -47,8 +48,9 @@ export interface Runtime {
     details?: DetailChannel;
     recoveredSession?: AcpRecovery;
     restartNotice?: string;
-    detach?: () => Promise<void>;
+    detach?: (cause?: CloseCause) => Promise<void>;
     restartInputIds?: readonly string[];
+    freshSessionConfirmed?: boolean;
     saveCheckpoint?: (id: string, acp: AcpRecovery) => Promise<boolean>;
     detailContext?: () => {
         turn: string | number | null;
@@ -63,8 +65,12 @@ export interface Runtime {
     };
     employeeExecution?: (params: unknown, signal?: AbortSignal) => Promise<Record<string, unknown>>;
     employeePresentation?: string;
+    closeDiagnostics?: CloseDiagnostics;
 }
 export interface RuntimeRequest extends Invocation {
+    closeDiagnostics?: CloseDiagnostics;
+    requireFreshSession?: boolean;
+    previousContextSha256?: string;
     preflightFailureRecorded?: boolean;
     recordEarlyFailure?: (error: unknown, stage: SourceAdmissionStage) => Promise<void>;
     userInputIds?: readonly string[];

package/dist/recovery.d.ts

@@ -4,6 +4,10 @@ export interface AcpRecovery {
     capabilities: AgentCapabilities;
     modelConfiguration?: {
         configOptions: SessionConfigOption[];
+        selectorRoles?: {
+            model?: string;
+            effort?: string;
+        };
         resolvedEvidence?: {
             modelValue: string;
             resolvedModel: string;

package/dist/rpc-namespace.d.ts

@@ -1,3 +1,3 @@
-import type { Stream } from '@agentclientprotocol/sdk/unstable';
+import type { Stream, AnyMessage } from '@agentclientprotocol/sdk/unstable';
 /** Public Stream only. Server request/approval IDs are never changed. */
-export declare function isolateRpcIds(stream: Stream): Stream;
+export declare function isolateRpcIds(stream: Stream, onWrite?: (message: AnyMessage) => void): Stream;

package/dist/rpc-namespace.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { NeedError } from "./remote.js";
 /** Public Stream only. Server request/approval IDs are never changed. */
-export function isolateRpcIds(stream) {
+export function isolateRpcIds(stream, onWrite) {
     const prefix = randomUUID() + '/';
     const pending = new Map();
     const readable = stream.readable.pipeThrough(new TransformStream({ transform(message, controller) {
@@ -30,6 +30,7 @@ export function isolateRpcIds(stream) {
             }
             const writer = stream.writable.getWriter();
             try {
+                onWrite?.(outgoing);
                 await writer.write(outgoing);
             }
             finally {

package/dist/session-header.d.ts

@@ -0,0 +1,4 @@
+import type { SessionHeader } from '@deepseek-ai/dsh-session';
+/** Only a persisted/live representation comparison. Live lifecycle fences still
+ * compare their original header exactly. Official JSONL stores omitted depth as 0. */
+export declare function sameStoredSessionHeader(a: SessionHeader, b: SessionHeader): boolean;

package/dist/session-header.js

@@ -0,0 +1,12 @@
+import { isDeepStrictEqual } from 'node:util';
+/** Only a persisted/live representation comparison. Live lifecycle fences still
+ * compare their original header exactly. Official JSONL stores omitted depth as 0. */
+export function sameStoredSessionHeader(a, b) {
+    const depth = (header) => !Object.hasOwn(header, 'delegationDepth') ? 0 :
+        typeof header.delegationDepth === 'number' && Number.isSafeInteger(header.delegationDepth) && header.delegationDepth >= 0 && !Object.is(header.delegationDepth, -0) ? header.delegationDepth : undefined;
+    const left = depth(a), right = depth(b);
+    if (left === undefined || right === undefined)
+        return false;
+    const normalized = (header, value) => Object.setPrototypeOf({ ...header, delegationDepth: value }, Object.getPrototypeOf(header));
+    return isDeepStrictEqual(normalized(a, left), normalized(b, right));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.12",
+  "version": "0.8.14",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,7 +39,7 @@
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.18.tgz",
+    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.19.tgz",
     "@ai-workbench/network": "file:test/fixtures/ai-workbench-network-0.4.4.tgz",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/cordis-plugin-group": "1.0.4",
@@ -68,7 +68,7 @@
     "zustand": "4.4.7"
   },
   "peerDependencies": {
-    "@ai-workbench/connect": "~0.7.18",
+    "@ai-workbench/connect": "~0.7.19",
     "@ai-workbench/network": "~0.4.4",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/dsh-agent": "0.2.0-rc.2",