shennian 0.2.6 → 0.2.7

package/dist/src/agents/codex.js

@@ -0,0 +1,829 @@
+// @arch docs/architecture/cli/agent-adapters.md
+// @test src/__tests__/codex-adapter.test.ts
+import { createInterface } from 'node:readline';
+import { randomUUID } from 'node:crypto';
+import { AgentAdapter, registerAgent } from './adapter.js';
+import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
+export class CodexAdapter extends AgentAdapter {
+    type = 'codex';
+    process = null;
+    workDir = null;
+    seq = 0;
+    runId = '';
+    pendingUsage;
+    agentSessionId = null;
+    hasEmittedText = false;
+    textTail = '';
+    terminalState = 'open';
+    forceCloseTimer = null;
+    stderrBuf = '';
+    rpcSeq = 1;
+    pendingRequests = new Map();
+    appServerReady = null;
+    appServerStartupError = null;
+    activeTurnId = null;
+    namedThread = false;
+    deltaItemIds = new Set();
+    lastTransientStatus = '';
+    async start(_sessionId, workDir, agentSessionId) {
+        this.workDir = workDir;
+        this.seq = 0;
+        if (agentSessionId)
+            this.agentSessionId = agentSessionId;
+    }
+    async send(text, modelId) {
+        if (this.activeTurnId) {
+            await this.killProcess();
+        }
+        const codexModelId = normalizeCodexModelId(modelId);
+        this.runId = randomUUID();
+        this.seq = 0;
+        this.resetRunState();
+        await this.ensureAppServer(codexModelId);
+        const threadId = this.agentSessionId;
+        if (!threadId)
+            throw new Error('codex app-server did not create a thread');
+        this.emitEvent({ state: 'start', agentSessionId: threadId });
+        if (!this.namedThread) {
+            await this.sendRpc('thread/name/set', {
+                threadId,
+                name: makeThreadTitle(text),
+            }).catch(() => { });
+            this.namedThread = true;
+        }
+        const response = await this.sendRpc('turn/start', {
+            threadId,
+            input: [{ type: 'text', text, text_elements: [] }],
+            approvalPolicy: 'never',
+            sandboxPolicy: { type: 'dangerFullAccess' },
+            ...(codexModelId ? { model: codexModelId } : {}),
+        });
+        this.activeTurnId = response.turn?.id ?? null;
+    }
+    async resume(agentSessionId) {
+        await this.killProcess();
+        this.agentSessionId = agentSessionId;
+        this.namedThread = true;
+        this.resetTextState();
+    }
+    async stop() {
+        await this.killProcess();
+    }
+    spawnCodex(args) {
+        const spec = resolveBuiltinCommand('codex');
+        if (!spec) {
+            this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
+            return;
+        }
+        const proc = spawnResolvedCommand(spec, args, {
+            cwd: this.workDir ?? undefined,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        this.process = proc;
+        const rl = createInterface({ input: proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const obj = JSON.parse(line);
+                this.handleStreamEvent(obj);
+            }
+            catch {
+                this.emitEvent({ state: 'delta', text: line });
+            }
+        });
+        let stderrBuf = '';
+        proc.stderr?.on('data', (chunk) => {
+            stderrBuf += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            this.clearForceCloseTimer();
+            this.handleProcessClose(code, stderrBuf);
+        });
+        proc.on('error', (err) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            if (err.code === 'ENOENT') {
+                this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
+            }
+            else {
+                this.emit('error', err);
+            }
+        });
+    }
+    spawnAppServer() {
+        const spec = resolveBuiltinCommand('codex');
+        if (!spec) {
+            this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
+            return;
+        }
+        const proc = spawnResolvedCommand(spec, ['app-server', '--listen', 'stdio://'], {
+            cwd: this.workDir ?? undefined,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, NO_COLOR: '1' },
+        });
+        this.process = proc;
+        this.stderrBuf = '';
+        this.appServerStartupError = null;
+        const rl = createInterface({ input: proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                this.handleAppServerNonJsonStdout(line);
+                return;
+            }
+            this.handleAppServerMessage(msg);
+        });
+        proc.stderr?.on('data', (chunk) => {
+            this.stderrBuf += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (this.process !== proc)
+                return;
+            const hadActiveTurn = this.activeTurnId != null;
+            this.process = null;
+            this.appServerReady = null;
+            this.activeTurnId = null;
+            this.rejectAllPending(new Error(normalizeCodexStderr(this.stderrBuf) || `codex app-server exited with code ${code}`));
+            if (this.terminalState === 'open' && hadActiveTurn) {
+                this.handleProcessClose(code, this.stderrBuf);
+            }
+        });
+        proc.on('error', (err) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            this.rejectAllPending(err);
+            if (err.code === 'ENOENT') {
+                this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
+            }
+            else {
+                this.emit('error', err);
+            }
+        });
+    }
+    async ensureAppServer(modelId) {
+        if (this.appServerReady)
+            return this.appServerReady;
+        this.spawnAppServer();
+        this.appServerReady = this.initializeAppServer(modelId).catch(async (error) => {
+            this.appServerReady = null;
+            await this.killProcess();
+            throw error;
+        });
+        return this.appServerReady;
+    }
+    async initializeAppServer(modelId) {
+        const codexModelId = normalizeCodexModelId(modelId);
+        await this.sendRpc('initialize', {
+            clientInfo: { name: 'shennian', title: 'Shennian', version: '0.0.0' },
+            capabilities: { experimentalApi: true },
+        });
+        if (this.agentSessionId) {
+            const response = await this.sendRpc('thread/resume', {
+                threadId: this.agentSessionId,
+                cwd: this.workDir,
+                approvalPolicy: 'never',
+                sandbox: 'danger-full-access',
+                persistExtendedHistory: true,
+                ...(codexModelId ? { model: codexModelId } : {}),
+            });
+            this.agentSessionId = response.thread?.id ?? this.agentSessionId;
+            this.namedThread = !!response.thread?.name;
+            return;
+        }
+        const response = await this.sendRpc('thread/start', {
+            cwd: this.workDir,
+            approvalPolicy: 'never',
+            sandbox: 'danger-full-access',
+            serviceName: 'Shennian',
+            experimentalRawEvents: false,
+            persistExtendedHistory: true,
+            ...(codexModelId ? { model: codexModelId } : {}),
+        });
+        const threadId = response.thread?.id;
+        if (!threadId)
+            throw new Error('codex app-server thread/start returned no thread id');
+        this.agentSessionId = threadId;
+        this.namedThread = !!response.thread?.name;
+    }
+    sendRpc(method, params, timeoutMs = 60_000) {
+        if (this.appServerStartupError)
+            return Promise.reject(this.appServerStartupError);
+        const proc = this.process;
+        if (!proc?.stdin)
+            return Promise.reject(new Error('codex app-server is not running'));
+        const id = this.rpcSeq++;
+        const payload = JSON.stringify({ id, method, params });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`codex app-server request timed out: ${method}`));
+            }, timeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            proc.stdin.write(`${payload}\n`, (error) => {
+                if (!error)
+                    return;
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(error);
+            });
+        });
+    }
+    handleAppServerMessage(msg) {
+        if (msg.id != null) {
+            const pending = this.pendingRequests.get(msg.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(msg.id);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error.message || `codex app-server error ${msg.error.code ?? ''}`.trim()));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+        }
+        if (!msg.method)
+            return;
+        const params = msg.params ?? {};
+        switch (msg.method) {
+            case 'item/agentMessage/delta': {
+                const itemId = typeof params.itemId === 'string' ? params.itemId : '';
+                if (itemId)
+                    this.deltaItemIds.add(itemId);
+                if (typeof params.delta === 'string')
+                    this.emitText(params.delta);
+                break;
+            }
+            case 'item/completed':
+                this.handleAppServerCompletedItem(params);
+                break;
+            case 'thread/tokenUsage/updated':
+                this.handleAppServerUsage(params);
+                break;
+            case 'turn/completed': {
+                const turn = typeof params.turn === 'object' && params.turn !== null
+                    ? params.turn
+                    : null;
+                const turnId = typeof turn?.id === 'string' ? turn.id : null;
+                if (!this.activeTurnId || turnId === this.activeTurnId) {
+                    this.activeTurnId = null;
+                    this.emitFinalIfOpen();
+                }
+                break;
+            }
+            case 'error': {
+                const message = extractAppServerErrorMessage(params);
+                if (isTransientCodexErrorMessage(message)) {
+                    this.emitTransientStatus(message);
+                    return;
+                }
+                this.emitErrorIfOpen(message);
+                break;
+            }
+        }
+    }
+    handleAppServerNonJsonStdout(line) {
+        const normalized = normalizeTerminalText(line);
+        if (!looksLikeCodexInteractiveAuthPrompt(normalized))
+            return;
+        this.failAppServerStartup(new Error('Codex 未登录。请先在这台电脑的终端运行 `codex`，按提示完成 ChatGPT 登录或配置 API key，然后再回到神念发送消息。'));
+    }
+    failAppServerStartup(error) {
+        if (this.appServerStartupError)
+            return;
+        this.appServerStartupError = error;
+        this.rejectAllPending(error);
+        this.process?.kill('SIGTERM');
+    }
+    handleAppServerCompletedItem(params) {
+        const item = typeof params.item === 'object' && params.item !== null
+            ? params.item
+            : null;
+        if (!item || typeof item.type !== 'string')
+            return;
+        switch (item.type) {
+            case 'agentMessage': {
+                const id = typeof item.id === 'string' ? item.id : '';
+                if (id && this.deltaItemIds.has(id))
+                    return;
+                if (typeof item.text === 'string')
+                    this.emitText(item.text, 'block');
+                break;
+            }
+            case 'commandExecution': {
+                const command = typeof item.command === 'string' ? item.command : '';
+                const output = typeof item.aggregatedOutput === 'string' ? item.aggregatedOutput : '';
+                if (command) {
+                    this.emitEvent({ state: 'tool-call', name: 'command_execution', args: { command } });
+                }
+                this.emitEvent({
+                    state: 'tool-result',
+                    name: 'command_execution',
+                    result: [output, item.exitCode != null ? `\n(exit ${item.exitCode})` : ''].join('').trim(),
+                });
+                break;
+            }
+            case 'mcpToolCall':
+            case 'dynamicToolCall': {
+                const tool = typeof item.tool === 'string' ? item.tool : item.type;
+                const args = typeof item.arguments === 'object' && item.arguments !== null
+                    ? item.arguments
+                    : {};
+                this.emitEvent({ state: 'tool-call', name: tool, args });
+                this.emitEvent({
+                    state: 'tool-result',
+                    name: tool,
+                    result: safeStringify(item.error ?? item.result ?? item.contentItems ?? ''),
+                });
+                break;
+            }
+            case 'fileChange': {
+                const changes = Array.isArray(item.changes) ? item.changes : [];
+                const summary = changes
+                    .map((change) => {
+                    if (typeof change !== 'object' || change === null)
+                        return '';
+                    const c = change;
+                    const path = typeof c.path === 'string' ? c.path : typeof c.file === 'string' ? c.file : '';
+                    const kind = typeof c.kind === 'string' ? c.kind : typeof c.type === 'string' ? c.type : 'change';
+                    return path ? `${kind}: ${path}` : '';
+                })
+                    .filter(Boolean)
+                    .join('\n');
+                if (summary)
+                    this.emitText(summary, 'block');
+                break;
+            }
+        }
+    }
+    handleAppServerUsage(params) {
+        const tokenUsage = typeof params.tokenUsage === 'object' && params.tokenUsage !== null
+            ? params.tokenUsage
+            : null;
+        const last = typeof tokenUsage?.last === 'object' && tokenUsage.last !== null
+            ? tokenUsage.last
+            : null;
+        const total = typeof tokenUsage?.total === 'object' && tokenUsage.total !== null
+            ? tokenUsage.total
+            : null;
+        const usage = last ?? total;
+        if (!usage)
+            return;
+        const input = typeof usage.inputTokens === 'number' ? usage.inputTokens : undefined;
+        const output = typeof usage.outputTokens === 'number' ? usage.outputTokens : undefined;
+        if (input != null || output != null) {
+            this.pendingUsage = {
+                inputTokens: input ?? 0,
+                outputTokens: output ?? 0,
+            };
+        }
+    }
+    handleCodexItemLine(obj) {
+        const item = obj.item;
+        if (!item?.type)
+            return;
+        switch (item.type) {
+            case 'agent_message':
+            case 'reasoning': {
+                if (obj.type === 'item.completed' && item.text) {
+                    this.emitText(item.text, 'block');
+                }
+                break;
+            }
+            case 'command_execution': {
+                if (obj.type === 'item.started' && item.command) {
+                    this.emitEvent({
+                        state: 'tool-call',
+                        name: 'command_execution',
+                        args: { command: item.command },
+                    });
+                }
+                if (obj.type === 'item.completed') {
+                    const parts = [
+                        item.aggregated_output ?? '',
+                        item.exit_code != null ? `\n(exit ${item.exit_code})` : '',
+                    ];
+                    this.emitEvent({
+                        state: 'tool-result',
+                        name: 'command_execution',
+                        result: parts.join('').trim() || String(item.status ?? ''),
+                    });
+                }
+                break;
+            }
+            case 'mcp_tool_call': {
+                if (obj.type === 'item.started') {
+                    this.emitEvent({
+                        state: 'tool-call',
+                        name: item.tool ?? 'mcp_tool',
+                        args: {
+                            server: item.server,
+                            ...(item.arguments && typeof item.arguments === 'object' ? item.arguments : {}),
+                        },
+                    });
+                }
+                if (obj.type === 'item.completed') {
+                    const errMsg = item.error && typeof item.error === 'object' ? item.error.message : undefined;
+                    this.emitEvent({
+                        state: 'tool-result',
+                        name: item.tool ?? 'mcp_tool',
+                        result: errMsg ?? safeStringify(item.result),
+                    });
+                }
+                break;
+            }
+            case 'file_change': {
+                if (obj.type === 'item.completed' && item.changes?.length) {
+                    const summary = item.changes.map((c) => `${c.kind}: ${c.path}`).join('\n');
+                    this.emitText(summary, 'block');
+                }
+                break;
+            }
+            case 'web_search': {
+                if (obj.type === 'item.completed' && item.query) {
+                    this.emitText(`[web_search] ${item.query}`, 'block');
+                }
+                break;
+            }
+            case 'todo_list': {
+                if (obj.type === 'item.completed' && item.items?.length) {
+                    const lines = item.items.map((t) => `- [${t.completed ? 'x' : ' '}] ${t.text}`).join('\n');
+                    this.emitText(lines, 'block');
+                }
+                break;
+            }
+            case 'error': {
+                if (obj.type === 'item.completed' && item.message) {
+                    this.emitEvent({ state: 'error', message: item.message });
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    handleStreamEvent(obj) {
+        const topType = obj.type ?? obj.event;
+        if (topType?.startsWith('item.')) {
+            this.handleCodexItemLine(obj);
+        }
+        switch (topType) {
+            case 'turn.completed': {
+                const u = obj.usage;
+                if (u) {
+                    const input = u.input_tokens ?? u.prompt_tokens;
+                    const output = u.output_tokens ?? u.completion_tokens;
+                    if (input != null || output != null) {
+                        this.pendingUsage = {
+                            inputTokens: input ?? 0,
+                            outputTokens: output ?? 0,
+                        };
+                    }
+                }
+                this.emitFinalIfOpen();
+                return;
+            }
+            case 'turn.failed': {
+                const msg = typeof obj.error === 'object' && obj.error?.message
+                    ? obj.error.message
+                    : typeof obj.error === 'string'
+                        ? obj.error
+                        : 'turn failed';
+                this.emitErrorIfOpen(msg);
+                return;
+            }
+            case 'error': {
+                const m = typeof obj.message === 'string' ? obj.message : '';
+                if (m.includes('Reconnecting'))
+                    return;
+                this.emitErrorIfOpen(m || (typeof obj.error === 'string' ? obj.error : 'stream error'));
+                return;
+            }
+            case 'thread.started': {
+                const sid = obj.thread_id ?? obj.session_id ?? obj.id;
+                if (typeof sid === 'string' && sid) {
+                    this.agentSessionId = sid;
+                    this.emitEvent({ state: 'start', agentSessionId: this.agentSessionId });
+                }
+                return;
+            }
+            case 'turn.started':
+                return;
+        }
+        if (topType?.startsWith('item.'))
+            return;
+        const eventType = obj.type ?? obj.event;
+        switch (eventType) {
+            case 'message':
+            case 'text':
+            case 'content': {
+                const text = obj.content ?? obj.text;
+                if (text) {
+                    this.emitText(text);
+                }
+                break;
+            }
+            case 'function_call':
+            case 'tool_call': {
+                this.emitEvent({
+                    state: 'tool-call',
+                    name: obj.name,
+                    args: obj.arguments ?? obj.input,
+                });
+                break;
+            }
+            case 'function_call_output':
+            case 'tool_result': {
+                this.emitEvent({
+                    state: 'tool-result',
+                    name: obj.name,
+                    result: obj.output ?? obj.result,
+                });
+                break;
+            }
+            case 'error': {
+                break;
+            }
+            case 'done':
+            case 'completed': {
+                if (obj.usage) {
+                    this.pendingUsage = {
+                        inputTokens: obj.usage.prompt_tokens ?? obj.usage.input_tokens ?? 0,
+                        outputTokens: obj.usage.completion_tokens ?? obj.usage.output_tokens ?? 0,
+                    };
+                }
+                this.emitFinalIfOpen();
+                break;
+            }
+        }
+    }
+    emitEvent(partial) {
+        const event = {
+            ...partial,
+            runId: this.runId,
+            seq: this.seq++,
+        };
+        this.emit('agentEvent', event);
+    }
+    async killProcess() {
+        const proc = this.process;
+        this.appServerReady = null;
+        this.activeTurnId = null;
+        if (!proc) {
+            this.rejectAllPending(new Error('codex app-server stopped'));
+            return;
+        }
+        this.process = null;
+        this.clearForceCloseTimer();
+        proc.kill('SIGTERM');
+        await new Promise((resolve) => {
+            proc.on('close', resolve);
+            setTimeout(() => {
+                proc.kill('SIGKILL');
+                resolve();
+            }, 3000);
+        });
+        this.rejectAllPending(new Error('codex app-server stopped'));
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pendingRequests.entries()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this.pendingRequests.delete(id);
+        }
+    }
+    handleProcessClose(code, stderrBuf) {
+        const stderr = normalizeCodexStderr(stderrBuf);
+        if (code !== 0 && code !== null) {
+            const msg = stderr || `codex exited with code ${code}`;
+            this.emitErrorIfOpen(msg);
+        }
+        else if (looksLikeFatalCodexStderr(stderr)) {
+            // Codex sometimes surfaces fatal API/auth errors on stderr without
+            // emitting a protocol-level `turn.failed`, and may still exit 0.
+            this.emitErrorIfOpen(stderr);
+        }
+        else {
+            this.emitFinalIfOpen();
+        }
+        this.pendingUsage = undefined;
+    }
+    emitFinalIfOpen() {
+        if (this.terminalState !== 'open')
+            return;
+        this.terminalState = 'final';
+        this.emitEvent({
+            state: 'final',
+            usage: this.pendingUsage,
+            agentSessionId: this.agentSessionId ?? undefined,
+        });
+    }
+    emitErrorIfOpen(message) {
+        if (this.terminalState !== 'open')
+            return;
+        this.terminalState = 'error';
+        this.emitEvent({ state: 'error', message: formatCodexErrorMessage(message) });
+        this.scheduleProcessClose();
+    }
+    resetRunState() {
+        this.pendingUsage = undefined;
+        this.terminalState = 'open';
+        this.deltaItemIds.clear();
+        this.lastTransientStatus = '';
+        this.clearForceCloseTimer();
+        this.resetTextState();
+    }
+    emitTransientStatus(message) {
+        const formatted = formatTransientCodexStatus(message);
+        if (!formatted || formatted === this.lastTransientStatus || this.terminalState !== 'open')
+            return;
+        this.lastTransientStatus = formatted;
+        this.emitEvent({ state: 'delta', text: `${formatted}\n`, thinking: true });
+    }
+    resetTextState() {
+        this.hasEmittedText = false;
+        this.textTail = '';
+    }
+    emitText(text, mode = 'delta') {
+        if (!text)
+            return;
+        let next = stripGitDirectiveArtifacts(text);
+        if (!next)
+            return;
+        if (mode === 'block' && this.hasEmittedText && !next.startsWith('\n')) {
+            if (this.textTail.endsWith('\n')) {
+                next = `\n${next}`;
+            }
+            else if (!this.textTail.endsWith('\n\n')) {
+                next = `\n\n${next}`;
+            }
+        }
+        this.hasEmittedText = true;
+        this.textTail = (this.textTail + next).slice(-4);
+        this.emitEvent({ state: 'delta', text: next });
+    }
+    scheduleProcessClose() {
+        const proc = this.process;
+        if (!proc || this.forceCloseTimer)
+            return;
+        this.forceCloseTimer = setTimeout(() => {
+            this.forceCloseTimer = null;
+            if (this.process !== proc)
+                return;
+            proc.kill('SIGTERM');
+            setTimeout(() => {
+                if (this.process === proc) {
+                    proc.kill('SIGKILL');
+                }
+            }, 1000);
+        }, 250);
+    }
+    clearForceCloseTimer() {
+        if (!this.forceCloseTimer)
+            return;
+        clearTimeout(this.forceCloseTimer);
+        this.forceCloseTimer = null;
+    }
+}
+function makeThreadTitle(text) {
+    const firstLine = normalizeTitleText(text).split('\n').find((line) => line.trim()) ?? 'Shennian';
+    const title = firstLine.trim().slice(0, 80);
+    return title || 'Shennian';
+}
+function normalizeTitleText(text) {
+    return text
+        .replace(/!\[[^\]]*]\([^)]+\)/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function normalizeCodexModelId(modelId) {
+    const trimmed = modelId?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.toLowerCase() === 'openai' ? undefined : trimmed;
+}
+function extractAppServerErrorMessage(params) {
+    if (typeof params.message === 'string' && params.message.trim())
+        return params.message.trim();
+    const error = params.error;
+    if (typeof error === 'string' && error.trim())
+        return error.trim();
+    if (typeof error === 'object' && error !== null) {
+        const message = error.message;
+        if (typeof message === 'string' && message.trim())
+            return message.trim();
+    }
+    return 'codex app-server error';
+}
+function isTransientCodexErrorMessage(message) {
+    return /\bReconnecting\.\.\.\s*\d+\/\d+/i.test(message);
+}
+function formatTransientCodexStatus(message) {
+    const match = message.match(/\bReconnecting\.\.\.\s*(\d+\/\d+)/i);
+    if (!match)
+        return '';
+    return `Codex API 暂时不可用，正在重试 ${match[1]}...`;
+}
+function formatCodexErrorMessage(message) {
+    const statusMatch = message.match(/unexpected status\s+(\d+)\s+([^:,]+)(?::\s*([^,]+))?(?:,\s*url:\s*([^,\s]+))?(?:,\s*request id:\s*([^\s,]+))?/i);
+    if (!statusMatch)
+        return message;
+    const [, status, statusText, detail, url, requestId] = statusMatch;
+    const parts = [
+        `Codex API 返回 ${status} ${statusText.trim()}`,
+        detail?.trim() ? `：${detail.trim()}` : '',
+        url ? `\n上游地址：${url}` : '',
+        requestId ? `\nrequest id：${requestId}` : '',
+    ];
+    return parts.join('');
+}
+const GIT_DIRECTIVE_LINE_RE = /^\s*::git-[a-z-]+\{[^\n]*\}\s*$/gm;
+function stripGitDirectiveArtifacts(text) {
+    if (!text)
+        return '';
+    const normalized = text.replace(/\r\n/g, '\n');
+    const hadDirective = /(^|\n)\s*::git-[a-z-]+\{[^\n]*\}\s*(?=\n|$)/.test(normalized);
+    const stripped = normalized
+        .replace(GIT_DIRECTIVE_LINE_RE, '')
+        .replace(/\n{3,}/g, '\n\n');
+    if (!stripped.trim())
+        return '';
+    return hadDirective
+        ? stripped.replace(/[ \t]+\n/g, '\n').replace(/\n+$/g, '')
+        : stripped;
+}
+function safeStringify(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function normalizeCodexStderr(stderr) {
+    return stderr
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((line) => !isIgnorableCodexStderrLine(line))
+        .join('\n');
+}
+function normalizeTerminalText(text) {
+    return text
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, ' ')
+        .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, ' ')
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function looksLikeCodexInteractiveAuthPrompt(text) {
+    if (!text)
+        return false;
+    const normalized = text.toLowerCase();
+    return (normalized.includes('welcome to codex') ||
+        normalized.includes('sign in with chatgpt') ||
+        normalized.includes('provide your own api key') ||
+        normalized.includes('press enter to continue'));
+}
+function isIgnorableCodexStderrLine(line) {
+    return [
+        /WARNING: proceeding, even though we could not update PATH:/i,
+        /Reading additional input from stdin\.\.\./i,
+        /failed to record rollout items: failed to queue rollout items: channel closed/i,
+    ].some((pattern) => pattern.test(line));
+}
+function looksLikeFatalCodexStderr(stderr) {
+    if (!stderr)
+        return false;
+    return [
+        /\bunauthorized\b/i,
+        /\bforbidden\b/i,
+        /\bpermission denied\b/i,
+        /\brate limit\b/i,
+        /\binsufficient quota\b/i,
+        /\bapi key\b/i,
+        /\bauth/i,
+        /\bnetwork\b/i,
+        /\btimeout\b/i,
+        /\bnot found\b/i,
+        /\berror\b/i,
+        /\bfailed\b/i,
+    ].some((pattern) => pattern.test(stderr));
+}
+registerAgent('codex', () => new CodexAdapter());