@ai-workbench/remote-agent 0.8.0 → 0.8.2

package/dist/login-diagnostic.js

@@ -0,0 +1,29 @@
+import { validOfficialReason } from "./auth-reason.js";
+import { createHash } from 'node:crypto';
+const code = (value) => typeof value === 'string' && /^[A-Z][A-Z0-9_]*$/u.test(value) ? value : null;
+export function loginDiagnostic(source, reason, provider, connection, state, officialReason) {
+    const value = (brand) => typeof state.logins?.[brand] === 'boolean' ? state.logins[brand] : state.logins?.[brand] === undefined ? 'absent' : 'invalid';
+    const rawReason = officialReason ?? state.providerNeeds?.[provider]?.officialReason;
+    const safeReason = typeof rawReason !== 'string' ? {} : validOfficialReason(rawReason) ? { officialReason: rawReason } : { officialReasonRejected: { bytes: Buffer.byteLength(rawReason, 'utf8'), sha256: createHash('sha256').update(rawReason).digest('hex') } };
+    return { version: 1, source, reason, provider, ...safeReason, connection: { instanceId: connection.instanceId, phase: connection.phase, epoch: connection.epoch }, login: { instanceId: state.instanceId, phase: state.phase, revision: state.revision, provider: state.provider ?? null, logins: { claude: value('claude'), codex: value('codex') }, queuedProviders: state.queuedProviders ?? [], checkingProviders: Array.isArray(state.checkingProviders) ? state.checkingProviders.filter(p => p === 'claude' || p === 'codex') : [], providerNeeds: { claude: code(state.providerNeeds?.claude?.code), codex: code(state.providerNeeds?.codex?.code) }, code: code(state.technicalDetails?.code) } };
+}
+export function loginReason(state, connection, provider) {
+    if (state.instanceId !== connection.instanceId)
+        return 'LOGIN_INSTANCE_MISMATCH';
+    if (state.phase === 'blocked')
+        return 'LOGIN_PHASE_BLOCKED';
+    if (state.phase === 'disposed')
+        return 'LOGIN_PHASE_DISPOSED';
+    if (state.queuedProviders?.includes(provider))
+        return 'LOGIN_QUEUED';
+    if (state.checkingProviders.includes(provider))
+        return 'LOGIN_CHECKING';
+    if (state.phase === 'authorizing' && state.provider === provider)
+        return 'LOGIN_AUTHORIZING';
+    if (state.providerNeeds[provider])
+        return 'LOGIN_PROVIDER_NEED';
+    if (typeof state.logins?.[provider] !== 'boolean')
+        return 'LOGIN_VALUE_INVALID';
+    if (!state.logins[provider])
+        return 'LOGIN_REQUIRED';
+}

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

@@ -1,12 +1,14 @@
 import type { AgentApp } from '@agentclientprotocol/sdk';
 import type { AgentApp as ExtendedAgentApp } from '@agentclientprotocol/sdk/unstable';
-import type { ConnectState, ConnectApi as LConnectApi, ConnectionState, LoginPromptState } from '@ai-workbench/connect/api';
+import type { ConnectState, ConnectNeed, ConnectApi as LConnectApi, ConnectionState, LoginPromptState } from '@ai-workbench/connect/api';
 export type { ConnectionState, LoginPromptState } from '@ai-workbench/connect/api';
 import type { OneShotRuntime } from './job.ts';
 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';
@@ -77,10 +85,10 @@ type Result<T> = {
         code: string;
         message: string;
         requires: string;
-    };
+    } & Pick<ConnectNeed, 'officialReason'>;
 };
 /** 消费正式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, 'onConnectionState' | 'onLoginPromptState' | '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;