@ai-workbench/remote-agent 0.8.5 → 0.8.11

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'));
     }
@@ -22,28 +80,8 @@ export async function prepareInput(options, readImage) {
     const preparedUsers = [];
     for (const message of users) {
         const before = prompt.length;
-        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输入映射');
-        }
+        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)

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

@@ -28,7 +28,19 @@ 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[];
+export interface CatalogIssue {
+    readonly modelName: string;
+    readonly reason: string;
+    readonly code: string;
+}
+export interface ParsedCatalog {
+    readonly models: readonly HostModel[];
+    readonly issues: readonly CatalogIssue[];
+}
+export declare function catalogDiagnostic(issues: readonly CatalogIssue[]): string | undefined;
+/** Defaults are provider declarations, never catalog order or display names. */
+export declare function declaredDefault(agent: AgentDefinition, models: readonly HostModel[]): HostModel | undefined;
+export declare function parseHostCatalog(input: string, provider: string, username: string): ParsedCatalog;
 /** 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. */
@@ -37,6 +49,8 @@ export declare class ModelCatalog implements ModelDirectory {
     private maxBytes;
     private run;
     private changed;
+    private diagnostic;
+    private loaded;
     private api?;
     private unsubscribe?;
     private signature?;
@@ -44,7 +58,9 @@ export declare class ModelCatalog implements ModelDirectory {
     private disposed;
     private initialized;
     private active;
-    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void);
+    private serial;
+    private latest;
+    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void, diagnostic?: (provider: 'claude' | 'codex', message: string | undefined) => void, loaded?: (agent: AgentDefinition, models: readonly HostModel[], assertCurrent: () => void) => void | Promise<void>);
     refresh(): void;
     private trusted;
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;

package/dist/model-catalog.js

@@ -13,12 +13,25 @@ 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'); }
+class CatalogError extends LlmError {
+    diagnostic;
+    constructor(reason, diagnostic) { super('无法获取模型列表：' + reason, 'MODEL_CATALOG_UNAVAILABLE'); this.diagnostic = diagnostic + '（诊断代码：MODEL_CATALOG_UNAVAILABLE）'; }
+}
+const safe = (value) => sanitizeObservation({ kind: 'session', severity: 'warning', code: 'MODEL_CATALOG_DIAGNOSTIC', summary: value, payload: {} }).summary;
+function fail(reason, diagnostic = reason) { throw new CatalogError(reason, diagnostic); }
 function freeze(value) { if (value && typeof value === 'object') {
     for (const item of Object.values(value))
         freeze(item);
     Object.freeze(value);
 } return value; }
