@ai-workbench/remote-agent 0.8.2 → 0.8.5

package/dist/index.js

@@ -2,7 +2,8 @@ import { SessionId } from '@deepseek-ai/dsh-session';
 import Schema from '@deepseek-ai/schemastery';
 import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
 import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { recoveryJournal, recoveryKey } from "./recovery.js";
 import * as unstable from '@agentclientprotocol/sdk/unstable';
 import * as acp from '@agentclientprotocol/sdk';
 import { AcpSession } from "./acp.js";
@@ -17,6 +18,11 @@ import { NeedError } from "./remote.js";
 import { employeeFailure } from "./presentation.js";
 import { createRemoteDetails } from "./remote-details.js";
 import { PROVIDER_NAMES, ProviderLocaleRemote } from "./provider-locale.js";
+import { approvalLabel } from "./approval-label.js";
+import { StageTiming } from "./stage-timing.js";
+import { verifyRecoveryCheckpoint, currentInputIds } from "./recovery-checkpoint.js";
+import { ModelCatalog, modelInfo } from "./model-catalog.js";
+import { ModelConfigurationError } from "./model-configuration.js";
 export const name = 'ai-workbench-remote-agent';
 export const settingsNamespace = 'ai-workbench-codex';
 // L can be installed/enabled after X; keeping X mounted lets it explain the prerequisite.
