@ai-workbench/remote-agent 0.8.2 → 0.8.10

package/dist/input.d.ts

@@ -4,9 +4,24 @@ export type ImageReader = (ref: ImageBlock['attachment'], signal?: AbortSignal)
     ref: ImageBlock['attachment'];
     data: Uint8Array;
 }>;
+export interface HistoryTransfer {
+    scope: 'visible-user-assistant-text-and-images';
+    textBlocks: number;
+    imageBlocks: number;
+    offloadedImagePlaceholders: number;
+    omittedReasoningBlocks: number;
+    reasoningOmissionReason: 'dsh-internal-reasoning';
+}
 export interface PreparedInput {
     prompt: AcpContentBlock[];
+    users: {
+        id: string | undefined;
+        prompt: AcpContentBlock[];
+    }[];
     systemPrompt?: string;
+    historyTransfer?: HistoryTransfer;
 }
+/** Role-labelled public history only; never serialize source/replay/tool internals. */
+export declare function prepareContinuation(options: GenerateOptions, input: PreparedInput, readImage?: ImageReader): Promise<PreparedInput>;
 /** The attachment service supplies verified bytes; client paths never cross SSH. */
 export declare function prepareInput(options: GenerateOptions, readImage?: ImageReader): Promise<PreparedInput>;

package/dist/input.js

@@ -1,5 +1,59 @@
 import { NeedError } from "./remote.js";
 import { isWorkspaceNoticeMessage, withoutWorkspaceNotice } from "./workspace-notice.js";