+export function catalogDiagnostic(issues) {
+    return issues.length ? '以下模型未加入可选列表：\n' + issues.map(issue => `模型「${issue.modelName}」：${issue.reason}（诊断代码：${issue.code}）`).join('\n') : undefined;
+}
+/** Defaults are provider declarations, never catalog order or display names. */
+export function declaredDefault(agent, models) {
+    const selected = models.filter(model => agent.loginProvider === 'claude' ? model.value === 'default' : object(model.source) && model.source.isDefault === true);
+    return selected.length === 1 ? selected[0] : undefined;
+}
 export function parseHostCatalog(input, provider, username) {
     let wire;
     try {
@@ -32,36 +45,60 @@ export function parseHostCatalog(input, provider, username) {
     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);
+        const reason = text(error?.message) ? safe(error.message) : '主机未提供失败说明';
+        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 ids = new Map(), values = new Map();
+    for (const model of wire.models)
+        if (object(model)) {
+            if (text(model.id))
+                ids.set(model.id, (ids.get(model.id) ?? 0) + 1);
+            if (text(model.value))
+                values.set(model.value, (values.get(model.value) ?? 0) + 1);
+        }
+    const models = [], issues = [];
+    for (const [index, model] of wire.models.entries()) {
+        const modelName = object(model) && text(model.name) ? safe(model.name) : object(model) && text(model.id) ? safe(model.id) : `第 ${index + 1} 项（缺少模型名称）`;
+        const reject = (reason, code = 'MODEL_CATALOG_ITEM_INVALID') => issues.push({ modelName, reason, code });
+        if (!object(model) || !text(model.id) || !text(model.value) || !text(model.name) || (model.resolvedModel !== null && !text(model.resolvedModel)) || !object(model.source) || !object(model.reasoning)) {
+            reject('模型标识、名称或能力资料不完整');
+            continue;
+        }
+        if ((ids.get(model.id) ?? 0) > 1 || (values.get(model.value) ?? 0) > 1) {
+            reject('模型标识或发送值重复，无法确定对应关系', 'MODEL_CATALOG_DUPLICATE');
+            continue;
+        }
+        if (provider === 'codex' && model.resolvedModel !== model.value) {
+            reject('具体型号与发送模型值不一致');
+            continue;
+        }
         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('主机推理等级或默认值无效');
+        if (!Array.isArray(r.options) || typeof r.defaultKnown !== 'boolean' || (r.defaultValue !== null && !text(r.defaultValue)) || (!r.defaultKnown && r.defaultValue !== null)) {
+            reject('推理档位或默认档位资料无效', 'MODEL_REASONING_INVALID');
+            continue;
+        }
         const efforts = new Set();
+        let invalid = false;
         for (const effort of r.options) {
-            if (!object(effort) || !text(effort.value) || !text(effort.name) || efforts.has(effort.value))
-                fail('主机推理等级条目无效或重复');
+            if (!object(effort) || !text(effort.value) || !text(effort.name) || efforts.has(effort.value)) {
+                invalid = true;
+                break;
+            }
             efforts.add(effort.value);
         }
-        if (r.defaultKnown && (r.defaultValue === null || !efforts.has(r.defaultValue)))
-            fail('主机默认推理等级缺少对应选项');
+        if (invalid) {
+            reject('推理档位缺少名称、值无效或重复', 'MODEL_REASONING_INVALID');
+            continue;
+        }
+        if (r.defaultKnown && (r.defaultValue === null || !efforts.has(r.defaultValue))) {
+            reject('默认推理档位不在该模型提供的选项中', 'MODEL_REASONING_DEFAULT_INVALID');
+            continue;
+        }
+        models.push(model);
     }
-    if (!wire.models.length)
-        fail('主机返回的完整模型目录为空');
-    return freeze(structuredClone(wire.models));
+    return freeze(structuredClone({ models, issues }));
 }
 /** Only the public L sshArgs function chooses SSH trust and transport arguments. */
 export const runCatalog = async (target, command, signal, maxBytes) => {
@@ -141,6 +178,8 @@ export class ModelCatalog {
     maxBytes;
     run;
     changed;
+    diagnostic;
+    loaded;
     api;
     unsubscribe;
     signature;
@@ -148,11 +187,15 @@ export class ModelCatalog {
     disposed = false;
     initialized = false;
     active = new Set();
-    constructor(get, maxBytes, run = runCatalog, changed = () => { }) {
+    serial = 0;
+    latest = new Map();
+    constructor(get, maxBytes, run = runCatalog, changed = () => { }, diagnostic = () => { }, loaded = () => { }) {
         this.get = get;
         this.maxBytes = maxBytes;
         this.run = run;
         this.changed = changed;
+        this.diagnostic = diagnostic;
+        this.loaded = loaded;
         this.refresh();
     }
     refresh() {
@@ -183,9 +226,12 @@ export class ModelCatalog {
         this.signature = signature;
         if (changed) {
             this.revision++;
+            this.latest.clear();
             for (const controller of this.active)
                 controller.abort();
             this.active.clear();
+            this.diagnostic('claude', undefined);
+            this.diagnostic('codex', undefined);
             this.changed();
         }
     }
@@ -198,7 +244,7 @@ export class ModelCatalog {
             fail('当前没有已验证的远程主机连接');
         const result = api.getModelCatalogTarget(agent.loginProvider);
         if (!result.ok)
-            fail(result.error.message);
+            fail('远程主机连接暂未提供可信的模型目录目标，请到设置 → 模型查看诊断。', `模型目录目标不可用（诊断代码：${safe(result.error.code)}）：${safe(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('模型目录目标与当前连接或品牌不匹配');
@@ -212,43 +258,62 @@ export class ModelCatalog {
     }
     async read(agent, signal) {
         let controller;
+        let api;
+        let revision = this.revision;
+        const serial = ++this.serial;
+        this.latest.set(agent.loginProvider, serial);
+        const current = () => !this.disposed && revision === this.revision && api === this.get() && this.latest.get(agent.loginProvider) === serial;
+        let reported = false;
+        const report = (message) => { if (current()) {
+            reported = true;
+            this.diagnostic(agent.loginProvider, message);
+        } };
         try {
             if (this.disposed)
                 fail('远程模型插件已关闭');
             this.refresh();
-            const api = this.get();
+            api = this.get();
+            revision = this.revision;
             if (!api)
                 fail('远程主机连接组件没有装好');
-            const target = freeze(this.trusted(agent, api)), revision = this.revision;
+            // refresh may clear reads from the previous connection generation.
+            this.latest.set(agent.loginProvider, serial);
+            const trustedApi = api, target = freeze(this.trusted(agent, trustedApi));
             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))
+            const assertCurrent = () => { if (combined.aborted || this.disposed || this.get() !== trustedApi || revision !== this.revision)
+                fail('连接已改变，原模型目录已失效'); const current = this.trusted(agent, trustedApi); 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 parsed = parseHostCatalog(output, agent.loginProvider, target.target.username), diagnostic = catalogDiagnostic(parsed.issues);
+            if (!parsed.models.length)
+                fail('当前没有可选模型，请到设置 → 模型查看诊断。', diagnostic ?? '主机返回的完整模型目录为空（诊断代码：MODEL_CATALOG_EMPTY）');
+            report(diagnostic);
+            if (current())
+                await this.loaded(agent, parsed.models, assertCurrent);
+            assertCurrent();
             const own = controller;
-            return { target, models, signal: combined, assertCurrent, release: () => this.active.delete(own) };
+            return { target, models: parsed.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('目录查询失败，根因未查明');
+            const failure = error instanceof CatalogError ? error : new CatalogError(error instanceof ModelConfigurationError ? error.message.replace(/^无法获取模型列表：/, '') : '目录查询失败，请到设置 → 模型查看诊断。', error instanceof Error ? `${error instanceof LlmError ? error.code : 'MODEL_CATALOG_QUERY_FAILED'}：${safe(error.message)}` : 'MODEL_CATALOG_QUERY_FAILED：目录查询失败，根因未查明');
+            if (!reported)
+                report(failure.diagnostic);
+            throw failure;
         }
     }
     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 };
+    // Official rc.2 represents no reasoning levels by absence, and rejects an empty efforts array.
+    return { provider, id: model.id, name: model.name, inputModalities: ['text', 'image'], ...(model.reasoning.options.length ? { 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-defaults.d.ts

@@ -0,0 +1,29 @@
+import type { AgentDefinition } from './agents.ts';
+import { type HostModel } from './model-catalog.ts';
+export interface DefaultSelection {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+/** Public agentDefaultModel service; writes below use the atomic config editor. */
+export interface DefaultModelService {
+    currentSelection(): DefaultSelection;
+}
+interface DefaultEntry {
+    options: {
+        name?: string;
+    };
+}
+/** Public rc.2 configEditor.entries/edit subset; no ownerContext/private config access. */
+export interface DefaultConfigEditor {
+    entries(): readonly DefaultEntry[];
+    edit(entry: DefaultEntry, change: (current: Record<string, unknown>, inherited: Record<string, unknown>) => Record<string, unknown>): Promise<void>;
+}
+export type DefaultSelectionWriter = (expected: DefaultSelection, next: DefaultSelection, assertCurrent: () => void) => Promise<void>;
+/** The editor invokes the guard synchronously under its profile lock after reconciliation. */
+export declare function createDefaultSelectionWriter(service: DefaultModelService, getEditor: () => DefaultConfigEditor | undefined): DefaultSelectionWriter;
+export declare function createModelDefaults(service: DefaultModelService, report: (provider: string, message: string | undefined) => void, write?: DefaultSelectionWriter): {
+    observe(agent: AgentDefinition, models: readonly HostModel[], assertCurrent?: () => void): Promise<void>;
+    dispose(): void;
+};
+export {};

package/dist/model-defaults.js

@@ -0,0 +1,62 @@
+import { declaredDefault } from "./model-catalog.js";
+const same = (a, b) => a.provider === b.provider && a.model === b.model && a.reasoningEffort === b.reasoningEffort;
+/** The editor invokes the guard synchronously under its profile lock after reconciliation. */
+export function createDefaultSelectionWriter(service, getEditor) {
+    return async (expected, next, assertCurrent) => {
+        const editor = getEditor();
+        const entries = editor?.entries().filter(entry => entry.options.name === '@deepseek-ai/dsh-agent-default-model');
+        if (!editor || entries?.length !== 1)
+            throw Error('缺少唯一可原子编辑的官方默认模型设置');
+        await editor.edit(entries[0], current => {
+            assertCurrent();
+            if (!same(expected, service.currentSelection()))
+                throw Error('员工已改变模型选择，本次默认更新已撤回');
+            const updated = { ...current, provider: next.provider, model: next.model };
+            Reflect.deleteProperty(updated, 'reasoningEffort');
+            if (next.reasoningEffort !== undefined)
+                Object.assign(updated, { reasoningEffort: next.reasoningEffort });
+            return updated;
+        });
+    };
+}
+export function createModelDefaults(service, report, write) {
+    let disposed = false, queue = Promise.resolve();
+    return {
+        observe(agent, models, assertCurrent = () => { }) {
+            const snapshot = { ...service.currentSelection() };
+            const job = queue.then(async () => {
+                if (disposed || snapshot.provider !== agent.id || !same(snapshot, service.currentSelection()))
+                    return;
+                if (snapshot.model !== 'remote' && models.some(model => model.id === snapshot.model)) {
+                    report(agent.id, undefined);
+                    return;
+                }
+                const model = declaredDefault(agent, models);
+                const notice = model ? undefined : '提供方没有声明唯一的默认模型，请先选择模型。（诊断代码：MODEL_DEFAULT_UNAVAILABLE）';
+                const next = { provider: agent.id, model: model?.id ?? '', ...(model?.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { reasoningEffort: model.reasoning.defaultValue } : {}) };
+                try {
+                    const guard = () => { assertCurrent(); if (disposed)
+                        throw Error('默认设置消费已撤回'); };
+                    guard();
+                    if (!same(snapshot, next)) {
+                        if (!write)
+                            throw Error('缺少原子配置能力');
+                        await write(snapshot, next, guard);
+                    }
+                    if (disposed)
+                        return;
+                    if (!same(next, service.currentSelection()))
+                        throw Error('未确认官方默认模型设置已保存');
+                    report(agent.id, notice);
+                }
+                catch {
+                    if (!disposed)
+                        report(agent.id, (notice ? notice + '\n' : '') + '未能确认默认模型设置已更新，员工新选择不会被迟到的自动更新覆盖；请在模型菜单选择当前目录中的模型。（诊断代码：MODEL_DEFAULT_SAVE_FAILED）');
+                }
+            });
+            queue = job;
+            return job;
+        },
+        dispose() { disposed = true; },
+    };
+}

package/dist/model-input-retention.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+export interface ModelInputRetentionOptions {
+    isOurProvider: (provider: string) => boolean;
+    diagnostic: (provider: string, message: string | undefined) => void;
+}
+/** Mark only at the actual X adapter's preparation catch, then rethrow the same
+ * error. One error object can prove only its first preparation, for that signal.
+ * Public request config is an intermediate proposal and is not route evidence. */
+export declare function markModelPreparationFailure(provider: string, error: unknown, signal?: AbortSignal): void;
+/**
+ * Retain a claimed human batch only after a known, undispatched metadata prepare
+ * failure. Restoration uses the public durable inbox without sending or waking
+ * the agent. This cannot cover errors before pre-step/request, or unknown core
+ * admission failures; it never manufactures transcript messages or model routes.
+ */
+export declare function installModelInputRetention(ctx: Context, options: ModelInputRetentionOptions): void;