@ai-workbench/remote-agent 0.8.0 → 0.8.1

package/dist/index.js

@@ -1,3 +1,4 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
 import Schema from '@deepseek-ai/schemastery';
 import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
 import { fileURLToPath } from 'node:url';
@@ -14,6 +15,7 @@ import { prepareInput } from "./input.js";
 import { createWorkspaceNoticeConsumer, isWorkspaceNoticeMessage } from "./workspace-notice.js";
 import { NeedError } from "./remote.js";
 import { employeeFailure } from "./presentation.js";
+import { createRemoteDetails } from "./remote-details.js";
 import { PROVIDER_NAMES, ProviderLocaleRemote } from "./provider-locale.js";
 export const name = 'ai-workbench-remote-agent';
 export const settingsNamespace = 'ai-workbench-codex';
@@ -116,6 +118,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
         let live;
         let succeeded = false;
         let remoteAttempted = false;
+        let activeMapper;
         const config = this.config();
         const mode = this.agent.oneShot ? config.mode : 'session';
         try {
@@ -150,9 +153,17 @@ export class CodexRemoteAdapter extends LlmAdapter {
             signal.throwIfAborted();
             if (previous && (previous.identity !== runtime.identity || previous.cwd !== runtime.cwd || previous.bindingId && previous.bindingId !== runtime.binding?.bindingId || previous.workspaceId && previous.workspaceId !== runtime.binding?.workspaceId))
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '原会话的员工主机或工作区已改变，请新建会话', '原会话的可信目标和工作区');
-            const mapper = new StreamMapper(mode === 'session' ? (live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined);
+            const details = runtime.details;
+            if (!details)
+                throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用，请更新远程主机连接组件。', 'L技术详情持久接收能力');
+            const mapper = new StreamMapper(mode === 'session' ? (live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
+            activeMapper = mapper;
             let id;
             let stop;
+            if (runtime.workspaceNotice) {
+                yield* mapper.text(runtime.workspaceNotice.text);
+                yield* mapper.flush();
+            }
             if (mode === 'session') {
                 if (live && live.runtime !== runtime)
                     throw new NeedError('SESSION_TRANSPORT_MISMATCH', '原会话的主机通道已更换，不能自动切换进程', '原主机会话通道');
@@ -169,7 +180,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     catch (error) {
                         failure = error;
                         session?.close();
-                    } }, onResponse: response => push(mapper.acpResponse(response)), onNeed: need => push(mapper.text(`\n[需要处理] ${need.message}\n`)) };
+                    } }, onResponse: response => push(mapper.acpResponse(response)), onDetail: detail => details.record(detail) };
                 const fresh = !live;
                 if (fresh) {
                     const transport = runtime.acpTransport instanceof acp.AgentApp || runtime.acpTransport instanceof unstable.AgentApp ? runtime.acpTransport : acp.ndJsonStream(runtime.acpTransport.writable, runtime.acpTransport.readable, { maxMessageBytes: config.acpMaxMessageBytes });
@@ -193,8 +204,15 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         if (updated && this.agent.loginProvider === 'claude')
                             throw new NeedError('SYSTEM_PROMPT_UPDATE_PENDING', 'Claude原会话的系统或开发者要求已变化；主机仅承诺下次上下文整理后生效，本轮未发送，请新建会话应用新要求', '新建Claude会话以立即应用当前系统与开发者要求');
                     }
+                    await details.flush();
+                    details.beginTurn(runtime.detailContext?.() ?? { turn: null, step: null });
                     id = session.id;
