@ai-workbench/remote-agent 0.8.25 → 0.8.27

package/README.md

@@ -1,4 +1,4 @@
-# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.25 · 插件 → 添加插件
+# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.27 · 插件 → 添加插件
 
 通过官方 DSH 插件入口使用 Claude（远程主机）与 Codex（远程主机）。登录和工作区来源由“远程主机连接”组件提供；员工在原生工作区和模型菜单中选择文件夹与型号。
 
@@ -6,6 +6,10 @@
 
 需要远程主机连接组件 0.7.29 或更新的 0.7.x，以及联网助手 0.4.9。主机来源保存于官方 storage.domain 的会话元数据表，每轮仅由连接组件检查一次主机目录，不检查本机占位目录。
 
+Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交给模型当作命令输出；真实传输中断仍提示结果未知。命令自身的标准输出、标准错误与退出码照常返回。
+
+模型列表读取会随连接状态或连接代际变化取消，连接恢复时通过官方机制刷新。目录失败原因写入当前 profile 的 `ai-workbench-remote-agent/logs/model-catalog.jsonl`（脱敏）；未增加单次读取时限或重试。
+
 ## 会话行为
 
 每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。主机会话始终使用创建时保存的主机和目录；工作区之后的选择只影响新会话。

package/dist/catalog-ssh.d.ts

