@ai-workbench/remote-agent 0.0.0-stage → 0.8.1

package/dist/mapping.js

@@ -0,0 +1,230 @@
+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'];
+/** 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' }, 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 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) {
+        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 'available_commands_update':
+                kind = 'commands';
+                code = 'ACP_COMMANDS';
+                summary = '远端命令与技能目录';
+                break;
+            case 'tool_call':
+            case 'tool_call_update':
+                kind = 'tool';
+                code = 'ACP_TOOL';
+                summary = '远端工具事件';
+                break;
+            case 'usage_update':
+                kind = 'usage';
+                code = 'ACP_USAGE_CONTEXT';
+                summary = '远端上下文占用，不替代生成用量';
+                break;
+            case 'notice':
+                kind = 'notice';
+                code = 'ACP_NOTICE';
+                summary = '远端通知';
+                break;
+            case 'user_message_chunk':
+            case 'plan':
+            case 'plan_update':
+            case 'plan_removed':
+            case 'current_mode_update':
+            case 'config_option_update':
+            case 'session_info_update':
+            case 'compaction_update':
+            case 'compaction_summary_chunk':
+            case 'session_message_chunk':
+            case 'session_message': break;
+            default:
+                kind = 'extension';
+                code = 'ACP_EVENT_UNSUPPORTED';
+                severity = 'warning';
+                summary = '远端未知事件，需要对应的公开显示映射';
+        }
+        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;
+        let chunks;
+        if (usage) {
+            chunks = this.cumulativeUsage('usage', usage.inputTokens, usage.outputTokens, usage.cachedReadTokens, usage.cachedWriteTokens, usage.thoughtTokens, usage.totalTokens);
+        }
+        else if (tokens) {
+            // Fixed Claude adapter's quotaTokenCount: inputTokens excludes both
+            // cachedInputTokens (reads) and cachedWriteTokens (writes).
+            chunks = this.cumulativeUsage('quota', tokens.inputTokens, tokens.outputTokens, tokens.cachedInputTokens, tokens.cachedWriteTokens, undefined, tokens.totalTokens);
+        }
+        else {
+            this.usageGap();
+            chunks = this.usageWarning('\n[远端用量] 本轮生成用量未提供；上下文占用不能替代输入或输出计数。\n');
+        }
+        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.usageWarning('\n[远端用量] 远端累计计数无效，本轮未记录生成用量；需要有效的输入、输出与缓存计数。\n');
+        }
+        const current = { version: 1, kind: 'cumulative', source, inputTokens: input, outputTokens: output,
+            ...(read == null ? {} : { cachedReadTokens: read }), ...(write == null ? {} : { cachedWriteTokens: write }),
+            ...(thought == null ? {} : { thoughtTokens: thought }), ...(total == null ? {} : { totalTokens: total }) };
+        const previous = this.baseline;
+        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.usageWarning('\n[远端用量] 远端累计计数发生回退，本轮未记录生成用量；已保留此前高水位，需要核对远端会话计数。\n');
+            }
+            if (optionalUsageCounters.some(key => previous[key] !== undefined && current[key] === undefined)) {
+                this.baseline = { ...previous, ...current, gap: true };
+                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.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.usageWarning('\n[远端用量] 已建立当前累计用量基线；本轮未记录生成用量，避免把无法核对的历史累计重复结算。\n');
+        }
+        if (previous.kind === 'zero')
+            return this.usage(current.inputTokens, current.outputTokens, current.cachedReadTokens, current.cachedWriteTokens, current.thoughtTokens, current.totalTokens);
+        const delta = (key) => current[key] === undefined ? undefined : current[key] - previous[key];
+        if (!usageCounters.some(key => (delta(key) ?? 0) !== 0))
+            return [];
+        return this.usage(delta('inputTokens'), delta('outputTokens'), delta('cachedReadTokens'), delta('cachedWriteTokens'), delta('thoughtTokens'), delta('totalTokens'));
+    }
+    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.usageWarning('\n[远端用量] 远端真实计数无效，本轮未记录生成用量；需要有效的输入、输出与缓存计数。\n');
+        }
+        const sum = input + output + (read ?? 0) + (write ?? 0);
+        if ((total != null && total !== sum) || (thought != null && thought > output)) {
+            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 }) } }];
+    }
+    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;
+            const uncached = u.input_tokens - u.cached_input_tokens - write;
+            if (![u.input_tokens, u.cached_input_tokens, write, u.output_tokens, uncached].every(n => Number.isSafeInteger(n) && n >= 0))
+                throw new NeedError('USAGE_INVALID', '远端用量计数不一致', '有效的 Codex 用量');
+            return [{ type: 'usage', usage: { inputTokens: uncached, cacheReadTokens: u.cached_input_tokens, outputTokens: u.output_tokens,
+                        ...(u.cache_write_input_tokens !== undefined ? { cacheWriteTokens: write } : {}),
+                        ...(u.reasoning_output_tokens !== undefined ? { reasoningTokens: u.reasoning_output_tokens } : {}) } }];
+        }
+        return [];
+    }
+}
+function validCount(value) { return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0; }
+function validUsageSnapshot(value) {
+    const snapshot = record(value);
+    if (snapshot?.version !== 1)
+        return false;
+    if (snapshot.kind === 'zero')
+        return Object.keys(snapshot).every(key => key === 'kind' || key === 'version');
+    if (snapshot.kind !== 'cumulative' || (snapshot.source !== 'usage' && snapshot.source !== 'quota') || (snapshot.gap !== undefined && snapshot.gap !== true)
+        || !validCount(snapshot.inputTokens) || !validCount(snapshot.outputTokens) || optionalUsageCounters.some(key => snapshot[key] !== undefined && !validCount(snapshot[key])))
+        return false;
+    const sum = snapshot.inputTokens + snapshot.outputTokens + (snapshot.cachedReadTokens ?? 0) + (snapshot.cachedWriteTokens ?? 0);
+    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; }

package/dist/oneshot.d.ts

@@ -0,0 +1,13 @@
+import { type ThreadEvent, type SandboxMode } from '@openai/codex-sdk';
+import { type OneShotRuntime } from './job.ts';
+export type { OneShotRuntime } from './job.ts';
+export interface OneShotOptions {
+    wrapperPath: string;
+    sshExecutable?: string;
+    sandboxMode?: SandboxMode;
+    approvalPolicy?: 'never';
+    /** Independent disposal signal for control/cleanup; not the already-cancelled turn signal. */
+    controlSignal?: AbortSignal;
+    onTiming?: (phase: string, elapsedMs: number) => void;
+}
+export declare function runOneShot(runtime: OneShotRuntime, options: OneShotOptions, prompt: string, resumeId?: string, signal?: AbortSignal): AsyncGenerator<ThreadEvent>;