-                    return await session.prompt(input.prompt, signal);
+                    try {
+                        return await session.prompt(input.prompt, signal);
+                    }
+                    finally {
+                        details.endTurn();
+                    }
                 })();
                 void task.then(value => { stop = value; }, error => { failure ??= runtime.broker?.error ?? error; }).finally(() => { done = true; wake?.(); wake = undefined; });
                 while (!done || queue.length) {
@@ -214,6 +232,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             else {
                 if (!runtime.oneShot)
                     throw new NeedError('DEPENDENCY_REQUIRED', '我需要主机单次运行助手', 'S安装的aw-codex-once');
+                details.beginTurn(runtime.detailContext?.() ?? { turn: null, step: null });
                 const text = input.prompt.map(block => block.type === 'text' ? block.text : '').join('\n');
                 for await (const event of runOneShot(runtime.oneShot, { wrapperPath: fileURLToPath(new URL('./sdk-ssh-wrapper.js', import.meta.url)), sandboxMode: config.oneShotSandbox, approvalPolicy: config.oneShotApproval }, text, previous?.sessionId, signal)) {
                     if (event.type === 'thread.started')
@@ -222,17 +241,31 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         yield chunk;
                 }
             }
+            details.endTurn();
+            await details.flush();
             if (!id)
                 throw new NeedError('SESSION_ID_MISSING', '远端没有返回会话标识', '有效的远端会话标识');
             if (live)
                 live.usageSnapshot = mapper.usageSnapshot;
-            const pointer = { version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), mode, identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
+            yield* mapper.flush();
+            const pointer = { ...(runtime.workspaceNotice ? { presentation: { workspaceNotice: runtime.workspaceNotice } } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), mode, identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
             succeeded = true;
             yield { type: 'finish', reason: { kind: stop === 'max_tokens' || stop === 'max_turn_requests' ? 'max-tokens' : 'stop' }, replayState: { response: pointer } };
         }
         catch (error) {
             if (live && (remoteAttempted || runtime === live.runtime))
-                live.failure = error;
+                live.failure = { cause: error };
+            let reportingFailure;
+            try {
+                await runtime?.details?.flush();
+            }
+            catch (failure) {
+                reportingFailure = { cause: failure };
+            }
+            if (activeMapper)
+                yield* activeMapper.flush();
+            if (reportingFailure !== undefined)
+                throw reportingFailure.cause;
             throw error;
         }
         finally {
@@ -269,7 +302,41 @@ export function apply(ctx, live) {
             throw new NeedError('ATTACHMENT_REQUIRED', '我需要官方附件组件读取这张图片', '官方attachments.readImage');
         return attachments.readImage(ref, signal);
     };
-    const adapter = new RemoteAgentsAdapter(config, agent => connectProvider(get, { agent, notice: createWorkspaceNoticeConsumer(ctx, agent), open: brokerFactory(get, undefined, config) }), dshApproval(ctx), agent => agent.name[language], readImage);
+    const openByAgent = new Map(AGENTS.map(agent => [agent.id, brokerFactory(get, undefined, config)]));
+    const detailManagers = new Map();
+    const adapter = new RemoteAgentsAdapter(config, agent => connectProvider(get, { agent, notice: createWorkspaceNoticeConsumer(ctx, agent), details: async (request, api, connection, target) => {
+            const profile = ctx.get('profileContext');
+            if (typeof profile?.dir !== 'string')
+                throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用：缺少官方profile目录。', '官方profileContext.dir');
+            let manager = detailManagers.get(profile.dir);
+            if (!manager) {
+                manager = createRemoteDetails({ profileDir: profile.dir, getApi: get });
+                detailManagers.set(profile.dir, manager);
+            }
+            return manager.open({ sessionId: request.sessionId, provider: agent.loginProvider, identity: `${target.username}@${target.host}:${target.port}`, connection });
+        }, open: async (...args) => {
+            const runtime = await openByAgent.get(agent.id)(...args);
+            runtime.detailContext = () => {
+                const events = args[2].sessionId ? ctx.get('agents')?.get(SessionId(args[2].sessionId))?.session.snapshotEvents() : undefined;
+                let turn = null, step = null;
+                for (const event of events ?? []) {
+                    if (event.type === 'turn/start') {
+                        turn = event.data.turn;
+                        step = null;
+                    }
+                    else if (event.type === 'turn/end') {
+                        turn = null;
+                        step = null;
+                    }
+                    else if (event.type === 'step/start' && event.data.turn === turn)
+                        step = event.data.step;
+                    else if (event.type === 'step/end')
+                        step = null;
+                }
+                return { turn, step };
+            };
+            return runtime;
+        } }), dshApproval(ctx), agent => agent.name[language], readImage);
     const ids = AGENTS.map(agent => agent.id);
     const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: settingsNamespace, settingsPath: [] }));
     const directory = ctx.llm.registerConfigurableProviders(entries());

package/dist/input.js

@@ -1,9 +1,9 @@
 import { NeedError } from "./remote.js";