@@ -14,7 +14,8 @@ export interface CatalogSshEvent {
 export declare function catalogSafeText(value: string): string;
 export declare class CatalogSshError extends ModelConfigurationError {
     readonly event: CatalogSshEvent;
-    constructor(reason: string, event: CatalogSshEvent);
+    private readonly stderr;
+    constructor(reason: string, event: CatalogSshEvent, stderr?: string);
     get diagnostic(): string;
 }
 export type CatalogSshObserver = (event: Readonly<CatalogSshEvent>) => void | Promise<void>;

package/dist/catalog-ssh.js

@@ -49,11 +49,13 @@ export function catalogSafeText(value) {
 }
 export class CatalogSshError extends ModelConfigurationError {
     event;
-    constructor(reason, event) {
+    stderr;
+    constructor(reason, event, stderr = '') {
         super(reason);
         this.event = event;
+        this.stderr = stderr;
     }
-    get diagnostic() { return '目录连接技术详情：' + JSON.stringify(this.event); }
+    get diagnostic() { return '目录连接技术详情：' + JSON.stringify(this.event) + (this.stderr ? '\nSSH诊断：' + this.stderr : ''); }
 }
 /** Each query starts a fresh strict L SSH invocation. No connection pool or retry. */
 export async function runCatalog(target, command, signal, maxBytes, observe) {
@@ -76,10 +78,12 @@ export async function runCatalog(target, command, signal, maxBytes, observe) {
     return new Promise((resolve, reject) => {
         const child = spawn('ssh', argv, { stdio: ['ignore', 'pipe', 'pipe'] });
         const output = [], diagnostics = [];
-        let total = 0, stdoutBytes = 0, stderrBytes = 0, processErrorCode = null, failure;
-        const abort = () => { failure ??= { code: 'MODEL_CATALOG_CANCELLED', reason: '连接已改变或目录查询已取消' }; child.kill('SIGTERM'); };
+        let settled = false, total = 0, stdoutBytes = 0, stderrBytes = 0, processErrorCode = null, failure;
+        const abort = () => { failure ??= { code: 'MODEL_CATALOG_CANCELLED', reason: '连接已变化或读取已取消；连接恢复后请重新打开模型菜单。' }; child.kill('SIGTERM'); complete(null, null); };
         signal.addEventListener('abort', abort, { once: true });
         const receive = (buffer, stdout) => {
+            if (settled)
+                return;
             if (stdout)
                 stdoutBytes += buffer.length;
             else
@@ -88,46 +92,49 @@ export async function runCatalog(target, command, signal, maxBytes, observe) {
             if (failure)
                 return;
             if (total > maxBytes) {
-                failure = { code: 'MODEL_CATALOG_OUTPUT_LIMIT', reason: '目录响应超过 acpMaxMessageBytes，未截断返回' };
+                failure = { code: 'MODEL_CATALOG_OUTPUT_LIMIT', reason: '主机返回的模型列表过大，暂时无法显示；请联系管理员检查后重新打开模型菜单。' };
                 child.kill('SIGTERM');
+                complete(null, null);
                 return;
             }
             (stdout ? output : diagnostics).push(buffer);
         };
         child.stdout.on('data', (b) => receive(b, true));
         child.stderr.on('data', (b) => receive(b, false));
-        child.on('error', (error) => { processErrorCode = typeof error.code === 'string' && /^[A-Z0-9_]+$/.test(error.code) ? error.code : 'SSH_SPAWN_FAILED'; failure ??= { code: processErrorCode, reason: '可信 SSH 进程启动失败' }; });
-        child.once('close', (code, closeSignal) => {
-            void (async () => {
-                signal.removeEventListener('abort', abort);
-                let value = '', typed = false;
-                try {
-                    value = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(output));
-                }
-                catch {
-                    failure ??= { code: 'MODEL_CATALOG_UTF8_INVALID', reason: '主机目录响应不是有效 UTF-8，未替换模型值' };
-                }
-                try {
-                    typed = JSON.parse(value)?.ok === false;
-                }
-                catch { }
-                if (!failure && code !== 0 && !typed)
-                    failure = { code: 'SSH_EXIT_NONZERO', reason: '模型列表暂时无法读取，请检查连接后重新打开模型菜单。' };
-                const final = { provider, exitCode: code ?? null, signal: closeSignal ?? null, stdoutBytes, stderrBytes, elapsedMs: performance.now() - tick, failureCode: failure?.code ?? null, processErrorCode };
-                console.info('[remote-agent] model-list ' + provider + ' exit=' + final.exitCode + ' bytes=' + stdoutBytes + ' elapsedMs=' + final.elapsedMs.toFixed(1));
-                try {
-                    void Promise.resolve(observe?.(final)).catch(() => console.warn('[remote-agent] 模型列表查询日志未保存'));
-                }
-                catch {
-                    console.warn('[remote-agent] 模型列表查询日志未保存');
-                }
-                if (failure) {
-                    reject(new CatalogSshError(failure.reason, final));
-                    return;
-                }
-                resolve(value);
-            })().catch(reject);
-        });
+        child.on('error', (error) => { processErrorCode = typeof error.code === 'string' && /^[A-Z0-9_]+$/.test(error.code) ? error.code : 'SSH_SPAWN_FAILED'; failure ??= { code: processErrorCode, reason: '连接程序未能启动，暂时读不到模型列表；请从远程主机连接检查组件后重新打开模型菜单。' }; complete(null, null); });
+        const complete = (code, closeSignal) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', abort);
+            let value = '', typed = false;
+            try {
+                value = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(output));
+            }
+            catch {
+                failure ??= { code: 'MODEL_CATALOG_UTF8_INVALID', reason: '主机返回的模型列表内容损坏，暂时无法读取；请联系管理员检查后重新打开模型菜单。' };
+            }
+            try {
+                typed = JSON.parse(value)?.ok === false;
+            }
+            catch { }
+            if (!failure && code !== 0 && !typed)
+                failure = { code: 'SSH_EXIT_NONZERO', reason: '模型列表暂时无法读取，请检查远程主机连接后重新打开模型菜单。' };
+            const final = { provider, exitCode: code ?? null, signal: closeSignal ?? null, stdoutBytes, stderrBytes, elapsedMs: performance.now() - tick, failureCode: failure?.code ?? null, processErrorCode };
+            console.info('[remote-agent] model-list ' + provider + ' exit=' + final.exitCode + ' bytes=' + stdoutBytes + ' elapsedMs=' + final.elapsedMs.toFixed(1));
+            try {
+                void Promise.resolve(observe?.(final)).catch(() => console.warn('[remote-agent] 模型列表查询日志未保存'));
+            }
+            catch {
+                console.warn('[remote-agent] 模型列表查询日志未保存');
+            }
+            if (failure) {
+                reject(new CatalogSshError(failure.reason, final, catalogSafeText(Buffer.concat(diagnostics).toString('utf8'))));
+                return;
+            }
+            resolve(value);
+        };
+        child.once('close', (code, closeSignal) => complete(code, closeSignal));
         if (signal.aborted)
             abort();
     });

package/dist/employee-shell.d.ts

@@ -1,4 +1,4 @@
-import { type CloseDiagnostics } from './close-diagnostics.ts';
+import type { CloseDiagnostics } from './close-diagnostics.ts';
 import type { ChildProcessWithoutNullStreams } from 'node:child_process';
 import type { EmployeeEndpointTarget } from './employee-endpoint.ts';
 export interface EmployeeShellResult {

package/dist/employee-shell.js

@@ -1,19 +1,35 @@
-import { closeCode } from "./close-diagnostics.js";
 import { randomUUID } from 'node:crypto';
 import { EMPLOYEE_PYTHON_ERRORS } from "./employee-relay.js";
 import { NeedError } from "./remote.js";
 const SHELL_PYTHON = String.raw `
-import sys,json,subprocess,shlex
+import sys,json,subprocess,shlex,tempfile,signal,re
 def fail(code):
  sys.stderr.write(json.dumps({"code":code})+"\n");sys.exit(254)
 try:
- x=json.loads(sys.argv[1]);e=x["endpoint"];args=x["sshArgs"];cwd=x["cwd"]
+ x=json.loads(sys.argv[1]);e=x["endpoint"];args=list(x["sshArgs"]);cwd=x["cwd"]
+ proxy=[i for i,arg in enumerate(args) if arg.startswith("ProxyCommand=")]
+ if len(proxy)!=1:fail("EMPLOYEE_BRIDGE_PROTOCOL_INVALID")
  # User source is stdin, never argv. The sentinel preserves trailing newlines.
  wrapper="cd -- "+shlex.quote(cwd)+" || exit 254; "+"printf '%s\\n' "+shlex.quote('AW_EMPLOYEE_SHELL_STARTED '+x['executionId'])+" >&2; "+'aw_x_source=$(/bin/cat; printf x); aw_x_source='+chr(36)+'{aw_x_source%?}; eval "'+chr(36)+'aw_x_source"'
  command=shlex.join([e["endpointShell"],"-c",wrapper])
  sys.stderr.write("AW_EMPLOYEE_SHELL_READY "+x["executionId"]+"\n");sys.stderr.flush()
- p=subprocess.Popen(["/usr/bin/ssh","-T"]+args+[command],stdin=sys.stdin,stdout=sys.stdout,stderr=sys.stderr)
- code=p.wait();sys.exit(code if code>=0 else 255)
+ # OpenSSH inherits ProxyCommand fd2 into its combined stderr. Separate that
+ # producer before launch; never inspect/filter the employee command's bytes.
+ def interrupted(signum,frame):
+  raise SystemExit(255)
+ for sig in [signal.SIGTERM,signal.SIGHUP,signal.SIGINT]:signal.signal(sig,interrupted)
+ with tempfile.NamedTemporaryFile(prefix="aw-x-bridge-") as diagnostic:
+  # S already escaped its own percent tokens. Only escape the added path.
+  i=proxy[0];args[i]+=" 2>"+shlex.quote(diagnostic.name.replace("%","%%"))
+  p=subprocess.Popen(["/usr/bin/ssh","-T"]+args+[command],stdin=sys.stdin,stdout=sys.stdout,stderr=sys.stderr)
+  code=p.wait()
+  diagnostic.seek(0)
+  # S's raw CLI emits at most one fixed error line, never arbitrary diagnostics.
+  raw=diagnostic.read(x["maxBytes"]+1)
+  match=re.fullmatch(rb"BRIDGE_ERROR ([A-Z][A-Z0-9_]{0,63})\n",raw)
+  bridge_code=match.group(1).decode("ascii") if match else None
+  sys.stderr.write("\nAW_EMPLOYEE_BRIDGE_RESULT "+x["executionId"]+" "+json.dumps(bridge_code)+"\n");sys.stderr.flush()
+ sys.exit(code if code>=0 else 255)
 ` + EMPLOYEE_PYTHON_ERRORS;
 const unknown = (code) => new NeedError(code, '本机命令结果未知；没有重放，也未改在主机执行。', '员工端真实退出回执');
 /** Use only the target verified at this round lease opening. Cancellation cannot prove remote exit. */
@@ -22,11 +38,10 @@ export function createEmployeeShell(options) {
         signal.throwIfAborted();
         const diagnostics = options.closeDiagnostics?.child();
         const executionId = randomUUID(), target = options.target;
-        const child = await options.attach({ command: '/usr/bin/python3', args: ['-c', SHELL_PYTHON, JSON.stringify({ endpoint: target.endpoint, sshArgs: options.sshArgs, cwd: target.local.directory.path, executionId })] });
+        const child = await options.attach({ command: '/usr/bin/python3', args: ['-c', SHELL_PYTHON, JSON.stringify({ endpoint: target.endpoint, sshArgs: options.sshArgs, cwd: target.local.directory.path, executionId, maxBytes: options.maxBytes })] });
         return new Promise((yes, no) => {
             let settled = false, bytes = 0, stdout = [], stderr = [], reason, grace, timer;
-            const finish = (error, code) => {
-                diagnostics?.record({ layer: 'executor', initiator: 'shell.finish', reason: closeCode(error, 'SHELL_FINISHED'), action: 'close', exitCode: code ?? null, changes: [{ field: 'shell.settled', before: settled, after: true }] });
+            const finish = (error, code, exitSignal) => {
                 if (settled)
                     return;
                 settled = true;
@@ -39,6 +54,7 @@ export function createEmployeeShell(options) {
                 child.stdout.destroy();
                 child.stderr.destroy();
                 if (error) {
+                    diagnostics?.record({ layer: 'executor', initiator: 'shell.finish', reason: error.code, action: 'failure', exitCode: code ?? null });
                     no(error);
                     return;
                 }
@@ -51,6 +67,23 @@ export function createEmployeeShell(options) {
                     no(unknown('EMPLOYEE_OUTPUT_BINARY_UNSUPPORTED'));
                     return;
                 }
+                const trailer = '\nAW_EMPLOYEE_BRIDGE_RESULT ' + executionId + ' ', end = err.lastIndexOf(trailer);
+                let bridgeCode;
+                if (end >= 0) {
+                    try {
+                        const value = JSON.parse(err.slice(end + trailer.length));
+                        if (typeof value === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(value))
+                            bridgeCode = value;
+                        else if (value !== null)
+                            throw Error();
+                        err = err.slice(0, end);
+                    }
+                    catch {
+                        no(unknown('EMPLOYEE_EXIT_UNKNOWN'));
+                        return;
+                    }
+                }
+                diagnostics?.record({ layer: 'relay', initiator: 'shell.process-close', reason: 'PROCESS_EXIT', action: 'exit', exitCode: code ?? null, signal: exitSignal ?? null, ...bridgeCode ? { remoteReason: bridgeCode } : {} });
                 const header = 'AW_EMPLOYEE_SHELL_READY ' + executionId + '\n', started = 'AW_EMPLOYEE_SHELL_STARTED ' + executionId + '\n';
                 const start = err.indexOf(started, header.length);
                 if (!err.startsWith(header) || start < header.length || start > header.length && err[start - 1] !== '\n') {
@@ -62,11 +95,11 @@ export function createEmployeeShell(options) {
                             source = parsed.code;
                     }
                     catch { /* Never expose arbitrary transport diagnostics. */ }
-                    no(unknown(source ?? 'EMPLOYEE_EXIT_UNKNOWN'));
+                    no(unknown(bridgeCode ?? source ?? 'EMPLOYEE_EXIT_UNKNOWN'));
                     return;
                 }
-                if (code === null || code === undefined || code === 255) {
-                    no(unknown('EMPLOYEE_EXIT_UNKNOWN'));
+                if (code === null || code === undefined || code === 255 || end < 0) {
+                    no(unknown(bridgeCode ?? 'EMPLOYEE_EXIT_UNKNOWN'));
                     return;
                 }
                 yes({ stdout: out, stderr: err.slice(header.length, start) + err.slice(start + started.length), stderrSource: 'combined-ssh-and-command', exitCode: code, signal: null });
@@ -85,7 +118,7 @@ export function createEmployeeShell(options) {
             child.stderr.on('data', (b) => collect(stderr, b));
             child.stdin.on('error', () => stop('EMPLOYEE_INPUT_UNKNOWN'));
             child.once('error', () => { diagnostics?.record({ layer: 'relay', initiator: 'shell.process-error', reason: 'EMPLOYEE_TRANSPORT_UNKNOWN', action: 'failure' }); finish(unknown('EMPLOYEE_TRANSPORT_UNKNOWN')); });
-            child.once('close', (code, exitSignal) => { diagnostics?.record({ layer: 'relay', initiator: 'shell.process-close', reason: reason?.code ?? 'PROCESS_EXIT', action: 'exit', exitCode: code, signal: exitSignal }); finish(reason, code); });
+            child.once('close', (code, exitSignal) => finish(reason, code, exitSignal));
             signal.addEventListener('abort', abort, { once: true });
             if (signal.aborted)
                 abort();

package/dist/index.js

@@ -115,7 +115,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
     providerInfo(provider) { return { id: provider, name: this.providerName() }; }
     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 {
+    async listModels(provider) { const catalog = await this.catalog(this.lifetime.signal); try {
+        this.lifetime.signal.throwIfAborted();
         this.modelPresentation.remember(catalog);
         return catalog.models.map(model => modelInfo(provider, model));
     }
@@ -621,7 +622,7 @@ export function apply(ctx, live) {
     };
     // Public Loader Entry.options.id; optional when mounted without Loader.
     const actualSettingsNamespace = ctx.fiber.entry?.options.id;
-    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes);
+    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, undefined, (provider, error) => managerForProfile().recordCatalogFailure(provider, error));
     const adapter = new RemoteAgentsAdapter(config, agent => {
         const details = async (request, api, connection, target) => {
             return managerForProfile().open({ sessionId: request.sessionId, provider: agent.loginProvider, identity: `${target.username}@${target.host}:${target.port}`, connection });
@@ -689,8 +690,10 @@ export function apply(ctx, live) {
         const previous = connection;
         connection = state;
         // Official replacement invalidates the browser's shared catalog and loads it.
-        if (state.phase === 'connected' && (previous?.phase !== 'connected' || previous.instanceId !== state.instanceId || previous.epoch !== state.epoch))
+        if (previous?.phase !== state.phase || previous.instanceId !== state.instanceId || previous.epoch !== state.epoch) {
+            modelDirectory.cancelPending();
             registration.replace(ids);
+        }
     });
     installModelInputRetention(ctx, { isOurProvider: provider => ids.includes(provider), diagnosticForAttempt: position => preflightDiagnostics.forPreparation(position.sessionId, position), preflightDiagnostic: (provider, message) => diagnostic('preflight', provider, message), diagnostic: (provider, message) => diagnostic('input', provider, message) });
     const cleanup = async (id) => { try {

package/dist/model-catalog.d.ts

@@ -44,7 +44,10 @@ export declare class ModelCatalog implements ModelDirectory {
     private get;
     private maxBytes;
     private run;
-    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner);
+    private reportFailure?;
+    private pending;
+    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, reportFailure?: ((provider: "claude" | "codex", error: unknown) => void) | undefined);
+    cancelPending(): void;
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
     dispose(): void;
 }

package/dist/model-catalog.js

@@ -1,5 +1,6 @@
 import { LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { validateTarget } from "./provider.js";
+import { ModelConfigurationError } from "./model-configuration.js";
 import { runCatalog, catalogSafeText } from "./catalog-ssh.js";
 export { runCatalog } from "./catalog-ssh.js";
 const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
@@ -91,32 +92,72 @@ export class ModelCatalog {
     get;
     maxBytes;
     run;
-    constructor(get, maxBytes, run = runCatalog) {
+    reportFailure;
+    pending = new Set();
+    constructor(get, maxBytes, run = runCatalog, reportFailure) {
         this.get = get;
         this.maxBytes = maxBytes;
         this.run = run;
+        this.reportFailure = reportFailure;
+    }
+    cancelPending() {
+        for (const controller of this.pending)
+            controller.abort(new CatalogError('连接已变化，本次模型列表读取已停止；连接恢复后请重新打开模型菜单。', 'MODEL_CATALOG_CONNECTION_CHANGED'));
+        this.pending.clear();
     }
     async read(agent, signal) {
-        signal?.throwIfAborted();
-        const api = this.get();
-        if (!api || typeof api.getModelCatalogTarget !== 'function')
-            fail('远程主机连接组件没有提供模型目录');
-        const reply = api.getModelCatalogTarget(agent.loginProvider);
-        if (!reply.ok)
-            fail(reply.error.message);
-        const target = reply.value;
-        validateTarget(target.target);
         const controller = new AbortController(), combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-        const max = this.maxBytes();
-        if (!Number.isSafeInteger(max) || max < 1)
-            fail('模型目录容量设置无效');
-        const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, combined, max);
-        const parsed = parseHostCatalog(output, agent.loginProvider, target.target.username);
-        if (parsed.issues.length)
-            console.warn('[remote-agent] 模型菜单部分条目无效：' + parsed.issues.map(issue => issue.code).join(','));
-        return { target, models: parsed.models, signal: combined, release() { } };
+        let off;
+        this.pending.add(controller);
+        try {
+            combined.throwIfAborted();
+            const api = this.get();
+            if (!api || typeof api.getModelCatalogTarget !== 'function')
+                fail('远程主机连接组件尚未就绪，请等待连接恢复后重新打开模型菜单。');
+            const reply = api.getModelCatalogTarget(agent.loginProvider);
+            if (!reply.ok)
+                fail(reply.error.message);
+            const target = reply.value;
+            validateTarget(target.target);
+            off = api.onConnectionState?.(() => {
+                const state = api.getConnectionState();
+                if (state.phase !== 'connected' || state.instanceId !== target.instanceId || state.epoch !== target.epoch)
+                    controller.abort(new CatalogError('连接已变化，本次模型列表读取已停止；连接恢复后请重新打开模型菜单。', 'MODEL_CATALOG_CONNECTION_CHANGED'));
+            });
+            const max = this.maxBytes();
+            if (!Number.isSafeInteger(max) || max < 1)
+                fail('模型目录容量设置无效，请联系管理员检查插件配置。');
+            const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, combined, max);
+            combined.throwIfAborted();
+            let parsed;
+            try {
+                parsed = parseHostCatalog(output, agent.loginProvider, target.target.username);
+            }
+            catch (error) {
+                if (error instanceof CatalogError)
+                    throw new CatalogError(error.message.slice('无法获取模型列表：'.length), error.diagnostic + '\n主机响应：' + safe(output));
+                throw error;
+            }
+            if (parsed.issues.length)
+                console.warn('[remote-agent] 模型菜单部分条目无效：' + parsed.issues.map(issue => issue.code).join(','));
+            return { target, models: parsed.models, signal: combined, release() { } };
+        }
+        catch (error) {
+            const failure = signal?.aborted ? signal.reason : error instanceof CatalogError || error instanceof ModelConfigurationError ? error : new CatalogError('暂时无法读取模型列表，请检查远程主机连接后重新打开模型菜单。', safe(error instanceof Error ? error.message : String(error)));
+            try {
+                this.reportFailure?.(agent.loginProvider, failure);
+            }
+            catch {
+                console.warn('[remote-agent] 模型列表失败日志未保存');
+            }
+            throw failure;
+        }
+        finally {
+            off?.();
+            this.pending.delete(controller);
+        }
     }
-    dispose() { }
+    dispose() { this.cancelPending(); }
 }
 export function modelInfo(provider, model) {
     // Official rc.2 represents no reasoning levels by absence, and rejects an empty efforts array.

package/dist/remote-details.d.ts

@@ -50,6 +50,8 @@ export declare function createRemoteDetails(options: {
     getApi?: () => unknown;
     warn?: (line: string) => void;
 }): {
+    /** Menu failures have no Session; keep them in the same private local logs. */
+    recordCatalogFailure(provider: "claude" | "codex", error: unknown): void;
     /** Await queued best-effort writes only when releasing the profile, never before dispatch. */
     dispose(): Promise<void>;
     releaseSession(sessionId: string): void;

package/dist/remote-details.js

@@ -1,3 +1,4 @@
+import { catalogSafeText } from "./catalog-ssh.js";
 import { closeCode } from "./close-diagnostics.js";
 import { randomUUID, createHash } from 'node:crypto';
 import { constants } from 'node:fs';
@@ -74,6 +75,14 @@ export function createRemoteDetails(options) {
         return { eventId };
     }
     return {
+        /** Menu failures have no Session; keep them in the same private local logs. */
+        recordCatalogFailure(provider, error) {
+            const reason = error instanceof Error ? error.message : typeof error === 'string' ? error : '模型目录查询失败';
+            const diagnostic = error && typeof error === 'object' && 'diagnostic' in error && typeof error.diagnostic === 'string' ? error.diagnostic : reason;
+            const line = { version: 1, at: new Date().toISOString(), provider, code: 'MODEL_CATALOG_UNAVAILABLE', message: catalogSafeText(reason), diagnostic: catalogSafeText(diagnostic) };
+            writes = writes.then(async () => { if (!root)
+                throw failure('DIAGNOSTIC_CONTEXT_UNAVAILABLE'); await privateDirectory(join(root, '..')); await privateDirectory(root); await appendFile(join(root, 'model-catalog.jsonl'), JSON.stringify(line) + '\n', { mode: 0o600, flag: constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW }); }).catch(warn);
+        },
         /** Await queued best-effort writes only when releasing the profile, never before dispatch. */
         async dispose() { await writes; memory.clear(); },
         releaseSession(sessionId) { for (const provider of ['claude', 'codex'])

package/package.json

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