package/dist/oneshot.js

@@ -0,0 +1,78 @@
+import { Codex } from '@openai/codex-sdk';
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { executeJob } from "./job.js";
+import { NeedError } from "./remote.js";
+export async function* runOneShot(runtime, options, prompt, resumeId, signal) {
+    if (!options.sandboxMode || options.approvalPolicy !== 'never')
+        throw new NeedError('SETTINGS_REQUIRED', '我需要管理员明确单次模式的沙箱及无交互审批设置', 'oneShotSandbox / oneShotApproval（待 owner 确认）');
+    signal?.throwIfAborted();
+    const started = performance.now();
+    const timing = (phase) => options.onTiming?.(phase, Math.round(performance.now() - started));
+    const dir = await mkdtemp(join(tmpdir(), 'aw-x-job-'));
+    const spec = { ...runtime, id: randomUUID().replaceAll('-', ''), sshExecutable: options.sshExecutable };
+    try {
+        timing('prepare-start');
+        const prepareSignal = signal && options.controlSignal ? AbortSignal.any([signal, options.controlSignal]) : signal ?? options.controlSignal;
+        if (await executeJob(spec, 'prepare', undefined, undefined, false, prepareSignal) !== 0)
+            throw new NeedError('ONESHOT_FAILED', '主机单次运行准备失败，根因未查明', '已安装的主机单次运行助手');
+        timing('prepare-complete');
+        signal?.throwIfAborted();
+        const file = join(dir, 'job.json');
+        await writeFile(file, JSON.stringify(spec), { mode: 0o600 });
+        const codex = new Codex({ codexPathOverride: options.wrapperPath, env: { PATH: process.env.PATH ?? '', AW_X_JOB_FILE: file } });
+        const threadOptions = { workingDirectory: runtime.cwd, sandboxMode: options.sandboxMode, approvalPolicy: options.approvalPolicy };
+        const thread = resumeId ? codex.resumeThread(resumeId, threadOptions) : codex.startThread(threadOptions);
+        timing('sdk-start');
+        const { events } = await thread.runStreamed(prompt, { signal });
+        let first = true;
+        let firstModel = true;
+        let completed = false;
+        for await (const event of events) {
+            const lifecycle = event;
+            if (lifecycle.type === 'aw.remote.lifecycle') {
+                if (lifecycle.phase === 'remote-run-ready' || lifecycle.phase === 'remote-codex-spawned')
+                    timing(lifecycle.phase);
+                continue;
+            }
+            if (first) {
+                timing('first-event');
+                first = false;
+            }
+            if (firstModel && (event.type === 'item.started' || event.type === 'item.updated' || event.type === 'item.completed') && (event.item.type === 'agent_message' || event.item.type === 'reasoning')) {
+                firstModel = false;
+                timing('first-model-output');
+            }
+            if (event.type === 'turn.failed' || event.type === 'error')
+                throw new NeedError('ONESHOT_FAILED', 'Codex 单次运行返回失败，根因未查明', '可用的主机 Codex 会话');
+            if (event.type === 'turn.completed')
+                completed = true;
+            yield event;
+        }
+        if (!completed)
+            throw new NeedError('ONESHOT_INCOMPLETE', '连接结束前未收到 turn.completed，结果不完整', '确认远端运行状态');
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw new NeedError('ABORTED', '本轮单次运行已取消', '重新开始或恢复已保存的线程');
+        if (error instanceof NeedError)
+            throw error;
+        throw new NeedError('ONESHOT_FAILED', 'SSH / Codex 单次运行失败，根因未查明', '有效的远端运行连接');
+    }
+    finally {
+        timing('cleanup-start');
+        let cleanupOk = false;
+        try {
+            cleanupOk = (await executeJob(spec, 'kill', undefined, undefined, false, options.controlSignal)) === 0;
+        }
+        catch { /* No fallback: every failed control attempt below reports cleanup unconfirmed. */ }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+        timing('cleanup-complete');
+        if (!cleanupOk)
+            throw new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '连接中断，无法确认远端进程已结束；需要管理员确认此轮状态', '恢复连接并结束对应运行');
+    }
+}