-import { isWorkspaceNoticeMessage } from "./workspace-notice.js";
+import { isWorkspaceNoticeMessage, withoutWorkspaceNotice } from "./workspace-notice.js";
 /** The attachment service supplies verified bytes; client paths never cross SSH. */
 export async function prepareInput(options, readImage) {
     options.signal?.throwIfAborted();
-    const messages = options.messages.filter(message => !isWorkspaceNoticeMessage(message));
+    const messages = options.messages.filter(message => !isWorkspaceNoticeMessage(message)).map(withoutWorkspaceNotice);
     const context = [];
     if (options.system)
         context.push('系统上下文：\n' + options.system);

package/dist/mapping.d.ts

@@ -1,6 +1,7 @@
 import type { StreamChunk } from '@deepseek-ai/dsh-llm';
 import type { PromptResponse, SessionUpdate } from '@agentclientprotocol/sdk/unstable';
 import type { ThreadEvent } from '@openai/codex-sdk';
+import { type SanitizedObservation } from './conversation-details.ts';
 /** Persist alongside the exact remote session identity; null means no trusted baseline. */
 export type UsageSnapshot = {
     version: 1;
@@ -18,23 +19,28 @@ export type UsageSnapshot = {
     /** A response was missing or unusable; the next complete response only re-establishes a baseline. */
     gap?: true;
 };
-/** Remote tools are reported as text; they must never become local DSH tool invocations. */
+/** Only model text enters DSH blocks; remote operations remain diagnostic observations. */
 export declare class StreamMapper {
     private index;
+    private active;
     private seen;
     private baseline;
+    private readonly observations;
+    private readonly onDiagnostic;
     /** Omitted argument is exclusively for a known new session; pass null on unknown resume. */
-    constructor(previousUsage?: UsageSnapshot | null);
+    constructor(previousUsage?: UsageSnapshot | null, onDiagnostic?: (observation: Readonly<SanitizedObservation>) => void);
     get usageSnapshot(): UsageSnapshot | null;
+    get diagnostics(): readonly Readonly<SanitizedObservation>[];
+    private diagnostic;
+    private usageWarning;
     text(text: string, reasoning?: boolean): StreamChunk[];
+    /** Close the current text or reasoning block once, before the stream settles. */
+    flush(): StreamChunk[];
     acp(update: SessionUpdate): StreamChunk[];
     /** ACP usage and the fixed Claude quota both accumulate across the session, not per turn. */
     acpResponse(response: PromptResponse): StreamChunk[];
     private usageGap;
     private cumulativeUsage;
     private usage;
-    private content;
-    private toolContent;
-    private meta;
     sdk(event: ThreadEvent): StreamChunk[];
 }

package/dist/mapping.js

@@ -1,89 +1,117 @@
 import { NeedError } from "./remote.js";
+import { sanitizeObservation } from "./conversation-details.js";
 const usageCounters = ['inputTokens', 'outputTokens', 'cachedReadTokens', 'cachedWriteTokens', 'thoughtTokens', 'totalTokens'];
 const optionalUsageCounters = ['cachedReadTokens', 'cachedWriteTokens', 'thoughtTokens', 'totalTokens'];
-/** Remote tools are reported as text; they must never become local DSH tool invocations. */
+/** Only model text enters DSH blocks; remote operations remain diagnostic observations. */
 export class StreamMapper {
     index = 0;
+    active;
     seen = new Map();
     baseline;
+    observations = [];
+    onDiagnostic;
     /** Omitted argument is exclusively for a known new session; pass null on unknown resume. */
-    constructor(previousUsage = { version: 1, kind: 'zero' }) {
+    constructor(previousUsage = { version: 1, kind: 'zero' }, onDiagnostic) {
         if (previousUsage !== null && !validUsageSnapshot(previousUsage))
             throw new NeedError('USAGE_BASELINE_INVALID', '已保存的远端累计用量基线无效，不能重复结算历史用量', '与原远端会话关联的有效用量快照');
         this.baseline = previousUsage === null ? null : { ...previousUsage };
+        this.onDiagnostic = onDiagnostic;
     }
     get usageSnapshot() { return this.baseline === null ? null : { ...this.baseline }; }
+    get diagnostics() {
+        return Object.freeze(this.observations.map(observation => sanitizeObservation(observation)));
+    }
+    diagnostic(observation) {
+        const sanitized = sanitizeObservation(observation);
+        this.observations.push(sanitized);
+        this.onDiagnostic?.(sanitized);
+        return [];
+    }
+    usageWarning(summary) {
+        return this.diagnostic({ kind: 'usage', severity: 'warning', code: 'USAGE_UNAVAILABLE', summary });
+    }
     text(text, reasoning = false) {
         if (!text)
             return [];
-        const index = this.index++;
-        return [{ type: 'block-start', index, blockType: reasoning ? 'reasoning' : 'text' },
-            reasoning ? { type: 'reasoning-delta', index, text } : { type: 'text-delta', index, text },
-            { type: 'block-end', index, block: { type: reasoning ? 'reasoning' : 'text', text } }];
+        const type = reasoning ? 'reasoning' : 'text';
+        const chunks = this.active && this.active.type !== type ? this.flush() : [];
+        if (!this.active) {
+            this.active = { index: this.index++, type, text: '' };
+            chunks.push({ type: 'block-start', index: this.active.index, blockType: type });
+        }
+        const { index } = this.active;
+        this.active.text += text;
+        chunks.push(reasoning ? { type: 'reasoning-delta', index, text } : { type: 'text-delta', index, text });
+        return chunks;
+    }
+    /** Close the current text or reasoning block once, before the stream settles. */
+    flush() {
+        if (!this.active)
+            return [];
+        const { index, type, text } = this.active;
+        this.active = undefined;
+        return [{ type: 'block-end', index, block: { type, text } }];
     }
     acp(update) {
-        let chunks;
+        if (update.sessionUpdate === 'agent_message_chunk' || update.sessionUpdate === 'agent_thought_chunk') {
+            if (update.content.type === 'text' && typeof update.content.text === 'string') {
+                // The whole update preserves every extension layer without inventing a display mapping.
+                if (Object.keys(update).some(key => key !== 'sessionUpdate' && key !== 'content')
+                    || Object.keys(update.content).some(key => key !== 'type' && key !== 'text')) {
+                    this.diagnostic({ kind: 'extension', severity: 'info', code: 'ACP_MODEL_METADATA', summary: '远端模型消息扩展', method: 'session/update', payload: update });
+                }
+                return this.text(update.content.text, update.sessionUpdate === 'agent_thought_chunk');
+            }
+            return this.diagnostic({ kind: 'extension', severity: 'warning', code: 'ACP_CONTENT_UNSUPPORTED', summary: '远端非文本内容，需要对应的公开显示映射', method: 'session/update', payload: update });
+        }
+        let kind = 'session';
+        let code = 'ACP_SESSION_UPDATE';
+        let summary = '远端会话事件';
+        let severity = 'info';
         switch (update.sessionUpdate) {
-            case 'agent_message_chunk':
-            case 'agent_thought_chunk':
-                chunks = this.content(update.content, update.sessionUpdate === 'agent_thought_chunk');
-                break;
-            case 'user_message_chunk':
-                chunks = this.text('\n[远端输入回显]\n').concat(this.content(update.content));
+            case 'available_commands_update':
+                kind = 'commands';
+                code = 'ACP_COMMANDS';
+                summary = '远端命令与技能目录';
                 break;
             case 'tool_call':
             case 'tool_call_update':
-                chunks = this.text(`\n[远端工具] ${update.title ?? update.toolCallId} · ${toolStatus(update.status)}\n`);
-                for (const content of update.content ?? [])
-                    chunks.push(...this.toolContent(content));
+                kind = 'tool';
+                code = 'ACP_TOOL';
+                summary = '远端工具事件';
                 break;
             case 'usage_update':
-                chunks = this.text(`\n[远端上下文] ${update.used}/${update.size} 令牌${update.cost ? ` · 累计费用 ${update.cost.amount} ${update.cost.currency}` : ''}；生成用量尚未提供，等待远端本轮真实计数。\n`);
+                kind = 'usage';
+                code = 'ACP_USAGE_CONTEXT';
+                summary = '远端上下文占用，不替代生成用量';
                 break;
-            case 'plan':
-                chunks = this.text('\n[远端计划]\n' + update.entries.map(e => `${planStatus(e.status)}: ${e.content}`).join('\n') + '\n');
+            case 'notice':
+                kind = 'notice';
+                code = 'ACP_NOTICE';
+                summary = '远端通知';
                 break;
+            case 'user_message_chunk':
+            case 'plan':
             case 'plan_update':
-                chunks = this.text('\n[远端计划更新]\n' + (update.plan.type === 'markdown' ? update.plan.content : update.plan.type === 'file' ? `远端计划 URI（仅供核查）：${plainUri(update.plan.uri)}` : update.plan.entries.map(e => `${planStatus(e.status)}: ${e.content}`).join('\n')) + '\n');
-                break;
             case 'plan_removed':
-                chunks = this.text(`\n[远端计划] 已移除计划 ${update.planId}\n`);
-                break;
-            case 'notice':
-                chunks = this.text(`\n[远端通知] ${update.title}${update.description ? ': ' + update.description : ''}\n`);
-                break;
             case 'current_mode_update':
-                chunks = this.text(`\n[远端模式] ${update.currentModeId}\n`);
-                break;
-            case 'available_commands_update':
-                chunks = this.text('\n[远端命令] ' + update.availableCommands.map(c => `${c.name}${c.description ? `：${c.description}` : ''}`).join('；') + '\n');
-                break;
             case 'config_option_update':
-                chunks = this.text('\n[远端配置] ' + update.configOptions.map(c => c.name).join('、') + '已更新；首版通过远端官方配置管理。\n');
-                break;
             case 'session_info_update':
-                chunks = this.text(`\n[远端会话信息] ${update.title ?? '会话信息已更新'}\n`);
-                break;
             case 'compaction_update':
-                chunks = this.text(`\n[远端上下文整理] ${update.status}\n`);
-                break;
             case 'compaction_summary_chunk':
-                chunks = this.text('\n[远端上下文摘要]\n').concat(this.content(update.content));
-                break;
             case 'session_message_chunk':
-                chunks = this.text('\n[远端会话消息]\n').concat(this.content(update.content));
-                break;
-            case 'session_message':
-                chunks = this.text('\n[远端会话消息]\n');
-                for (const content of update.content ?? [])
-                    chunks.push(...this.content(content));
-                break;
-            default: chunks = this.text(`\n[远端事件] 首版不支持此事件：${safeLabel(update.sessionUpdate)}；需要对应的公开显示映射。\n`);
+            case 'session_message': break;
+            default:
+                kind = 'extension';
+                code = 'ACP_EVENT_UNSUPPORTED';
+                severity = 'warning';
+                summary = '远端未知事件，需要对应的公开显示映射';
         }
-        return chunks.concat(this.meta(update._meta));
+        return this.diagnostic({ kind, severity, code, summary, method: 'session/update', payload: update });
     }
     /** ACP usage and the fixed Claude quota both accumulate across the session, not per turn. */
     acpResponse(response) {
+        this.diagnostic({ kind: 'usage', severity: 'info', code: 'ACP_PROMPT_RESPONSE', summary: '远端响应与真实用量', method: 'session/prompt', payload: response });
         const quota = record(response._meta?.quota);
         const tokens = record(quota?.token_count);
         const usage = response.usage;
@@ -98,16 +126,16 @@ export class StreamMapper {
         }
         else {
             this.usageGap();
-            chunks = this.text('\n[远端用量] 本轮生成用量未提供；上下文占用不能替代输入或输出计数。\n');
+            chunks = this.usageWarning('\n[远端用量] 本轮生成用量未提供；上下文占用不能替代输入或输出计数。\n');
         }
-        return chunks.concat(this.meta(response._meta, ['quota']));
+        return chunks;
     }
     usageGap() { this.baseline = this.baseline?.kind === 'cumulative' ? { ...this.baseline, gap: true } : null; }
     cumulativeUsage(source, input, output, read, write, thought, total) {
         const values = [input, output, ...(read == null ? [] : [read]), ...(write == null ? [] : [write]), ...(thought == null ? [] : [thought]), ...(total == null ? [] : [total])];
         if (!values.every(validCount)) {
             this.usageGap();
-            return this.text('\n[远端用量] 远端累计计数无效，本轮未记录生成用量；需要有效的输入、输出与缓存计数。\n');
+            return this.usageWarning('\n[远端用量] 远端累计计数无效，本轮未记录生成用量；需要有效的输入、输出与缓存计数。\n');
         }
         const current = { version: 1, kind: 'cumulative', source, inputTokens: input, outputTokens: output,
             ...(read == null ? {} : { cachedReadTokens: read }), ...(write == null ? {} : { cachedWriteTokens: write }),
@@ -116,21 +144,21 @@ export class StreamMapper {
         if (previous?.kind === 'cumulative' && previous.source === source) {
             if (usageCounters.some(key => current[key] !== undefined && previous[key] !== undefined && current[key] < previous[key])) {
                 this.usageGap();
-                return this.text('\n[远端用量] 远端累计计数发生回退，本轮未记录生成用量；已保留此前高水位，需要核对远端会话计数。\n');
+                return this.usageWarning('\n[远端用量] 远端累计计数发生回退，本轮未记录生成用量；已保留此前高水位，需要核对远端会话计数。\n');
             }
             if (optionalUsageCounters.some(key => previous[key] !== undefined && current[key] === undefined)) {
                 this.baseline = { ...previous, ...current, gap: true };
-                return this.text('\n[远端用量] 可选累计计数缺失，本轮未记录生成用量；未把缺失值补为零，等待完整计数重建基线。\n');
+                return this.usageWarning('\n[远端用量] 可选累计计数缺失，本轮未记录生成用量；未把缺失值补为零，等待完整计数重建基线。\n');
             }
         }
         const sum = current.inputTokens + current.outputTokens + (current.cachedReadTokens ?? 0) + (current.cachedWriteTokens ?? 0);
         if (!Number.isSafeInteger(sum) || (current.totalTokens !== undefined && current.totalTokens !== sum) || (current.thoughtTokens !== undefined && current.thoughtTokens > current.outputTokens)) {
             this.usageGap();
-            return this.text('\n[远端用量] 输入、输出、缓存与合计计数不一致，本轮未记录生成用量；需要远端提供语义一致的真实计数。\n');
+            return this.usageWarning('\n[远端用量] 输入、输出、缓存与合计计数不一致，本轮未记录生成用量；需要远端提供语义一致的真实计数。\n');
         }
         this.baseline = current;
         if (previous === null || previous.kind === 'cumulative' && (previous.source !== source || previous.gap || optionalUsageCounters.some(key => previous[key] === undefined && current[key] !== undefined))) {
-            return this.text('\n[远端用量] 已建立当前累计用量基线；本轮未记录生成用量，避免把无法核对的历史累计重复结算。\n');
+            return this.usageWarning('\n[远端用量] 已建立当前累计用量基线；本轮未记录生成用量，避免把无法核对的历史累计重复结算。\n');
         }
         if (previous.kind === 'zero')
             return this.usage(current.inputTokens, current.outputTokens, current.cachedReadTokens, current.cachedWriteTokens, current.thoughtTokens, current.totalTokens);
@@ -142,59 +170,37 @@ export class StreamMapper {
     usage(input, output, read, write, thought, total) {
         const values = [input, output, ...(read == null ? [] : [read]), ...(write == null ? [] : [write]), ...(thought == null ? [] : [thought]), ...(total == null ? [] : [total])];
         if (!values.every(n => typeof n === 'number' && Number.isSafeInteger(n) && n >= 0)) {
-            return this.text('\n[远端用量] 远端真实计数无效，本轮未记录生成用量；需要有效的输入、输出与缓存计数。\n');
+            return this.usageWarning('\n[远端用量] 远端真实计数无效，本轮未记录生成用量；需要有效的输入、输出与缓存计数。\n');
         }
         const sum = input + output + (read ?? 0) + (write ?? 0);
         if ((total != null && total !== sum) || (thought != null && thought > output)) {
-            return this.text('\n[远端用量] 输入、输出、缓存与合计计数不一致，本轮未记录生成用量；需要远端提供语义一致的真实计数。\n');
+            return this.usageWarning('\n[远端用量] 输入、输出、缓存与合计计数不一致，本轮未记录生成用量；需要远端提供语义一致的真实计数。\n');
         }
         return [{ type: 'usage', usage: { inputTokens: input, outputTokens: output,
                     ...(read == null ? {} : { cacheReadTokens: read }), ...(write == null ? {} : { cacheWriteTokens: write }),
                     ...(thought == null ? {} : { reasoningTokens: thought }) } }];
     }
-    content(content, reasoning = false) {
-        let chunks;
-        switch (content.type) {
-            case 'text':
-                chunks = this.text(content.text, reasoning);
-                break;
-            case 'image':
-                chunks = this.text(`\n[远端图片] 收到 ${content.mimeType} 图片内容；需要持久附件引用才能在官方界面显示，首版未生成附件。${content.uri ? `远端 URI（仅供核查）：${plainUri(content.uri)}` : ''}\n`);
-                break;
-            case 'audio':
-                chunks = this.text(`\n[远端音频] 收到 ${content.mimeType} 音频内容；首版尚无持久音频附件适配，需要远端提供文字或可持久引用。\n`);
-                break;
-            case 'resource_link':
-                chunks = this.text(`\n[远端资源] ${content.name}${content.description ? `：${content.description}` : ''}；URI（仅供核查，不作为员工设备本地资源打开）：${plainUri(content.uri)}\n`);
-                break;
-            case 'resource':
-                chunks = this.text(`\n[远端嵌入资源] URI（仅供核查）：${plainUri(content.resource.uri)}\n`);
-                if ('text' in content.resource)
-                    chunks.push(...this.text(content.resource.text));
-                else
-                    chunks.push(...this.text('远端返回二进制资源；首版需要持久附件适配，尚未展示其字节内容。\n'));
-                chunks.push(...this.meta(content.resource._meta));
-                break;
-            default: chunks = this.text(`\n[远端内容] 首版不支持此内容类型：${safeLabel(content.type)}；需要对应的公开内容映射。\n`);
-        }
-        return chunks.concat(this.meta(content._meta));
-    }
-    toolContent(content) {
-        switch (content.type) {
-            case 'content': return this.content(content.content).concat(this.meta(content._meta));
-            case 'diff': return this.text(`\n[远端文件修改] ${content.path}\n原内容：\n${content.oldText ?? '远端未提供'}\n新内容：\n${content.newText}\n`).concat(this.meta(content._meta));
-            case 'terminal': return this.text(`\n[远端终端] ${content.terminalId}；首版未创建员工设备本地终端，需要远端提供文本输出。\n`).concat(this.meta(content._meta));
-            default: return this.text('\n[远端工具内容] 首版不支持此内容，需要对应的公开显示映射。\n');
-        }
-    }
-    meta(meta, known = []) {
-        const fields = record(meta);
-        if (!fields)
-            return [];
-        const names = Object.keys(fields).filter(key => !known.includes(key));
-        return names.length ? this.text(`\n[远端扩展] 首版不支持这些扩展字段：${names.map(safeLabel).join('、')}；扩展值未展开，需要公开的对应映射。\n`) : [];
-    }
     sdk(event) {
+        if (event.type === 'item.started' || event.type === 'item.updated' || event.type === 'item.completed') {
+            const item = event.item;
+            if ((item.type === 'agent_message' || item.type === 'reasoning') && typeof item.text === 'string') {
+                if (Object.keys(event).some(key => key !== 'type' && key !== 'item')
+                    || Object.keys(item).some(key => key !== 'id' && key !== 'type' && key !== 'text')) {
+                    this.diagnostic({ kind: 'extension', severity: 'info', code: 'SDK_MODEL_METADATA', summary: '远端模型消息扩展', method: event.type, payload: event });
+                }
+                const previous = this.seen.get(item.id) ?? '';
+                if (!item.text.startsWith(previous))
+                    throw new NeedError('EVENT_REWRITE_UNSUPPORTED', '远端更改了已输出的文本，当前流不能无损替换', '支持文本替换的展示适配器');
+                this.seen.set(item.id, item.text);
+                return this.text(item.text.slice(previous.length), item.type === 'reasoning');
+            }
+            const tool = item.type === 'command_execution' || item.type === 'file_change' || item.type === 'mcp_tool_call';
+            this.diagnostic({ kind: tool ? 'tool' : 'session', severity: item.type === 'error' ? 'warning' : 'info', code: tool ? 'SDK_TOOL' : 'SDK_ITEM', summary: '远端非模型事件', method: event.type, payload: event });
+            if (item.type === 'error')
+                throw new NeedError('ONESHOT_FAILED', 'Codex 返回了错误，根因未查明', '远端诊断');
+            return [];
+        }
+        this.diagnostic({ kind: event.type === 'turn.completed' ? 'usage' : 'session', severity: event.type === 'error' || event.type === 'turn.failed' ? 'warning' : 'info', code: 'SDK_EVENT', summary: '远端会话事件', method: event.type, payload: event });
         if (event.type === 'turn.completed') {
             const u = event.usage;
             const write = u.cache_write_input_tokens ?? 0;
@@ -205,30 +211,6 @@ export class StreamMapper {
                         ...(u.cache_write_input_tokens !== undefined ? { cacheWriteTokens: write } : {}),
                         ...(u.reasoning_output_tokens !== undefined ? { reasoningTokens: u.reasoning_output_tokens } : {}) } }];
         }
-        if (event.type !== 'item.started' && event.type !== 'item.updated' && event.type !== 'item.completed')
-            return [];
-        const item = event.item;
-        if (item.type === 'agent_message' || item.type === 'reasoning') {
-            const previous = this.seen.get(item.id) ?? '';
-            if (!item.text.startsWith(previous))
-                throw new NeedError('EVENT_REWRITE_UNSUPPORTED', '远端更改了已输出的文本，当前流不能无损替换', '支持文本替换的展示适配器');
-            this.seen.set(item.id, item.text);
-            return this.text(item.text.slice(previous.length), item.type === 'reasoning');
-        }
-        if (item.type === 'command_execution' || item.type === 'file_change' || item.type === 'mcp_tool_call') {
-            const key = `tool:${item.id}`;
-            if (this.seen.get(key) === item.status)
-                return [];
-            this.seen.set(key, item.status);
-            const title = item.type === 'command_execution' ? item.command : item.type === 'file_change' ? item.changes.map(c => c.path).join(', ') : `${item.server}/${item.tool}`;
-            return this.text(`\n[远端工具] ${title} · ${item.status}\n`);
-        }
-        if (item.type === 'web_search')
-            return this.text(`\n[远端搜索] ${item.query}\n`);
-        if (item.type === 'todo_list')
-            return this.text('\n[远端计划]\n' + item.items.map(i => `${i.completed ? '完成' : '待做'}: ${i.text}`).join('\n') + '\n');
-        if (item.type === 'error')
-            throw new NeedError('ONESHOT_FAILED', 'Codex 返回了错误，根因未查明', '远端诊断');
         return [];
     }
 }
@@ -246,21 +228,3 @@ function validUsageSnapshot(value) {
     return snapshot.gap === true || Number.isSafeInteger(sum) && (snapshot.totalTokens === undefined || snapshot.totalTokens === sum) && (snapshot.thoughtTokens === undefined || snapshot.thoughtTokens <= snapshot.outputTokens);
 }
 function record(value) { return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
-function safeLabel(value) { return value.replaceAll(/[\r\n\x00-\x1f\x7f]/g, ' '); }
-function plainUri(uri) {
-    let result = uri;
-    try {
-        const parsed = new URL(uri);
-        parsed.username = '';
-        parsed.password = '';
-        parsed.search = '';
-        parsed.hash = '';
-        result = parsed.toString();
-    }
-    catch {
-        result = uri.split(/[?#]/)[0];
-    }
-    return '`' + safeLabel(result).replaceAll('`', '\u02cb') + '`';
-}
-function toolStatus(status) { return { pending: '待处理', in_progress: '处理中', completed: '完成', failed: '失败' }[status ?? ''] ?? '更新'; }
-function planStatus(status) { return { pending: '待做', in_progress: '进行中', completed: '完成' }[status] ?? safeLabel(status); }

package/dist/presentation.js

@@ -5,6 +5,10 @@ export const TEST_HOST_NOTICE = '远程主机正在使用测试配置，遇到
 /** Employee failures use business language; diagnostic codes remain separately available. */
 export function employeeFailure(code) {
     const messages = {
+        TECHNICAL_DETAILS_UNAVAILABLE: '技术详情暂不可用，请更新远程主机连接组件。',
+        REMOTE_DETAIL_STORAGE_FAILED: '技术详情保存失败，本轮已停止，请联系管理员检查。',
+        REMOTE_DETAIL_DELIVERY_UNKNOWN: '技术详情的持久结果无法核对，本轮已停止。',
+        REMOTE_DETAIL_TOO_LARGE: '技术详情超过已配置的单事件容量，本轮已停止；请联系管理员调整conversationDetails.maxEventBytes。',
         DEPENDENCY_REQUIRED: CONNECTION_REQUIRED,
         LOGIN_REQUIRED: '需要登录，请到设置 → 远程主机连接 点登录',
         LOGIN_COMPLETED: '登录已完成，请重新发送本轮内容。',

package/dist/provider.d.ts

@@ -7,6 +7,8 @@ import type { BrokerTransport, BrokerSettings } from './broker.ts';
 import type { Interaction, Invocation } from './interaction.ts';
 import { type AgentDefinition } from './agents.ts';
 import type { NativeWorkspaceApi, SessionProjectTarget, WorkspaceNotice, LoginProvider } from './connect-contract.ts';
+import type { DetailChannel } from './remote-details.ts';
+import type { WorkspaceNoticePresentation } from './workspace-notice.ts';
 export interface Runtime {
     identity: string;
     cwd: string;
@@ -24,6 +26,12 @@ export interface Runtime {
         revision: number;
     };
     connection?: ConnectionState;
+    workspaceNotice?: WorkspaceNoticePresentation;
+    details?: DetailChannel;
+    detailContext?: () => {
+        turn: string | number | null;
+        step: string | number | null;
+    };
 }
 export interface RuntimeRequest extends Invocation {
     mode: 'session' | 'one-shot';
@@ -80,7 +88,7 @@ type Result<T> = {
     };
 };
 /** 消费正式connect-api 0.7公开子集；X不响应L登录票据、不直接调用登录。 */
-export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'getLoginPromptState' | 'requestLoginPrompt' | 'refreshLoginPrompts'>, Partial<NativeWorkspaceApi> {
+export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'getLoginPromptState' | 'requestLoginPrompt' | 'refreshLoginPrompts'>, Partial<NativeWorkspaceApi>, Partial<Pick<LConnectApi, 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails'>> {
     getState?(): ConnectState;
     getSshTarget(): Promise<Result<ConnectTarget>>;
     checkLogin(provider: LoginProvider): Promise<Result<{
@@ -124,12 +132,13 @@ export declare function requireNativeWorkspace(api: ConnectApi): asserts api is
 export declare function offerLogin(connect: ConnectApi, request: Invocation, currentApi?: () => ConnectApi | undefined, agent?: AgentDefinition): Promise<void>;
 export interface NoticeConsumer {
     reconcile(request: RuntimeRequest, api: ConnectApi): Promise<void>;
-    deliver(notice: WorkspaceNotice, resolved: SessionProjectTarget, request: RuntimeRequest, api: ConnectApi): Promise<void>;
+    deliver(notice: WorkspaceNotice, resolved: SessionProjectTarget, request: RuntimeRequest, api: ConnectApi): Promise<WorkspaceNoticePresentation | void>;
 }
 export declare function sameTarget(a: ConnectTarget, b: ConnectTarget): boolean;
 export declare function connectProvider(get: () => ConnectApi | undefined, options?: {
     agent?: AgentDefinition;
     ask?: Interaction;
     notice?: NoticeConsumer;
+    details?: (request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<DetailChannel>;
     open?: (target: ConnectTarget, project: Project, request: RuntimeRequest) => Promise<Runtime>;
 }): RuntimeProvider;