@ai-workbench/remote-agent 0.8.13 → 0.8.14

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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.13",
+  "version": "0.8.14",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",