package/dist/presentation.d.ts

@@ -0,0 +1,6 @@
+/** Functional wording from connect-api appendix D1-D3 (L0.5.1 candidate). */
+export declare const REMOTE_CODEX_NAME = "Codex\uFF08\u8FDC\u7A0B\u4E3B\u673A\uFF09";
+export declare const CONNECTION_REQUIRED = "\u8FDC\u7A0B\u4E3B\u673A\u8FDE\u63A5\u7EC4\u4EF6\u6CA1\u6709\u88C5\u597D\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002";
+export declare const TEST_HOST_NOTICE = "\u8FDC\u7A0B\u4E3B\u673A\u6B63\u5728\u4F7F\u7528\u6D4B\u8BD5\u914D\u7F6E\uFF0C\u9047\u5230\u95EE\u9898\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002";
+/** Employee failures use business language; diagnostic codes remain separately available. */
+export declare function employeeFailure(code: string): string;

package/dist/presentation.js

@@ -0,0 +1,45 @@
+/** Functional wording from connect-api appendix D1-D3 (L0.5.1 candidate). */
+export const REMOTE_CODEX_NAME = 'Codex（远程主机）';
+export const CONNECTION_REQUIRED = '远程主机连接组件没有装好，请联系管理员。';
+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: '登录已完成，请重新发送本轮内容。',
+        LOGIN_FAILED: '登录未完成，请到设置 → 远程主机连接 点登录；如仍有问题，请联系管理员。',
+        AUTH_STATUS_INVALID: '登录检查没有返回有效结果，请重新检查；如仍有问题，请联系管理员。',
+        HOST_OFFLINE: '暂时无法连接远程主机，请联系管理员。',
+        CONNECTION_LOST: '远程主机连接已中断，请检查网络后重新连接。',
+        SETTINGS_REQUIRED: '远程主机连接尚未设置好，请联系管理员。',
+        CONNECT_API_MISMATCH: '远程主机连接组件需要更新，请联系管理员。',
+        ENROLLMENT_REQUIRED: '我需要连接资料，请联系管理员发放。',
+        NETWORK_KEY_INVALID: '连接资料已经失效，请联系管理员核对并重新发放。',
+        EMPLOYEE_MISSING: '远程主机账号还没有开通，请联系管理员。',
+        DISPOSED: '远程主机连接已经关闭，请重新连接远程主机。',
+        ENROLLMENT_INVALID: '远程主机开通信息需要更新，请联系管理员。',
+        HOST_KEY_MISMATCH: '远程主机连接信息需要管理员核对。',
+        HOST_TRUST_REQUIRED: '远程主机连接信息还未准备好，请联系管理员。',
+        POLICY_DENIED: '这个账号暂时不能使用，请联系公司账号管理员。',
+        SESSION_CONTEXT_MISMATCH: '远程主机连接已改变，请重新开始本次检查。',
+        ABORTED: '本次检查已取消。',
+        CONFIRMATION_REQUIRED: '请先选择是否打开授权窗口。',
+        CONTEXT_UNSUPPORTED: '远程 Codex 暂不支持这类会话内容，请联系管理员。',
+        CONTENT_UNSUPPORTED: '远程 Codex 暂不支持这类附件，请联系管理员。',
+        SYSTEM_PROMPT_UPDATE_PENDING: 'Claude原会话无法保证立即应用已变化的系统或开发者要求，本轮未发送；请新建会话应用新要求。',
+        SYSTEM_PROMPT_UNSUPPORTED: '远端没有声明系统与开发者上下文能力，本轮未发送；需要管理员提供支持该能力的远端适配器。',
+        SYSTEM_PROMPT_UPDATE_UNSUPPORTED: '远端不能更新原会话的系统与开发者要求，本轮未发送；请新建会话。',
+        PROMPT_CONTENT_UNSUPPORTED: '远端没有声明这类输入能力，本轮未发送；请使用受支持的内容或联系管理员。',
+        ATTACHMENT_REQUIRED: '我需要官方附件组件读取这张图片，请联系管理员检查组件。',
+        ATTACHMENT_INVALID: '图片附件没有返回匹配的已核验内容，本轮未发送；请重新添加图片或联系管理员。',
+        ACP_MESSAGE_TOO_LARGE: '本轮输入超过会话消息容量，未截断或发送；请联系管理员调整acpMaxMessageBytes。',
+        ACP_CLIENT_LOST: '我需要管理员核对并结束遗留的主机会话；当前保留原进程，没有代答旧审批。',
+        ONESHOT_CONTEXT_REQUIRED: '首版单次模式不支持图片或系统与开发者上下文，请改用会话模式。',
+    };
+    return messages[code] ?? `远程主机暂时无法完成这次操作，请联系管理员。技术详情：诊断代码 ${code}`;
+}

