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

package/dist/mapping.js

@@ -0,0 +1,266 @@
+import { NeedError } from "./remote.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. */
+export class StreamMapper {
+    index = 0;
+    seen = new Map();
+    baseline;
+    /** Omitted argument is exclusively for a known new session; pass null on unknown resume. */
+    constructor(previousUsage = { version: 1, kind: 'zero' }) {
+        if (previousUsage !== null && !validUsageSnapshot(previousUsage))
+            throw new NeedError('USAGE_BASELINE_INVALID', '已保存的远端累计用量基线无效，不能重复结算历史用量', '与原远端会话关联的有效用量快照');
+        this.baseline = previousUsage === null ? null : { ...previousUsage };
+    }
+    get usageSnapshot() { return this.baseline === null ? null : { ...this.baseline }; }
+    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 } }];
+    }
+    acp(update) {
+        let chunks;
+        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));
+                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));
+                break;
+            case 'usage_update':
+                chunks = this.text(`\n[远端上下文] ${update.used}/${update.size} 令牌${update.cost ? ` · 累计费用 ${update.cost.amount} ${update.cost.currency}` : ''}；生成用量尚未提供，等待远端本轮真实计数。\n`);
+                break;
+            case 'plan':
+                chunks = this.text('\n[远端计划]\n' + update.entries.map(e => `${planStatus(e.status)}: ${e.content}`).join('\n') + '\n');
+                break;
+            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`);
+        }
+        return chunks.concat(this.meta(update._meta));
+    }
+    /** ACP usage and the fixed Claude quota both accumulate across the session, not per turn. */
+    acpResponse(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.text('\n[远端用量] 本轮生成用量未提供；上下文占用不能替代输入或输出计数。\n');
+        }
+        return chunks.concat(this.meta(response._meta, ['quota']));
+    }
+    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');
+        }
+        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.text('\n[远端用量] 远端累计计数发生回退，本轮未记录生成用量；已保留此前高水位，需要核对远端会话计数。\n');
+            }
+            if (optionalUsageCounters.some(key => previous[key] !== undefined && current[key] === undefined)) {
+                this.baseline = { ...previous, ...current, gap: true };
+                return this.text('\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');
+        }
+        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');
+        }
+        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.text('\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 [{ 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 === '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 } : {}) } }];
+        }
+        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 [];
+    }
+}
+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; }
+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/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,41 @@
+/** 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 = {
+        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,135 @@
+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';
+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;
+}
+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> {
+    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<void>;
+}
+export declare function sameTarget(a: ConnectTarget, b: ConnectTarget): boolean;
+export declare function connectProvider(get: () => ConnectApi | undefined, options?: {
+    agent?: AgentDefinition;
+    ask?: Interaction;
+    notice?: NoticeConsumer;
+    open?: (target: ConnectTarget, project: Project, request: RuntimeRequest) => Promise<Runtime>;
+}): RuntimeProvider;