+async function publicBlock(block, options, readImage, history = false) {
+    options.signal?.throwIfAborted();
+    if (block.type === 'text')
+        return { type: 'text', text: block.text };
+    if (block.type === 'image') {
+        if (block.offloaded) {
+            return { type: 'text', text: `图片 ${block.attachment.name ?? block.attachment.attachmentId} 已按官方会话策略移出当前上下文。` };
+        }
+        if (!readImage)
+            throw new NeedError('ATTACHMENT_REQUIRED', '我需要官方附件组件读取这张图片', '官方attachments.readImage');
+        const image = await readImage(block.attachment, options.signal);
+        options.signal?.throwIfAborted();
+        if (!image || !(image.data instanceof Uint8Array) || image.ref?.attachmentId !== block.attachment.attachmentId || !['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(image.ref.mediaType) || image.ref.bytes !== image.data.byteLength)
+            throw new NeedError('ATTACHMENT_INVALID', '图片附件没有返回匹配的已核验内容', '官方核验的图片字节与媒体类型');
+        return { type: 'image', mimeType: image.ref.mediaType, data: Buffer.from(image.data).toString('base64') };
+    }
+    throw new NeedError(history ? 'HISTORY_CONTENT_UNSUPPORTED' : 'INPUT_TYPE_REQUIRED', `我需要此${history ? '历史' : '输入'}类型的远程转接能力：${block.type}；本轮未新建或发送`, '对应类型的公开ACP输入映射；内部推理及工具记录不可降为用户要求');
+}
+/** Role-labelled public history only; never serialize source/replay/tool internals. */
+export async function prepareContinuation(options, input, readImage) {
+    const messages = options.messages.filter(message => !isWorkspaceNoticeMessage(message)).map(withoutWorkspaceNotice);
+    for (const message of messages)
+        if (!['user', 'assistant', 'system', 'developer'].includes(message.role))
+            throw new NeedError('HISTORY_CONTENT_UNSUPPORTED', `此前含有无法可靠承接的历史角色：${message.role}；本轮未新建或发送`, '完整公开的用户及助手历史；工具记录的公开内容映射');
+    const after = messages.findLastIndex(message => message.role === 'assistant');
+    const prompt = [];
+    const historyTransfer = { scope: 'visible-user-assistant-text-and-images', textBlocks: 0, imageBlocks: 0, offloadedImagePlaceholders: 0, omittedReasoningBlocks: 0, reasoningOmissionReason: 'dsh-internal-reasoning' };
+    for (const message of messages.slice(0, after + 1)) {
+        if (message.role === 'system' || message.role === 'developer')
+            continue;
+        if (message.role !== 'user' && message.role !== 'assistant')
+            throw new NeedError('HISTORY_CONTENT_UNSUPPORTED', `此前含有无法可靠承接的历史角色：${message.role}；本轮未新建或发送`, '完整公开的用户及助手历史；工具记录的公开内容映射');
+        prompt.push({ type: 'text', text: `此前可见对话（历史角色：${message.role}；仅为历史记录）：\n` });
+        for (const block of message.content) {
+            // DSH explicitly distinguishes internal thinking from visible user text.
+            if (block.type === 'reasoning') {
+                historyTransfer.omittedReasoningBlocks++;
+                continue;
+            }
+            prompt.push(await publicBlock(block, options, readImage, true));
+            if (block.type === 'text')
+                historyTransfer.textBlocks++;
+            else if (block.type === 'image') {
+                if (block.offloaded)
+                    historyTransfer.offloadedImagePlaceholders++;
+                else
+                    historyTransfer.imageBlocks++;
+            }
+        }
+        prompt.push({ type: 'text', text: `\n（历史角色：${message.role} 的记录结束）\n` });
+    }
+    prompt.push({ type: 'text', text: '此前可见对话结束。以下为当前用户输入：\n' }, ...input.prompt);
+    return { ...input, prompt, historyTransfer };
+}
 /** The attachment service supplies verified bytes; client paths never cross SSH. */
 export async function prepareInput(options, readImage) {
     options.signal?.throwIfAborted();
@@ -10,7 +64,11 @@ export async function prepareInput(options, readImage) {
     for (const message of messages) {
         if (message.role !== 'system' && message.role !== 'developer')
             continue;
-        const parts = message.content.map(block => block.type === 'text' ? block.text : JSON.stringify(block));
+        const parts = message.content.map(block => {
+            if (block.type !== 'text')
+                throw new NeedError('SYSTEM_CONTEXT_TYPE_UNSUPPORTED', '系统或开发者要求包含暂不支持的非文本内容，本轮未新建或发送', '系统及开发者仅支持公开text上下文；非文本内容需要已定义的公开ACP投影');
+            return block.text;
+        });
         if (parts.length)
             context.push((message.role === 'system' ? '系统上下文：' : '开发者上下文：') + '\n' + parts.join('\n'));
     }
@@ -19,31 +77,14 @@ export async function prepareInput(options, readImage) {
     if (!users.length)
         throw new NeedError('INPUT_REQUIRED', '我需要本轮用户输入', '用户输入');
     const prompt = [];
+    const preparedUsers = [];
     for (const message of users) {
-        for (const block of message.content) {
-            options.signal?.throwIfAborted();
-            if (block.type === 'text') {
-                prompt.push({ type: 'text', text: block.text });
-                continue;
-            }
-            if (block.type === 'image') {
-                if (block.offloaded) {
-                    prompt.push({ type: 'text', text: `图片 ${block.attachment.name ?? block.attachment.attachmentId} 已按官方会话策略移出当前上下文。` });
-                    continue;
-                }
-                if (!readImage)
-                    throw new NeedError('ATTACHMENT_REQUIRED', '我需要官方附件组件读取这张图片', '官方attachments.readImage');
-                const image = await readImage(block.attachment, options.signal);
-                options.signal?.throwIfAborted();
-                if (!image || !(image.data instanceof Uint8Array) || image.ref?.attachmentId !== block.attachment.attachmentId || !['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(image.ref.mediaType) || image.ref.bytes !== image.data.byteLength)
-                    throw new NeedError('ATTACHMENT_INVALID', '图片附件没有返回匹配的已核验内容', '官方核验的图片字节与媒体类型');
-                prompt.push({ type: 'image', mimeType: image.ref.mediaType, data: Buffer.from(image.data).toString('base64') });
-                continue;
-            }
-            throw new NeedError('INPUT_TYPE_REQUIRED', `我需要此输入类型的远程转接能力：${block.type}`, '对应类型的公开ACP输入映射');
-        }
+        const before = prompt.length;
+        for (const block of message.content)
+            prompt.push(await publicBlock(block, options, readImage));
+        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/local-user-turn.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeRequest } from './provider.ts';
+import type { Context } from '@deepseek-ai/cordis';
+export interface LocalTurnProof {
+    expectedUserTurn: {
+        turn: number;
+        userMessageId: string;
+    };
+    startSequence: number;
+    userMessageSequence: number;
+    assertCurrent(): void;
+}
+/** CAS expectation only. L independently establishes live human-turn/brand evidence. */
+export declare function readLocalUserTurn(ctx: Context, request: {
+    sessionId: string;
+    route: string;
+    userMessageIds: readonly string[];
+}): Promise<LocalTurnProof>;
+/** Only metadata observed live since this plugin mounted; never seed or persisted tails. */
+export declare function createLocalUserTurnObserver(ctx: Pick<Context, 'get' | 'on'>): {
+    current(request: Pick<RuntimeRequest, "sessionId" | "userInputIds">): {
+        turn: number;
+        userMessageId: string;
+    };
+};

package/dist/local-user-turn.js

@@ -0,0 +1,103 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { isDeepStrictEqual } from 'node:util';
+import { NeedError } from "./remote.js";
+const failure = (code = 'REMOTE_DETAIL_SCOPE_INVALID') => new NeedError(code, '本轮输入无法核对，已停止本次处理。', '官方当前员工输入与所选远程品牌');
+/** CAS expectation only. L independently establishes live human-turn/brand evidence. */
+export async function readLocalUserTurn(ctx, request) {
+    request = structuredClone(request);
+    const id = SessionId(request.sessionId), sessions = ctx.get('sessions'), session = sessions?.get(id);
+    const persistence = ctx.get('sessionPersistence');
+    if (!session || typeof sessions?.flush !== 'function' || !persistence?.identity || typeof persistence.open !== 'function' || !request.userMessageIds.length)
+        throw failure();
+    const watermark = session.seq, header = structuredClone(session.header), persistenceIdentity = persistence.identity;
+    const assertCurrent = () => { if (ctx.get('sessions')?.get(id) !== session || ctx.get('sessionPersistence')?.identity !== persistenceIdentity || session.seq !== watermark || !isDeepStrictEqual(session.header, header))
+        throw failure('LOCAL_USER_TURN_CHANGED'); };
+    assertCurrent();
+    if (!await sessions.flush(session))
+        throw failure();
+    assertCurrent();
+    const handle = await persistence.open(id, 'read');
+    let proof, firstFailure;
+    try {
+        assertCurrent();
+        if (handle.id !== id || handle.access !== 'read' || !isDeepStrictEqual(handle.header, header) || handle.inheritedEventCount !== session.inheritedEventCount)
+            throw failure();
+        const { events } = await handle.read();
+        assertCurrent();
+        if (!Array.isArray(events) || events.length !== watermark)
+            throw failure();
+        let turn, step, input, route, routeContext;
+        for (let i = 0; i < events.length; i++) {
+            const e = events[i];
+            if (e.seq !== i)
+                throw failure();
+            if (e.type === 'turn/start') {
+                turn = e;
+                step = undefined;
+                input = undefined;
+            }
+            else if (e.type === 'turn/end') {
+                turn = undefined;
+                step = undefined;
+                input = undefined;
+            }
+            else if (e.type === 'step/start') {
+                step = e;
+                input = undefined;
+            }
+            else if (e.type === 'step/end') {
+                step = undefined;
+                input = undefined;
+            }
+            else if (e.type === 'user/message' && step && e.data.source.kind === 'user')
+                input = e;
+            else if (e.type === 'request/header')
+                route = e.data.header.config.provider;
+            else if (e.type === 'request/context')
+                routeContext = e.data.provider;
+        }
+        if (!turn || !step || step.data.turn !== turn.data.turn || !input || route !== request.route || routeContext !== undefined && routeContext !== request.route || !session.isOwnSeq(turn.seq) || !session.isOwnSeq(step.seq) || !session.isOwnSeq(input.seq) || !request.userMessageIds.includes(input.data.id))
+            throw failure();
+        proof = { expectedUserTurn: { turn: turn.data.turn, userMessageId: input.data.id }, startSequence: turn.seq, userMessageSequence: input.seq };
+    }
+    catch (error) {
+        firstFailure = error;
+    }
+    try {
+        await handle.close();
+    }
+    catch (error) {
+        if (firstFailure instanceof NeedError)
+            throw Object.assign(new NeedError(firstFailure.code, firstFailure.message, firstFailure.requires + '；持久句柄关闭失败'), { cause: new AggregateError([firstFailure, error], 'LOCAL_TURN_READ_AND_CLOSE_FAILED') });
+        if (firstFailure !== undefined)
+            throw new AggregateError([firstFailure, error], 'LOCAL_TURN_READ_AND_CLOSE_FAILED');
+        throw error;
+    }
+    if (firstFailure !== undefined)
+        throw firstFailure;
+    assertCurrent();
+    return { ...proof, assertCurrent };
+}
+/** Only metadata observed live since this plugin mounted; never seed or persisted tails. */
+export function createLocalUserTurnObserver(ctx) {
+    const current = new WeakMap();
+    ctx.on('session/event', (session, event) => {
+        if (event.type === 'turn/start')
+            current.set(session, { turn: event.data.turn });
+        else if (event.type === 'turn/end')
+            current.delete(session);
+        else if (event.type === 'user/message' && event.data.source.kind === 'user') {
+            const turn = current.get(session);
+            if (turn)
+                turn.userMessageId = event.data.id;
+        }
+    });
+    ctx.on('session/disposed', session => current.delete(session));
+    return { current(request) {
+            const session = request.sessionId ? ctx.get('sessions')?.get(SessionId(request.sessionId)) : undefined;
+            const metadata = session ? current.get(session) : undefined;
+            if (!metadata || !Number.isSafeInteger(metadata.turn) || metadata.turn < 0 || !metadata.userMessageId || !request.userInputIds?.includes(metadata.userMessageId))
+                throw new NeedError('LOCAL_USER_TURN_UNCONFIRMED', '无法核对本次员工输入，本轮已停止。', '本插件启用后观察到的官方真实员工输入');
+            return { turn: metadata.turn, userMessageId: metadata.userMessageId };
+        } };
+}

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;
+};

package/dist/model-catalog.js

@@ -0,0 +1,254 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { spawn } from 'node:child_process';
+import { LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { sameTarget, validateTarget } from "./provider.js";
+import { ModelConfigurationError } from "./model-configuration.js";
+import { sanitizeObservation } from "./conversation-details.js";
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const text = (value) => typeof value === 'string' && value.trim().length > 0;
+function fail(reason) { throw new LlmError('无法获取模型列表：' + reason, 'MODEL_CATALOG_UNAVAILABLE'); }
+function freeze(value) { if (value && typeof value === 'object') {
+    for (const item of Object.values(value))
+        freeze(item);
+    Object.freeze(value);
+} return value; }
+export function parseHostCatalog(input, provider, username) {
+    let wire;
+    try {
+        wire = JSON.parse(input);
+    }
+    catch {
+        fail('主机目录响应不是有效 JSON');
+    }
+    if (!object(wire) || wire.version !== 1 || wire.purpose !== 'model-catalog' || wire.scope !== 'host-user' || wire.provider !== provider)
+        fail('主机目录版本、品牌或作用域不匹配');
+    if (wire.ok === false) {
+        const error = object(wire.error) ? wire.error : undefined;
+        const code = typeof error?.code === 'string' && /^[A-Z][A-Z0-9_]*$/.test(error.code) ? error.code : 'PROTOCOL_INVALID';
+        const reason = text(error?.message) ? sanitizeObservation({ kind: 'session', severity: 'warning', code, summary: error.message, payload: {} }).summary : '主机未提供失败说明';
+        fail('主机目录查询失败（' + code + '）：' + reason);
+    }
+    if (wire.ok !== true || wire.permissionProbe !== false || !object(wire.subject) || wire.subject.username !== username || !Number.isSafeInteger(wire.subject.uid) || !text(wire.observedAt) || !object(wire.source) || !object(wire.settings) || !Array.isArray(wire.models))
+        fail('主机目录缺少完整元数据');
+    const ids = new Set(), values = new Set();
+    for (const model of wire.models) {
+        if (!object(model) || !text(model.id) || !text(model.value) || !text(model.name) || (model.resolvedModel !== null && !text(model.resolvedModel)) || !object(model.source) || !object(model.reasoning))
+            fail('主机模型条目不完整');
+        if (provider === 'codex' && model.resolvedModel !== model.value)
+            fail('Codex目录具体型号与模型值不一致');
+        if (ids.has(model.id) || values.has(model.value))
+            fail('主机目录含重复模型标识或值');
+        ids.add(model.id);
+        values.add(model.value);
+        const r = model.reasoning;
+        if (!Array.isArray(r.options) || typeof r.defaultKnown !== 'boolean' || (r.defaultValue !== null && !text(r.defaultValue)) || (!r.defaultKnown && r.defaultValue !== null))
+            fail('主机推理等级或默认值无效');
+        const efforts = new Set();
+        for (const effort of r.options) {
+            if (!object(effort) || !text(effort.value) || !text(effort.name) || efforts.has(effort.value))
+                fail('主机推理等级条目无效或重复');
+            efforts.add(effort.value);
+        }
+        if (r.defaultKnown && (r.defaultValue === null || !efforts.has(r.defaultValue)))
+            fail('主机默认推理等级缺少对应选项');
+    }
+    if (!wire.models.length)
+        fail('主机返回的完整模型目录为空');
+    return freeze(structuredClone(wire.models));
+}
+/** Only the public L sshArgs function chooses SSH trust and transport arguments. */
+export const runCatalog = async (target, command, signal, maxBytes) => {
+    let argv;
+    try {
+        const moduleName = '@ai-workbench/connect';
+        const l = await import(__rewriteRelativeImportExtension(moduleName));
+        if (typeof l.sshArgs !== 'function')
+            fail('远程主机连接组件缺少可信 SSH 能力');
+        argv = l.sshArgs(target);
+    }
+    catch (error) {
+        if (error instanceof LlmError)
+            throw error;
+        fail('远程主机连接组件缺少可信 SSH 能力');
+    }
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const child = spawn('ssh', ['-n', ...argv, command], { stdio: ['ignore', 'pipe', 'pipe'] });
+        const parts = [];
+        let total = 0, stderr = 0;
+        let failure;
+        const abort = () => { failure = new ModelConfigurationError('连接已改变或目录查询已取消'); child.kill('SIGTERM'); };
+        signal.addEventListener('abort', abort, { once: true });
+        const receive = (buffer, output) => { if (failure)
+            return; total += buffer.length; if (total > maxBytes) {
+            failure = new ModelConfigurationError('目录响应超过 acpMaxMessageBytes，未截断返回');
+            child.kill('SIGTERM');
+            return;
+        } if (output)
+            parts.push(buffer);
+        else
+            stderr += buffer.length; };
+        child.stdout.on('data', (b) => receive(b, true));
+        child.stderr.on('data', (b) => receive(b, false));
+        child.on('error', () => { failure = new ModelConfigurationError('可信 SSH 进程启动失败'); });
+        child.on('close', code => {
+            signal.removeEventListener('abort', abort);
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            let output;
+            try {
+                output = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(parts));
+            }
+            catch {
+                reject(new ModelConfigurationError('主机目录响应不是有效 UTF-8，未替换模型值'));
+                return;
+            }
+            // S publishes its typed failure JSON on stdout even on nonzero exit.
+            if (code !== 0) {
+                try {
+                    const wire = JSON.parse(output);
+                    if (wire?.ok === false) {
+                        resolve(output);
+                        return;
+                    }
+                }
+                catch { }
+                reject(new ModelConfigurationError('可信 SSH 或主机目录命令失败（退出码 ' + String(code) + '）'));
+                return;
+            }
+            if (stderr) {
+                reject(new ModelConfigurationError('目录命令返回了非预期诊断输出'));
+                return;
+            }
+            resolve(output);
+        });
+        if (signal.aborted)
+            abort();
+    });
+};
+/** No cache: every query binds to L's current object, host-user and generation. */
+export class ModelCatalog {
+    get;
+    maxBytes;
+    run;
+    changed;
+    api;
+    unsubscribe;
+    signature;
+    revision = 0;
+    disposed = false;
+    initialized = false;
+    active = new Set();
+    constructor(get, maxBytes, run = runCatalog, changed = () => { }) {
+        this.get = get;
+        this.maxBytes = maxBytes;
+        this.run = run;
+        this.changed = changed;
+        this.refresh();
+    }
+    refresh() {
+        const api = this.get();
+        const state = api?.getConnectionState?.();
+        const info = api?.getContractInfo?.();
+        const targets = info?.modelCatalogTarget === 1 && api?.getModelCatalogTarget ? ['codex', 'claude'].map(brand => api.getModelCatalogTarget(brand)) : undefined;
+        const login = api?.getLoginPromptState?.();
+        // L's same-epoch recovery wording is presentation metadata, not an execution change.
+        const executionState = state && { instanceId: state.instanceId, epoch: state.epoch, phase: state.phase, needCode: state.need?.code };
+        const executionTargets = targets?.map(result => result.ok ? result : { ok: false, code: result.error.code });
+        const signature = JSON.stringify({ state: executionState, capability: info?.modelCatalogTarget, targets: executionTargets, logins: login?.logins, authorizing: login?.phase === 'authorizing' });
+        const switched = api !== this.api;
+        const changed = this.initialized && (switched || signature !== this.signature);
+        this.initialized = true;
+        if (switched) {
+            this.unsubscribe?.();
+            this.unsubscribe = undefined;
+            this.api = api;
+            const off = [];
+            if (typeof api?.onConnectionState === 'function')
+                off.push(api.onConnectionState(() => this.refresh()));
+            if (typeof api?.onLoginPromptState === 'function')
+                off.push(api.onLoginPromptState(() => this.refresh()));
+            this.unsubscribe = () => { for (const stop of off)
+                stop(); };
+        }
+        this.signature = signature;
+        if (changed) {
+            this.revision++;
+            for (const controller of this.active)
+                controller.abort();
+            this.active.clear();
+            this.changed();
+        }
+    }
+    trusted(agent, api) {
+        const info = api.getContractInfo?.();
+        if (info?.modelCatalogTarget !== 1 || typeof api.getModelCatalogTarget !== 'function')
+            fail('远程主机连接组件尚未提供模型目录目标能力');
+        const state = api.getConnectionState();
+        if (state.phase !== 'connected' || !text(state.instanceId) || !Number.isSafeInteger(state.epoch) || state.epoch < 0)
+            fail('当前没有已验证的远程主机连接');
+        const result = api.getModelCatalogTarget(agent.loginProvider);
+        if (!result.ok)
+            fail(result.error.message);
+        const target = result.value;
+        if (target.version !== 1 || target.purpose !== 'model-catalog' || target.scope !== 'host-user' || target.provider !== agent.loginProvider || target.instanceId !== state.instanceId || target.epoch !== state.epoch)
+            fail('模型目录目标与当前连接或品牌不匹配');
+        try {
+            validateTarget(target.target);
+        }
+        catch {
+            fail('模型目录的可信 SSH 目标不完整');
+        }
+        return structuredClone(target);
+    }
+    async read(agent, signal) {
+        let controller;
+        try {
+            if (this.disposed)
+                fail('远程模型插件已关闭');
+            this.refresh();
+            const api = this.get();
+            if (!api)
+                fail('远程主机连接组件没有装好');
+            const target = freeze(this.trusted(agent, api)), revision = this.revision;
+            const max = this.maxBytes();
+            if (!Number.isSafeInteger(max) || max < 1)
+                fail('acpMaxMessageBytes 设置无效');
+            controller = new AbortController();
+            this.active.add(controller);
+            const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+            const assertCurrent = () => { if (combined.aborted || this.disposed || this.get() !== api || revision !== this.revision)
+                fail('连接已改变，原模型目录已失效'); const current = this.trusted(agent, api); if (current.instanceId !== target.instanceId || current.epoch !== target.epoch || current.provider !== target.provider || !sameTarget(current.target, target.target))
+                fail('可信目标或连接代次已改变，原模型目录已失效'); };
+            assertCurrent();
+            const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, combined, max);
+            assertCurrent();
+            const models = parseHostCatalog(output, agent.loginProvider, target.target.username);
+            const own = controller;
+            return { target, models, signal: combined, assertCurrent, release: () => this.active.delete(own) };
+        }
+        catch (error) {
+            if (controller)
+                this.active.delete(controller);
+            if (error instanceof LlmError)
+                throw error;
+            if (error instanceof ModelConfigurationError)
+                fail(error.message.replace(/^无法获取模型列表：/, ''));
+            fail('目录查询失败，根因未查明');
+        }
+    }
+    dispose() { this.disposed = true; this.unsubscribe?.(); for (const controller of this.active)
+        controller.abort(); this.active.clear(); }
+}
+export function modelInfo(provider, model) {
+    return { provider, id: model.id, name: model.name, inputModalities: ['text', 'image'], reasoning: { efforts: model.reasoning.options.map(option => ({ id: ReasoningEffortId(option.value), name: option.name })), ...(model.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { defaultEffort: ReasoningEffortId(model.reasoning.defaultValue) } : {}) }, catalog: model };
+}

package/dist/model-configuration.d.ts

@@ -0,0 +1,51 @@
+import type { SessionConfigOption } from '@agentclientprotocol/sdk/unstable';
+export type DeepReadonly<T> = T extends readonly unknown[] ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+export interface ModelCatalogValue {
+    readonly value: string;
+    readonly name: string;
+    readonly description?: string | null;
+}
+export interface ModelConfigurationSnapshot {
+    readonly configOptions: DeepReadonly<SessionConfigOption[]>;
+    readonly models: readonly ModelCatalogValue[];
+    readonly modelConfigId?: string;
+    readonly effortConfigId?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly effortAvailable: boolean;
+    /** Acknowledges the selected values, not the availability of every catalog entry. */
+    readonly confirmed: boolean;
+    readonly failure?: Readonly<{
+        code: 'MODEL_CATALOG_UNAVAILABLE';
+        message: string;
+    }>;
+}
+export type ModelConfigurationSetter = (configId: string, value: string) => Promise<{
+    configOptions: SessionConfigOption[];
+}>;
+export declare class ModelConfigurationError extends Error {
+    readonly code = "MODEL_CATALOG_UNAVAILABLE";
+    constructor(reason: string, options?: ErrorOptions);
+}
+/** Pure ACP configuration state. All IDs and values come from the given peer data. */
+export declare class ModelConfiguration {
+    private readonly rpcSet;
+    private state;
+    private parsed?;
+    private revision;
+    private busy;
+    constructor(options: SessionConfigOption[], rpcSet: ModelConfigurationSetter);
+    get models(): readonly ModelCatalogValue[];
+    get snapshot(): ModelConfigurationSnapshot;
+    update(options: SessionConfigOption[]): void;
+    private fail;
+    private checkAckRevision;
+    private set;
+    select(model: string, effort?: string): Promise<ModelConfigurationSnapshot>;
+    /** Call immediately before prompt; an idle/new/load/resume update withdraws the ACK. */
+    assertSelection(model: string, effort?: string): void;
+}