package/dist/provider-locale.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+/** Matches the official locale service's English fallback before a client reports. */
+export declare const PROVIDER_NAMES: Readonly<{
+    en: "Codex (Remote Host)";
+    zh: "Codex（远程主机）";
+}>;
+export type ProviderLanguage = 'en' | 'zh';
+/** Local client presentation only: no host login, model call or locale preference write. */
+export declare class ProviderLocaleRemote extends TypertRemoteService {
+    private readonly update;
+    private language;
+    private disposed;
+    constructor(ctx: Context, update: (language: ProviderLanguage) => void);
+    setLocale(language: unknown, signal: AbortSignal): Promise<{
+        language: ProviderLanguage;
+        name: string;
+    }>;
+}

package/dist/provider-locale.js

@@ -0,0 +1,73 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { NeedError } from "./remote.js";
+/** Matches the official locale service's English fallback before a client reports. */
+export const PROVIDER_NAMES = Object.freeze({ en: 'Codex (Remote Host)', zh: 'Codex（远程主机）' });
+/** Local client presentation only: no host login, model call or locale preference write. */
+let ProviderLocaleRemote = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _setLocale_decorators;
+    return class ProviderLocaleRemote extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _setLocale_decorators = [Remote];
+            __esDecorate(this, null, _setLocale_decorators, { kind: "method", name: "setLocale", static: false, private: false, access: { has: obj => "setLocale" in obj, get: obj => obj.setLocale }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        update = __runInitializers(this, _instanceExtraInitializers);
+        language = 'en';
+        disposed = false;
+        constructor(ctx, update) {
+            super(ctx, 'awCodexPresentation');
+            this.update = update;
+            ctx.effect(() => () => { this.disposed = true; });
+        }
+        async setLocale(language, signal) {
+            signal.throwIfAborted();
+            if (this.disposed)
+                throw new NeedError('DISPOSED', 'Codex presentation registration is disposed', 'active plugin');
+            if (language !== 'en' && language !== 'zh')
+                throw new NeedError('INVALID_REQUEST', 'Unsupported presentation language', 'official en/zh locale');
+            if (language !== this.language) {
+                this.update(language);
+                this.language = language;
+            }
+            return { language, name: PROVIDER_NAMES[language] };
+        }
+    };
+})();
+export { ProviderLocaleRemote };