@@ -56,11 +62,15 @@ export class CodexRemoteAdapter extends LlmAdapter {
     agent;
     readImage;
     reportLoginFailure;
+    directory;
     config;
     sessions = new Map();
     turns = new Map();
     lifetime = new AbortController();
-    constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage, reportLoginFailure) {
+    shuttingDown = false;
+    detached = new Set();
+    cleanups = new WeakMap();
+    constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage, reportLoginFailure, directory) {
         super();
         this.resolveRuntime = resolveRuntime;
         this.approve = approve;
@@ -68,23 +78,80 @@ export class CodexRemoteAdapter extends LlmAdapter {
         this.agent = agent;
         this.readImage = readImage;
         this.reportLoginFailure = reportLoginFailure;
+        this.directory = directory;
         this.config = typeof config === 'function' ? config : () => config;
     }
     providerInfo(provider) { return { id: provider, name: this.providerName() }; }
-    async listModels(provider) { return [{ provider, id: 'remote', name: this.providerName(), inputModalities: ((this.agent.oneShot && this.config().mode === 'one-shot') ? ['text'] : ['text', 'image']) }]; }
+    catalog(signal) { if (!this.directory)
+        throw new LlmError('无法获取模型列表：缺少可信主机目录能力', 'MODEL_CATALOG_UNAVAILABLE'); return this.directory.read(this.agent, signal); }
+    async listModels(provider) { const catalog = await this.catalog(); try {
+        return catalog.models.map(model => modelInfo(provider, model));
+    }
+    finally {
+        catalog.release();
+    } }
+    async resolveModel(provider, id, signal) { const catalog = await this.catalog(signal); try {
+        const model = catalog.models.find(model => model.id === id);
+        if (!model)
+            throw new LlmError('无法获取模型列表：所选模型已不在当前主机目录中', 'MODEL_CATALOG_UNAVAILABLE');
+        return modelInfo(provider, model);
+    }
+    finally {
+        catalog.release();
+    } }
+    async invalidateModelState() { for (const turn of this.turns.values())
+        turn.abort(); await Promise.all([...this.sessions.keys()].map(id => this.disposeSession(id))); }
     providerRetryPolicy() { return { mode: 'normal', maxRetries: 0, retryableCodes: [], initialDelayMs: 0, maxDelayMs: 0, jitterRatio: 0 }; }
+    cleanupRuntime(runtime) {
+        const existing = this.cleanups.get(runtime);
+        if (existing)
+            return existing;
+        const cleanup = Promise.resolve().then(() => runtime.dispose?.()).catch(() => {
+            const failure = new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '原主机会话的清理结果未确认，不能继续或重开此会话', '管理员核对并结束原主机会话');
+            for (const live of this.sessions.values())
+                if (live.runtime === runtime) {
+                    live.cleanupFailure = failure;
+                    live.failure ??= { cause: failure };
+                }
+            throw failure;
+        });
+        this.cleanups.set(runtime, cleanup);
+        return cleanup;
+    }
     async disposeSession(sessionId) {
         this.turns.get(sessionId)?.abort();
         const current = this.sessions.get(sessionId);
         if (!current)
             return;
-        this.sessions.delete(sessionId);
+        if (current.disposal)
+            return current.disposal;
         current.session.close();
-        await current.runtime.dispose?.();
+        current.disposal = this.cleanupRuntime(current.runtime).then(() => { if (this.sessions.get(sessionId) === current)
+            this.sessions.delete(sessionId); });
+        return current.disposal;
+    }
+    async detachSession(sessionId) {
+        const current = this.sessions.get(sessionId), turn = this.turns.get(sessionId);
+        if (!current && !turn)
+            return;
+        this.detached.add(sessionId);
+        if (current) {
+            try {
+                await current.runtime.detach?.();
+            }
+            finally {
+                current.session.close();
+                this.sessions.delete(sessionId);
+                turn?.abort();
+            }
+        }
+        else
+            turn?.abort();
     }
     async dispose() {
+        this.shuttingDown = true;
+        const results = await Promise.allSettled([...new Set([...this.sessions.keys(), ...this.turns.keys()])].map(id => this.detachSession(id)));
         this.lifetime.abort();
-        const results = await Promise.allSettled([...this.sessions.keys()].map(id => this.disposeSession(id)));
         const failure = results.find(result => result.status === 'rejected');
         if (failure?.status === 'rejected')
             throw failure.reason;
@@ -94,6 +161,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
             yield* this.generate(options);
         }
         catch (error) {
+            if (error instanceof ModelConfigurationError)
+                throw new LlmError(error.message, error.code, { cause: error });
             if (error instanceof NeedError) {
                 const rpc = /RPC 错误码 (-?\d+)/u.exec(error.requires)?.[1];
                 const message = employeeFailure(error.code) + (rpc ? `（技术详情：RPC 错误码 ${rpc}）` : '');
@@ -125,12 +194,16 @@ export class CodexRemoteAdapter extends LlmAdapter {
             this.turns.set(key, turn);
         const signal = AbortSignal.any([this.lifetime.signal, turn.signal, ...(original.signal ? [original.signal] : [])]);
         const options = { ...original, signal };
+        const timing = new StageTiming();
         let runtime;
         let session;
         let live;
         let succeeded = false;
         let remoteAttempted = false;
         let activeMapper;
+        let catalog;
+        let selected;
+        let modelConfiguration;
         const config = this.config();
         const mode = this.agent.oneShot ? config.mode : 'session';
         try {
@@ -139,7 +212,11 @@ export class CodexRemoteAdapter extends LlmAdapter {
             const previous = readPointer(options, this.agent);
             if (previous && previous.mode !== mode)
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '运行模式与原会话不一致，请新建会话', '原会话模式');
+            if (previous && !previous.modelConfiguration)
+                throw new NeedError('MODEL_SELECTION_REQUIRED', '旧远端恢复记录没有明确模型选择，请新建会话并选择模型', '本轮明确选择的模型');
             live = key ? this.sessions.get(key) : undefined;
+            if (live?.disposal || live?.cleanupFailure)
+                throw live.cleanupFailure ?? new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '原主机会话正在结束，清理结果尚未确认，不能继续或重开此会话', '管理员核对原主机会话清理结果');
             if (live?.failure)
                 throw new NeedError('SESSION_STATE_UNCONFIRMED', '上轮远端状态未确认，不能自动重发或重开，请新建会话并核对项目', '管理员核对原会话状态');
             if (live && !previous)
@@ -147,10 +224,11 @@ export class CodexRemoteAdapter extends LlmAdapter {
             const configuration = JSON.stringify([mode, config.acpMaxMessageBytes, config.brokerMaxFrameBytes, config.brokerControlMaxBytes]);
             if (live && live.configuration !== configuration)
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '会话运行设置已改变，请新建会话', '原会话运行设置');
-            const request = { sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, retainProcess: !!key && mode === 'session', signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) };
+            const request = { timing, acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, recoveryCheckpointId: previous?.recoveryCheckpointId, sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, retainProcess: !!key && mode === 'session', signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) };
             await this.resolveRuntime.preflight?.(request);
-            const input = await prepareInput(options, this.readImage);
+            const input = await timing.run('input-prepare', () => prepareInput(options, this.readImage));
             const contextSha256 = createHash('sha256').update(input.systemPrompt ?? '').digest('hex');
+            request.contextSha256 = contextSha256;
             if (previous && this.agent.loginProvider === 'claude' && previous.contextSha256 !== contextSha256)
                 throw new NeedError('SYSTEM_PROMPT_UPDATE_PENDING', 'Claude原会话的系统或开发者要求已变化；主机仅承诺下次上下文整理后生效，本轮未发送，请新建会话应用新要求', '新建Claude会话以立即应用当前系统与开发者要求');
             if (live) {
@@ -161,14 +239,35 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 throw new NeedError('ONESHOT_CONTEXT_REQUIRED', '首版单次模式不支持图片或系统/开发者上下文，请使用会话模式', 'Codex会话模式');
             if (mode === 'session' && Buffer.byteLength(JSON.stringify({ prompt: input.prompt, systemPrompt: input.systemPrompt }), 'utf8') > config.acpMaxMessageBytes)
                 throw new NeedError('ACP_MESSAGE_TOO_LARGE', '本轮输入超过已设置的会话消息容量，未截断或发送', '管理员调整acpMaxMessageBytes');
+            if (mode === 'one-shot')
+                throw new NeedError('MODEL_CONFIGURATION_UNSUPPORTED', '单次模式不支持确认当前模型与推理等级，请改用会话模式', '支持模型配置确认的会话模式');
+            catalog = await this.catalog(signal);
+            selected = catalog.models.find(model => model.id === options.model);
+            if (!selected)
+                throw new ModelConfigurationError('所选模型不在本次可信主机目录中，请重新选择模型');
+            if (options.reasoningEffort !== undefined && !selected.reasoning.options.some(option => option.value === options.reasoningEffort))
+                throw new ModelConfigurationError('所选推理等级不在本次模型目录中');
+            const modelSignal = AbortSignal.any([signal, catalog.signal]);
+            options.signal = modelSignal;
+            request.signal = modelSignal;
             runtime = await this.resolveRuntime(request);
             signal.throwIfAborted();
+            catalog.assertCurrent();
+            if (runtime.connection && (runtime.connection.instanceId !== catalog.target.instanceId || runtime.connection.epoch !== catalog.target.epoch) || runtime.identity !== `${catalog.target.target.username}@${catalog.target.target.host}:${catalog.target.target.port}`)
+                throw new ModelConfigurationError('模型目录与当前会话可信员工主机不一致');
             if (previous && (previous.identity !== runtime.identity || previous.cwd !== runtime.cwd || previous.bindingId && previous.bindingId !== runtime.binding?.bindingId || previous.workspaceId && previous.workspaceId !== runtime.binding?.workspaceId))
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '原会话的员工主机或工作区已改变，请新建会话', '原会话的可信目标和工作区');
+            if (runtime.restartNotice) {
+                const ids = runtime.restartInputIds;
+                if (!ids?.length || new Set(ids).size !== ids.length || ids.some(id => input.users.filter(u => u.id === id).length !== 1))
+                    throw new NeedError('CURRENT_INPUT_UNCONFIRMED', '无法核对本次输入，尚未发送给模型', '官方当前步骤的已接纳用户输入');
+                input.prompt = ids.flatMap(id => input.users.find(u => u.id === id).prompt);
+            }
             const details = runtime.details;
             if (!details)
                 throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用，请更新远程主机连接组件。', 'L技术详情持久接收能力');
-            const mapper = new StreamMapper(mode === 'session' ? (live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
+            timing.bind(detail => details.record(detail));
+            const mapper = new StreamMapper(mode === 'session' ? (runtime.restartNotice ? undefined : live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
             activeMapper = mapper;
             let id;
             let stop;
@@ -176,6 +275,10 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 yield* mapper.text(runtime.workspaceNotice.text);
                 yield* mapper.flush();
             }
+            if (runtime.restartNotice) {
+                yield* mapper.text(runtime.restartNotice + '\n\n');
+                yield* mapper.flush();
+            }
             if (mode === 'session') {
                 if (live && live.runtime !== runtime)
                     throw new NeedError('SESSION_TRANSPORT_MISMATCH', '原会话的主机通道已更换，不能自动切换进程', '原主机会话通道');
@@ -186,7 +289,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 let done = false;
                 let failure;
                 const push = (chunks) => { queue.push(...chunks); wake?.(); wake = undefined; };
-                const hooks = { broker: runtime.broker, approve: (permission, approvalSignal) => this.approve?.(permission, approvalSignal, options) ?? Promise.resolve('unavailable'), onUpdate: notification => { try {
+                const hooks = { broker: runtime.broker, timing, approve: (permission, approvalSignal) => this.approve?.(permission, approvalSignal, options) ?? Promise.resolve('unavailable'), onUpdate: notification => { try {
                         push(mapper.acp(notification.update));
                     }
                     catch (error) {
@@ -209,18 +312,47 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 }
                 const task = (async () => {
                     remoteAttempted = true;
-                    if (fresh)
-                        await session.start(runtime.cwd, previous?.sessionId, signal, { systemPrompt: input.systemPrompt });
-                    else {
-                        const updated = await session.updateContext({ systemPrompt: input.systemPrompt }, signal);
-                        if (updated && this.agent.loginProvider === 'claude')
-                            throw new NeedError('SYSTEM_PROMPT_UPDATE_PENDING', 'Claude原会话的系统或开发者要求已变化；主机仅承诺下次上下文整理后生效，本轮未发送，请新建会话应用新要求', '新建Claude会话以立即应用当前系统与开发者要求');
+                    try {
+                        if (fresh) {
+                            if (runtime.recoveredSession)
+                                session.restore(runtime.cwd, runtime.recoveredSession, { systemPrompt: input.systemPrompt });
+                            else
+                                await session.start(runtime.cwd, runtime.restartNotice ? undefined : previous?.sessionId, modelSignal, { systemPrompt: input.systemPrompt });
+                        }
+                        else {
+                            const updated = await session.updateContext({ systemPrompt: input.systemPrompt }, modelSignal);
+                            if (updated && this.agent.loginProvider === 'claude')
+                                throw new NeedError('SYSTEM_PROMPT_UPDATE_PENDING', 'Claude原会话的系统或开发者要求已变化；主机仅承诺下次上下文整理后生效，本轮未发送，请新建会话应用新要求', '新建Claude会话以立即应用当前系统与开发者要求');
+                        }
+                        catalog.assertCurrent();
+                        const actual = await session.selectModel(selected.value, options.reasoningEffort, modelSignal);
+                        catalog.assertCurrent();
+                        session.assertModelSelection(selected.value, options.reasoningEffort);
+                        let resolved = selected.resolvedModel;
+                        if (this.agent.loginProvider === 'claude') {
+                            const evidence = session.resolvedModelEvidence;
+                            if (!resolved || (selected.value !== resolved && (!evidence || evidence.modelValue !== selected.value || evidence.resolvedModel !== resolved)))
+                                throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '所选模型的具体型号未获得当前会话确认，本轮未发送', '当前会话的具体型号证据');
+                            if (evidence && evidence.resolvedModel !== resolved)
+                                throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '当前会话具体型号与所选目录不一致，本轮未发送', '完全一致的具体型号证据');
+                        }
+                        if (!resolved)
+                            throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '远端没有提供具体型号证据，本轮未发送', '具体型号证据');
+                        modelConfiguration = { selected: { ...selected, ...(options.reasoningEffort === undefined ? {} : { effort: options.reasoningEffort }) }, configured: actual, resolvedModel: resolved, status: 'remote-configured' };
+                        details.record({ kind: 'session', severity: 'info', code: 'MODEL_CONFIGURATION_CONFIRMED', summary: '本轮选择已由远端配置回执确认；不代表推理效果已验证', payload: modelConfiguration });
+                    }
+                    catch (error) {
+                        details.record({ kind: 'session', severity: 'action-required', code: 'MODEL_CONFIGURATION_FAILED', summary: '本轮模型配置未获完整确认，未发送用户输入', payload: { selected, requestedEffort: options.reasoningEffort ?? null, actual: session.modelConfiguration ?? null, reason: error instanceof NeedError ? error.code : error instanceof ModelConfigurationError ? error.message : 'MODEL_CONFIGURATION_FAILED' } });
+                        throw error;
                     }
+                    await timing.run('details-flush', () => details.flush());
                     await details.flush();
                     details.beginTurn(runtime.detailContext?.() ?? { turn: null, step: null });
+                    catalog.assertCurrent();
+                    session.assertModelSelection(selected.value, options.reasoningEffort);
                     id = session.id;
                     try {
-                        return await session.prompt(input.prompt, signal);
+                        return await session.prompt(input.prompt, modelSignal);
                     }
                     finally {
                         details.endTurn();
@@ -254,13 +386,27 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 }
             }
             details.endTurn();
-            await details.flush();
+            await timing.run('details-flush', () => details.flush());
+            await details.flush(); // The timing record is a new ordered write, not a retry.
             if (!id)
                 throw new NeedError('SESSION_ID_MISSING', '远端没有返回会话标识', '有效的远端会话标识');
             if (live)
                 live.usageSnapshot = mapper.usageSnapshot;
+            if (modelConfiguration) {
+                const actual = session.modelConfiguration;
+                if (!actual?.confirmed || actual.model !== modelConfiguration.configured.model || actual.effort !== modelConfiguration.configured.effort)
+                    throw new ModelConfigurationError('远端会话在本轮期间改变了模型配置，不能沿用旧回执');
+                catalog.assertCurrent();
+                yield* mapper.text(`\n\n本轮所选模型：${modelConfiguration.selected.name}（${modelConfiguration.selected.value}）；推理等级：${modelConfiguration.selected.effort ?? '沿用远端配置'}。远端已配置模型：${modelConfiguration.configured.model}；具体型号：${modelConfiguration.resolvedModel}；推理等级：${modelConfiguration.configured.effort ?? '远端未提供'}（配置已确认，推理效果未验证）。`);
+            }
             yield* mapper.flush();
-            const pointer = { ...(runtime.workspaceNotice ? { presentation: { workspaceNotice: runtime.workspaceNotice } } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), mode, identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
+            let recoveryCheckpointId;
+            if (session?.checkpoint && runtime.saveCheckpoint) {
+                const id = randomUUID();
+                if (await runtime.saveCheckpoint(id, session.checkpoint))
+                    recoveryCheckpointId = id;
+            }
+            const pointer = { ...(modelConfiguration ? { modelConfiguration } : {}), ...(recoveryCheckpointId ? { recoveryCheckpointId } : {}), ...(runtime.workspaceNotice ? { presentation: { workspaceNotice: runtime.workspaceNotice } } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), mode, identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
             succeeded = true;
             yield { type: 'finish', reason: { kind: stop === 'max_tokens' || stop === 'max_turn_requests' ? 'max-tokens' : 'stop' }, replayState: { response: pointer } };
         }
@@ -281,27 +427,42 @@ export class CodexRemoteAdapter extends LlmAdapter {
             throw error;
         }
         finally {
-            if (!succeeded || !key || mode !== 'session') {
-                session?.close();
-                await runtime?.dispose?.();
+            catalog?.release();
+            try {
+                if (this.shuttingDown || key && this.detached.has(key)) {
+                    session?.close();
+                    await runtime?.detach?.();
+                }
+                else if (!succeeded || !key || mode !== 'session') {
+                    session?.close();
+                    if (runtime)
+                        await this.cleanupRuntime(runtime);
+                }
+            }
+            finally {
+                if (key && this.turns.get(key) === turn)
+                    this.turns.delete(key);
+                if (key)
+                    this.detached.delete(key);
             }
-            if (key && this.turns.get(key) === turn)
-                this.turns.delete(key);
         }
     }
 }
 /** One official registration owns both routes, preserving opaque replay ownership. */
 export class RemoteAgentsAdapter extends LlmAdapter {
     adapters = new Map();
-    constructor(config, makeRuntime, approve, nameFor, readImage, reportLoginFailure) { super(); for (const agent of AGENTS)
-        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage, reportLoginFailure)); }
+    constructor(config, makeRuntime, approve, nameFor, readImage, reportLoginFailure, directory) { super(); for (const agent of AGENTS)
+        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage, reportLoginFailure, directory)); }
     adapter(provider) { const adapter = this.adapters.get(provider); if (!adapter)
         throw new LlmError('远程模型未注册', 'PROVIDER_NOT_FOUND'); return adapter; }
     providerInfo(provider) { return this.adapter(provider).providerInfo(provider); }
     listModels(provider) { return this.adapter(provider).listModels(provider); }
+    resolveModel(provider, model, signal) { return this.adapter(provider).resolveModel(provider, model, signal); }
+    async invalidateModelState() { await Promise.all([...this.adapters.values()].map(adapter => adapter.invalidateModelState())); }
     providerRetryPolicy() { return { mode: 'normal', maxRetries: 0, retryableCodes: [], initialDelayMs: 0, maxDelayMs: 0, jitterRatio: 0 }; }
     stream(options) { return this.adapter(options.provider).stream(options); }
     async disposeSession(sessionId) { await Promise.all([...this.adapters.values()].map(adapter => adapter.disposeSession(sessionId))); }
+    async detachSession(sessionId) { await Promise.all([...this.adapters.values()].map(adapter => adapter.detachSession(sessionId))); }
     async dispose() { await Promise.all([...this.adapters.values()].map(adapter => adapter.dispose())); }
 }
 export function apply(ctx, live) {
@@ -327,9 +488,17 @@ export function apply(ctx, live) {
         }
         return manager;
     };
+    let changed = () => { };
+    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, undefined, () => changed());
     const adapter = new RemoteAgentsAdapter(config, agent => connectProvider(get, { agent, notice: createWorkspaceNoticeConsumer(ctx, agent), details: async (request, api, connection, target) => {
             return managerForProfile().open({ sessionId: request.sessionId, provider: agent.loginProvider, identity: `${target.username}@${target.host}:${target.port}`, connection });
         }, open: async (...args) => {
+            const profile = ctx.get('profileContext');
+            if (!profile?.dir)
+                throw new NeedError('RECOVERY_STORAGE_REQUIRED', '会话恢复需要官方profile目录', '官方profileContext.dir');
+            args[2].recoveryJournal = recoveryJournal(profile.dir, recoveryKey([`${args[0].username}@${args[0].host}:${args[0].port}`, agent.id, args[2].sessionId]));
+            args[2].verifyRecovery = () => verifyRecoveryCheckpoint(ctx, args[2], agent.id);
+            args[2].currentInputIds = await currentInputIds(ctx, args[2]);
             const runtime = await openByAgent.get(agent.id)(...args);
             runtime.detailContext = () => {
                 const events = args[2].sessionId ? ctx.get('agents')?.get(SessionId(args[2].sessionId))?.session.snapshotEvents() : undefined;
@@ -369,17 +538,19 @@ export function apply(ctx, live) {
                 step = null;
         }
         return managerForProfile().recordLoginFailure({ sessionId, code, diagnostic, context: { turn, step } });
-    });
+    }, modelDirectory);
     const ids = AGENTS.map(agent => agent.id);
     const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: settingsNamespace, settingsPath: [] }));
     const directory = ctx.llm.registerConfigurableProviders(entries());
     const registration = ctx.llm.registerAdapter(ids, adapter);
+    changed = () => { registration.replace(ids); void adapter.invalidateModelState().catch(() => { ctx.logger('remote-agent').warn('原会话清理结果未确认，已阻断继续发送；请联系管理员核对。'); }); };
+    ctx.on('internal/service', service => { if (service === 'aiWorkbenchConnect')
+        modelDirectory.refresh(); });
     new ProviderLocaleRemote(ctx, next => { language = next; directory.replace(entries()); registration.replace(ids); });
-    const cleanup = (id) => adapter.disposeSession(id);
+    const cleanup = (id) => adapter.detachSession(id);
     ctx.on('agent/disposed', ({ agent }) => cleanup(agent.session.id));
     ctx.on('session/disposed', session => cleanup(session.id));
-    ctx.on('workspace/session-stop', ((request) => cleanup(request.sessionId)));
-    ctx.effect(() => () => adapter.dispose());
+    ctx.effect(() => () => { modelDirectory.dispose(); return adapter.dispose(); });
 }
 export function dshApproval(ctx) {
     return async (request, signal, options, context) => {
@@ -387,7 +558,9 @@ export function dshApproval(ctx) {
         const approval = ctx.get('approval');
         if (!agent || !approval)
             return 'unavailable';
-        return approval.request({ agent, toolName: request.toolCall.name ?? request.toolCall.title ?? '远端工具',
-            reason: `${context ?? '主机'} · 会话 ${request.sessionId}：${request.toolCall.title ?? request.toolCall.toolCallId}`, signal });
+        const label = approvalLabel(request);
+        if (!label)
+            return 'unavailable';
+        return approval.request({ agent, ...label, signal });
     };
 }

package/dist/input.d.ts

@@ -6,6 +6,10 @@ export type ImageReader = (ref: ImageBlock['attachment'], signal?: AbortSignal)
 }>;
 export interface PreparedInput {
     prompt: AcpContentBlock[];
+    users: {
+        id: string | undefined;
+        prompt: AcpContentBlock[];
+    }[];
     systemPrompt?: string;
 }
 /** The attachment service supplies verified bytes; client paths never cross SSH. */

package/dist/input.js

@@ -19,7 +19,9 @@ export async function prepareInput(options, readImage) {
     if (!users.length)
         throw new NeedError('INPUT_REQUIRED', '我需要本轮用户输入', '用户输入');
     const prompt = [];
+    const preparedUsers = [];
     for (const message of users) {
+        const before = prompt.length;
         for (const block of message.content) {
             options.signal?.throwIfAborted();
             if (block.type === 'text') {
@@ -42,8 +44,9 @@ export async function prepareInput(options, readImage) {
             }
             throw new NeedError('INPUT_TYPE_REQUIRED', `我需要此输入类型的远程转接能力：${block.type}`, '对应类型的公开ACP输入映射');
         }
+        preparedUsers.push({ id: message.id, prompt: prompt.slice(before) });
     }
     if (!prompt.length)
         throw new NeedError('INPUT_REQUIRED', '我需要本轮用户输入', '用户输入');
-    return { prompt, ...(context.length ? { systemPrompt: context.join('\n\n') } : {}) };
+    return { prompt, users: preparedUsers, ...(context.length ? { systemPrompt: context.join('\n\n') } : {}) };
 }

package/dist/model-catalog.d.ts

@@ -0,0 +1,55 @@
+import { type LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
+import type { ModelCatalogTarget } from '@ai-workbench/connect/api';
+import type { AgentDefinition } from './agents.ts';
+import { type ConnectApi, type ConnectTarget } from './provider.ts';
+export interface HostModel {
+    id: string;
+    value: string;
+    name: string;
+    resolvedModel: string | null;
+    reasoning: {
+        options: {
+            value: string;
+            name: string;
+        }[];
+        defaultValue: string | null;
+        defaultKnown: boolean;
+    };
+    source: unknown;
+}
+export interface CatalogLease {
+    readonly target: ModelCatalogTarget;
+    readonly models: readonly HostModel[];
+    readonly signal: AbortSignal;
+    assertCurrent(): void;
+    release(): void;
+}
+export interface ModelDirectory {
+    read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
+}
+export type CatalogRunner = (target: ConnectTarget, command: string, signal: AbortSignal, maxBytes: number) => Promise<string>;
+export declare function parseHostCatalog(input: string, provider: string, username: string): HostModel[];
+/** Only the public L sshArgs function chooses SSH trust and transport arguments. */
+export declare const runCatalog: CatalogRunner;
+/** No cache: every query binds to L's current object, host-user and generation. */
+export declare class ModelCatalog implements ModelDirectory {
+    private get;
+    private maxBytes;
+    private run;
+    private changed;
+    private api?;
+    private unsubscribe?;
+    private signature?;
+    private revision;
+    private disposed;
+    private initialized;
+    private active;
+    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void);
+    refresh(): void;
+    private trusted;
+    read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
+    dispose(): void;
+}
+export declare function modelInfo(provider: string, model: HostModel): LlmResolvedModelInfo & {
+    catalog: HostModel;
+};