package/dist/provider.d.ts

@@ -0,0 +1,144 @@
+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';
+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;
+    acpTransport?: {
+        writable: WritableStream<Uint8Array>;
+        readable: ReadableStream<Uint8Array>;
+    } | AgentApp | ExtendedAgentApp;
+    broker?: BrokerTransport;
+    oneShot?: OneShotRuntime;
+    loginRequired?: () => Promise<void>;
+    dispose?: () => Promise<void>;
+    binding?: {
+        bindingId: string;
+        workspaceId: string;
+        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';
+    cwd?: string;
+    identity?: string;
+    bindingId?: string;
+    workspaceId?: string;
+    agent?: AgentDefinition;
+    retainProcess?: boolean;
+    brokerSettings?: Readonly<BrokerSettings>;
+}
+export type RuntimeProvider = ((request: RuntimeRequest) => Promise<Runtime>) & {
+    preflight?: (request: RuntimeRequest) => Promise<void>;
+};
+export interface ConnectTarget {
+    hostContext?: {
+        enforcement: 'production' | 'test';
+        checkExitCode: 0 | 1;
+        failedChecks: {
+            id: string;
+            status: string;
+        }[];
+        unverifiedChecks: {
+            id: string;
+            status: string;
+        }[];
+    };
+    host: string;
+    username: string;
+    port: number;
+    proxyCommand: string;
+    projectRoot: string;
+    knownHostsFile: string;
+    session: {
+        command: string;
+        root: string;
+        settingsPath: string;
+        protocolVersion: 1;
+    };
+}
+export interface Project {
+    name: string;
+    path: string;
+}
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        requires: string;
+    };
+};
+/** 消费正式connect-api 0.7公开子集；X不响应L登录票据、不直接调用登录。 */
+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<{
+        provider: string;
+        loggedIn: boolean;
+    }>>;
+    login(provider: LoginProvider): Promise<Result<{
+        provider: string;
+        loggedIn: boolean;
+    }>>;
+    listProjects(): Promise<Result<{
+        projects: Project[];
+        unavailable: {
+            name: string;
+            reason: string;
+        }[];
+    }>>;
+    createProject(name: string): Promise<Result<Project>>;
+}
+export declare function requireLoginCoordinator(api: ConnectApi): void;
+export declare function requireLoginState(state: LoginPromptState): void;
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        aiWorkbenchConnect: ConnectApi;
+    }
+    interface Events {
+        'ai-workbench/connection-state': (state: ConnectionState) => void;
+        'ai-workbench/login-prompt-state': (state: LoginPromptState) => void;
+    }
+}
+/** Cancel only this consumer's wait; L owns the shared flight and its lifetime. */
+export declare function awaitL<T>(operation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+export declare function unwrap<T>(result: Result<T>): T;
+export declare function validateTarget(t: ConnectTarget): void;
+/** Only the declared public check identifiers/statuses, never provider evidence. */
+export declare function hostContextNotice(t: ConnectTarget): string | undefined;
+export declare function identity(t: ConnectTarget): string;
+/** Reject draft.3 and legacy runtime rather than inventing workspace bindings. */
+export declare function requireNativeWorkspace(api: ConnectApi): asserts api is ConnectApi & NativeWorkspaceApi;
+/** Authorization stays in L; ensureReady only checks and records the need. */
+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<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;