@peakflo/agent-harness 0.0.0-stage → 0.2.1-rc.3

package/dist/adapters/codex-adapter.js

@@ -0,0 +1,681 @@
+"use strict";
+/**
+ * Codex Adapter
+ *
+ * Implements CodingAgentAdapter for OpenAI Codex via direct CLI integration.
+ *
+ * Key differences from Claude Code:
+ * - Uses JSON-RPC over stdio (like MCP protocol)
+ * - Spawns `codex` CLI process per session
+ * - Thread-based session model (thread_id instead of session_id)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAdapter = exports.DEFAULT_CODEX_MODEL = void 0;
+/**
+ * Extracted verbatim from 20x `src/main/adapters/codex-adapter.ts`.
+ * CHANGED: imports only — `../child-stream-guards` ->
+ * `../runtime/child-stream-guards`. Source formatting (no semicolons)
+ * preserved.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const child_stream_guards_1 = require("../runtime/child-stream-guards");
+const coding_agent_adapter_1 = require("./coding-agent-adapter");
+exports.DEFAULT_CODEX_MODEL = 'gpt-5.6-sol';
+class CodexAdapter {
+    sessions = new Map();
+    codexExecutablePath = null;
+    /** Callback set by agent-manager to trigger an immediate poll cycle */
+    onDataAvailable;
+    async initialize() {
+        // Find codex CLI executable
+        this.codexExecutablePath = await this.findCodexExecutable();
+        console.log(`[CodexAdapter] Initialized with executable: ${this.codexExecutablePath}`);
+    }
+    /**
+     * Find the Codex CLI executable path
+     */
+    async findCodexExecutable() {
+        if (this.codexExecutablePath) {
+            return this.codexExecutablePath;
+        }
+        try {
+            const { execFile } = await Promise.resolve().then(() => __importStar(require('child_process')));
+            const { promisify } = await Promise.resolve().then(() => __importStar(require('util')));
+            const execFileAsync = promisify(execFile);
+            // Try to find codex in PATH
+            const isWin = process.platform === 'win32';
+            const whichCmd = isWin ? 'where' : 'which';
+            const binaryName = isWin ? 'codex.cmd' : 'codex';
+            const { stdout } = await execFileAsync(whichCmd, [binaryName]);
+            this.codexExecutablePath = stdout.trim().split(/\r?\n/)[0];
+            console.log(`[CodexAdapter] Found codex executable at: ${this.codexExecutablePath}`);
+            return this.codexExecutablePath;
+        }
+        catch {
+            // Common installation locations — must cover Homebrew, npm globals,
+            // pnpm globals, Volta, and NVM paths so the binary is found even when
+            // the shell PATH wasn't fully resolved (packaged macOS GUI app).
+            const home = process.env.HOME || process.env.USERPROFILE || '';
+            const commonPaths = process.platform === 'win32'
+                ? [
+                    `${home}\\AppData\\Roaming\\npm\\codex.cmd`,
+                    `${home}\\.local\\bin\\codex.cmd`
+                ]
+                : [
+                    '/usr/local/bin/codex',
+                    '/opt/homebrew/bin/codex',
+                    `${home}/.local/bin/codex`,
+                    `${home}/.npm-global/bin/codex`,
+                    `${home}/Library/pnpm/codex`,
+                    `${home}/.volta/bin/codex`,
+                ];
+            // Dynamically detect NVM-managed npm global bin (avoids hardcoding a Node version)
+            if (process.platform !== 'win32' && home) {
+                try {
+                    const { join } = await Promise.resolve().then(() => __importStar(require('path')));
+                    const { readdirSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+                    const nvmDir = join(home, '.nvm', 'versions', 'node');
+                    const versions = readdirSync(nvmDir);
+                    versions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+                    for (const v of versions) {
+                        commonPaths.push(join(nvmDir, v, 'bin', 'codex'));
+                    }
+                }
+                catch {
+                    // NVM not installed — skip
+                }
+            }
+            for (const path of commonPaths) {
+                if ((0, fs_1.existsSync)(path)) {
+                    this.codexExecutablePath = path;
+                    console.log(`[CodexAdapter] Found codex executable at: ${this.codexExecutablePath}`);
+                    return this.codexExecutablePath;
+                }
+            }
+            throw new Error('Codex CLI not found. Install it from OpenAI: https://platform.openai.com/docs/codex');
+        }
+    }
+    /**
+     * Build environment variables for Codex process
+     */
+    buildCodexEnvironment() {
+        const env = { ...process.env };
+        // Ensure API key is available
+        if (!env.OPENAI_API_KEY && !env.CODEX_API_KEY) {
+            console.warn('[CodexAdapter] No OPENAI_API_KEY or CODEX_API_KEY found in environment');
+        }
+        return env;
+    }
+    buildCodexArgs(config) {
+        const args = [
+            '--model',
+            config.model || exports.DEFAULT_CODEX_MODEL,
+        ];
+        if (config.reasoningEffort && config.reasoningEffort !== 'max') {
+            args.push('-c', `model_reasoning_effort="${config.reasoningEffort}"`);
+        }
+        args.push('--json-rpc');
+        return args;
+    }
+    async createSession(config) {
+        if (!this.codexExecutablePath) {
+            throw new Error('Codex executable not found');
+        }
+        const abortController = new AbortController();
+        // Spawn codex process
+        // On Windows, .cmd wrappers need shell:true to resolve
+        const needsShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(this.codexExecutablePath);
+        const codexProcess = (0, child_process_1.spawn)(this.codexExecutablePath, this.buildCodexArgs(config), {
+            cwd: config.workspaceDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: this.buildCodexEnvironment(),
+            ...(needsShell ? { shell: true } : {}),
+        });
+        // Every pipe needs an error listener before the first write. Codex can exit
+        // at any moment, and an unhandled EPIPE on its stdin crashes the main
+        // process.
+        (0, child_stream_guards_1.guardChildStreams)(codexProcess, 'CodexAdapter');
+        // Create session state
+        const session = {
+            sessionId: '', // Will be set to threadId after thread.create
+            threadId: '', // Will be set after thread.create
+            process: codexProcess,
+            workspaceDir: config.workspaceDir,
+            messageBuffer: [],
+            status: 'idle',
+            abortController,
+            config,
+            lastError: null,
+            nextRpcId: 1,
+            pendingRpcCalls: new Map(),
+            stdoutBuffer: '',
+        };
+        // Set up stdout parser
+        this.setupStdoutParser(codexProcess, session);
+        // Set up stderr logging
+        codexProcess.stderr?.on('data', (chunk) => {
+            console.error('[CodexAdapter] Codex stderr:', chunk.toString());
+        });
+        // Handle process exit
+        codexProcess.on('exit', (code, signal) => {
+            console.log(`[CodexAdapter] Codex process exited: code=${code}, signal=${signal}`);
+            if (code !== 0 && code !== null) {
+                session.status = 'error';
+                session.lastError = `Codex process exited with code ${code}`;
+            }
+        });
+        // Initialize JSON-RPC session
+        try {
+            const apiKey = process.env.OPENAI_API_KEY || process.env.CODEX_API_KEY;
+            await this.sendRpcRequest(session, 'initialize', {
+                api_key: apiKey,
+                model: config.model || exports.DEFAULT_CODEX_MODEL,
+            });
+            // Create thread (Codex's session concept)
+            const threadResponse = (await this.sendRpcRequest(session, 'thread.create', {}));
+            session.threadId = threadResponse.thread_id;
+            session.sessionId = session.threadId;
+            console.log(`[CodexAdapter] Created Codex thread: ${session.threadId}`);
+            // Store session
+            this.sessions.set(session.threadId, session);
+            return session.threadId;
+        }
+        catch (error) {
+            // Cleanup on error
+            codexProcess.kill();
+            throw new Error(`Failed to create Codex session: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async resumeSession(sessionId, config) {
+        if (!this.codexExecutablePath) {
+            throw new Error('Codex executable not found');
+        }
+        // Validate session ID format (Codex uses thread_xxx format)
+        if (!sessionId.startsWith('thread_')) {
+            throw new Error('INCOMPATIBLE_SESSION_ID: This session was created with a different coding agent and cannot be resumed with Codex.');
+        }
+        const abortController = new AbortController();
+        // Spawn new codex process
+        // On Windows, .cmd wrappers need shell:true to resolve
+        const needsShellResume = process.platform === 'win32' && /\.(cmd|bat)$/i.test(this.codexExecutablePath);
+        const codexProcess = (0, child_process_1.spawn)(this.codexExecutablePath, this.buildCodexArgs(config), {
+            cwd: config.workspaceDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: this.buildCodexEnvironment(),
+            ...(needsShellResume ? { shell: true } : {}),
+        });
+        // Every pipe needs an error listener before the first write. Codex can exit
+        // at any moment, and an unhandled EPIPE on its stdin crashes the main
+        // process.
+        (0, child_stream_guards_1.guardChildStreams)(codexProcess, 'CodexAdapter');
+        // Create session state
+        const session = {
+            sessionId,
+            threadId: sessionId,
+            process: codexProcess,
+            workspaceDir: config.workspaceDir,
+            messageBuffer: [],
+            status: 'idle',
+            abortController,
+            config,
+            lastError: null,
+            nextRpcId: 1,
+            pendingRpcCalls: new Map(),
+            stdoutBuffer: '',
+        };
+        // Set up stdout parser
+        this.setupStdoutParser(codexProcess, session);
+        // Set up stderr logging
+        codexProcess.stderr?.on('data', (chunk) => {
+            console.error('[CodexAdapter] Codex stderr:', chunk.toString());
+        });
+        // Handle process exit
+        codexProcess.on('exit', (code, signal) => {
+            console.log(`[CodexAdapter] Codex process exited: code=${code}, signal=${signal}`);
+            if (code !== 0 && code !== null) {
+                session.status = 'error';
+                session.lastError = `Codex process exited with code ${code}`;
+            }
+        });
+        try {
+            // Initialize JSON-RPC session
+            const apiKey = process.env.OPENAI_API_KEY || process.env.CODEX_API_KEY;
+            await this.sendRpcRequest(session, 'initialize', {
+                api_key: apiKey,
+                model: config.model || exports.DEFAULT_CODEX_MODEL,
+            });
+            // Fetch thread history
+            const historyResponse = (await this.sendRpcRequest(session, 'thread.messages', {
+                thread_id: sessionId,
+            }));
+            // Store session
+            this.sessions.set(sessionId, session);
+            // Convert history to SessionMessage format
+            const messages = historyResponse.messages.map((msg) => ({
+                id: msg.id,
+                role: msg.role === 'user' ? coding_agent_adapter_1.MessageRole.USER : coding_agent_adapter_1.MessageRole.ASSISTANT,
+                parts: [
+                    {
+                        id: `${msg.id}-text`,
+                        type: coding_agent_adapter_1.MessagePartType.TEXT,
+                        text: msg.content,
+                    },
+                ],
+            }));
+            console.log(`[CodexAdapter] Resumed session ${sessionId} with ${messages.length} messages`);
+            return messages;
+        }
+        catch (error) {
+            // Check if thread not found
+            const errMsg = error instanceof Error ? error.message : String(error);
+            if (errMsg.includes('thread not found') || errMsg.includes('Thread not found')) {
+                codexProcess.kill();
+                throw new Error('INCOMPATIBLE_SESSION_ID: This session does not exist on Codex servers. It may have been created with a different coding agent or has expired.');
+            }
+            // Cleanup on error
+            codexProcess.kill();
+            throw error;
+        }
+    }
+    async sendPrompt(sessionId, parts, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Extract text from parts
+        const promptText = parts
+            .filter((p) => p.type === coding_agent_adapter_1.MessagePartType.TEXT && p.text)
+            .map((p) => p.text)
+            .join('\n');
+        if (!promptText) {
+            throw new Error('No text content in prompt parts');
+        }
+        // Add user message to buffer
+        const userMessage = {
+            type: 'text',
+            id: `user-${Date.now()}`,
+            role: 'user',
+            content: promptText,
+        };
+        session.messageBuffer.push(userMessage);
+        session.status = 'busy';
+        try {
+            // Send message via JSON-RPC
+            await this.sendRpcRequest(session, 'message.create', {
+                thread_id: session.threadId,
+                role: 'user',
+                content: promptText,
+            });
+            console.log(`[CodexAdapter] Sent prompt to thread ${session.threadId}`);
+        }
+        catch (error) {
+            session.status = 'error';
+            session.lastError = error instanceof Error ? error.message : String(error);
+            throw error;
+        }
+    }
+    async getStatus(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: 'Session not found' };
+        }
+        if (session.lastError) {
+            return { type: coding_agent_adapter_1.SessionStatusType.ERROR, message: session.lastError };
+        }
+        return {
+            type: session.status === 'busy' ? coding_agent_adapter_1.SessionStatusType.BUSY : coding_agent_adapter_1.SessionStatusType.IDLE,
+        };
+    }
+    async pollMessages(sessionId, seenMessageIds, seenPartIds, partContentLengths, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        const newParts = [];
+        // Process buffered messages
+        for (const codexMsg of session.messageBuffer) {
+            if (seenMessageIds.has(codexMsg.id))
+                continue;
+            seenMessageIds.add(codexMsg.id);
+            // Convert CodexMessage to MessagePart
+            const parts = this.convertCodexMessageToParts(codexMsg, seenPartIds, partContentLengths);
+            newParts.push(...parts);
+        }
+        // Clear processed messages from buffer
+        session.messageBuffer = [];
+        return newParts;
+    }
+    async abortPrompt(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Send abort request
+        try {
+            await this.sendRpcRequest(session, 'message.abort', {
+                thread_id: session.threadId,
+            });
+        }
+        catch (error) {
+            console.warn(`[CodexAdapter] Failed to abort: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        session.status = 'idle';
+    }
+    async destroySession(sessionId, _config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        // Kill process
+        session.process.kill('SIGTERM');
+        // Wait a bit, then force kill if needed
+        setTimeout(() => {
+            if (!session.process.killed) {
+                session.process.kill('SIGKILL');
+            }
+        }, 1000);
+        // Remove session
+        this.sessions.delete(sessionId);
+    }
+    async registerMcpServer(_serverName, _mcpConfig, _workspaceDir) {
+        // Codex doesn't support MCP servers yet
+        // This is a no-op for now
+        console.warn('[CodexAdapter] MCP servers are not yet supported by Codex');
+    }
+    async checkHealth() {
+        try {
+            const execPath = await this.findCodexExecutable();
+            if (!execPath) {
+                return { available: false, reason: 'Codex CLI not found. Install from: https://openai.com/codex' };
+            }
+            // Check if API key is available
+            if (!process.env.OPENAI_API_KEY && !process.env.CODEX_API_KEY) {
+                return { available: false, reason: 'OPENAI_API_KEY not set in environment' };
+            }
+            // Verify Codex CLI is executable by checking version
+            try {
+                const { execFile } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                const { promisify } = await Promise.resolve().then(() => __importStar(require('util')));
+                const execFileAsync = promisify(execFile);
+                await execFileAsync(execPath, ['--version'], { timeout: 5000 });
+                return { available: true };
+            }
+            catch (error) {
+                return { available: false, reason: `Codex CLI found but not executable: ${error instanceof Error ? error.message : String(error)}` };
+            }
+        }
+        catch (error) {
+            return { available: false, reason: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    // ========================================================================
+    // Private Helper Methods
+    // ========================================================================
+    /**
+     * Set up stdout parser for JSON-RPC messages
+     */
+    setupStdoutParser(process, session) {
+        process.stdout?.on('data', (chunk) => {
+            session.stdoutBuffer += chunk.toString();
+            // Parse newline-delimited JSON messages
+            let newlineIndex;
+            while ((newlineIndex = session.stdoutBuffer.indexOf('\n')) !== -1) {
+                const line = session.stdoutBuffer.slice(0, newlineIndex).trim();
+                session.stdoutBuffer = session.stdoutBuffer.slice(newlineIndex + 1);
+                if (!line)
+                    continue;
+                try {
+                    const message = JSON.parse(line);
+                    this.handleRpcMessage(session, message);
+                }
+                catch {
+                    console.error('[CodexAdapter] Failed to parse JSON-RPC message:', line);
+                }
+            }
+        });
+    }
+    /**
+     * Handle incoming JSON-RPC message
+     */
+    handleRpcMessage(session, message) {
+        // Response to our RPC request
+        if ('id' in message && message.id !== undefined) {
+            const pending = session.pendingRpcCalls.get(message.id);
+            if (pending) {
+                session.pendingRpcCalls.delete(message.id);
+                // Type guard for JsonRpcResponse
+                const response = message;
+                if ('error' in response && response.error) {
+                    pending.reject(new Error(response.error.message));
+                }
+                else if ('result' in response) {
+                    pending.resolve(response.result);
+                }
+                else {
+                    pending.reject(new Error('Invalid RPC response'));
+                }
+            }
+            return;
+        }
+        // Notification (streaming event)
+        if ('method' in message) {
+            this.handleNotification(session, message);
+        }
+    }
+    /**
+     * Handle JSON-RPC notification (streaming events)
+     */
+    handleNotification(session, notification) {
+        const params = notification.params;
+        const delta = params.delta;
+        switch (notification.method) {
+            case 'message.delta':
+                // Text content streaming
+                session.messageBuffer.push({
+                    type: 'text',
+                    id: params.message_id || `msg-${Date.now()}`,
+                    role: params.role || 'assistant',
+                    delta: delta?.content || '',
+                    content: delta?.content || '',
+                });
+                break;
+            case 'message.completed':
+                // Message finished
+                session.status = 'idle';
+                session.messageBuffer.push({
+                    type: 'text',
+                    id: params.message_id || `msg-${Date.now()}`,
+                    role: 'assistant',
+                    finished: true,
+                });
+                break;
+            case 'tool.call':
+                // Tool call started
+                session.messageBuffer.push({
+                    type: 'tool_call',
+                    id: params.tool_call_id || `tool-${Date.now()}`,
+                    tool_name: params.tool_name,
+                    tool_call_id: params.tool_call_id,
+                    arguments: params.arguments,
+                });
+                break;
+            case 'tool.result':
+                // Tool call completed
+                session.messageBuffer.push({
+                    type: 'tool_result',
+                    id: params.tool_call_id || `tool-${Date.now()}`,
+                    tool_call_id: params.tool_call_id,
+                    result: params.result,
+                });
+                break;
+            case 'error':
+                // Error occurred
+                session.status = 'error';
+                session.lastError = params.message || 'Unknown error';
+                session.messageBuffer.push({
+                    type: 'error',
+                    id: `error-${Date.now()}`,
+                    error: params.message,
+                });
+                break;
+            default:
+                console.log(`[CodexAdapter] Unknown notification: ${notification.method}`);
+        }
+        // Notify the polling coordinator that new data is available
+        this.onDataAvailable?.(session.sessionId);
+    }
+    /**
+     * Send JSON-RPC request and wait for response
+     */
+    sendRpcRequest(session, method, params) {
+        return new Promise((resolve, reject) => {
+            const id = session.nextRpcId++;
+            const request = {
+                jsonrpc: '2.0',
+                id,
+                method,
+                params,
+            };
+            // Store pending call
+            session.pendingRpcCalls.set(id, { resolve, reject });
+            // Send request
+            const requestJson = JSON.stringify(request) + '\n';
+            session.process.stdin?.write(requestJson, (error) => {
+                if (error) {
+                    session.pendingRpcCalls.delete(id);
+                    reject(error);
+                }
+            });
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (session.pendingRpcCalls.has(id)) {
+                    session.pendingRpcCalls.delete(id);
+                    reject(new Error(`RPC request timed out: ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    /**
+     * Convert CodexMessage to MessagePart format
+     */
+    convertCodexMessageToParts(msg, seenPartIds, partContentLengths) {
+        const parts = [];
+        switch (msg.type) {
+            case 'text':
+                const textPartId = `${msg.id}-text`;
+                if (!seenPartIds.has(textPartId)) {
+                    seenPartIds.add(textPartId);
+                    const content = msg.content || msg.delta || '';
+                    partContentLengths.set(textPartId, String(content.length));
+                    parts.push({
+                        id: textPartId,
+                        type: coding_agent_adapter_1.MessagePartType.TEXT,
+                        text: content,
+                        role: msg.role,
+                    });
+                }
+                break;
+            case 'tool_call':
+                const toolCallPartId = `tool-${msg.tool_call_id}`;
+                if (!seenPartIds.has(toolCallPartId)) {
+                    seenPartIds.add(toolCallPartId);
+                    const input = msg.arguments ? JSON.stringify(msg.arguments, null, 2) : undefined;
+                    partContentLengths.set(toolCallPartId, `pending:${msg.tool_name}`);
+                    parts.push({
+                        id: toolCallPartId,
+                        type: coding_agent_adapter_1.MessagePartType.TOOL,
+                        content: `Tool: ${msg.tool_name}`,
+                        tool: {
+                            name: msg.tool_name || 'unknown',
+                            status: 'pending',
+                            input,
+                        },
+                    });
+                }
+                break;
+            case 'tool_result':
+                const toolResultPartId = `tool-${msg.tool_call_id}`;
+                const previousContent = partContentLengths.get(toolResultPartId);
+                if (previousContent) {
+                    // Update existing tool part
+                    partContentLengths.set(toolResultPartId, `success:${msg.result?.length || 0}`);
+                    parts.push({
+                        id: toolResultPartId,
+                        type: coding_agent_adapter_1.MessagePartType.TOOL,
+                        content: 'Tool completed',
+                        tool: {
+                            name: previousContent.split(':')[1] || 'tool',
+                            status: 'success',
+                            output: msg.result?.slice(0, 2000),
+                        },
+                        update: true,
+                    });
+                }
+                else {
+                    // First time seeing this tool (result before call)
+                    if (!seenPartIds.has(toolResultPartId)) {
+                        seenPartIds.add(toolResultPartId);
+                        partContentLengths.set(toolResultPartId, `success:${msg.result?.length || 0}`);
+                        parts.push({
+                            id: toolResultPartId,
+                            type: coding_agent_adapter_1.MessagePartType.TOOL,
+                            content: 'Tool result',
+                            tool: {
+                                name: 'tool',
+                                status: 'success',
+                                output: msg.result?.slice(0, 2000),
+                            },
+                        });
+                    }
+                }
+                break;
+            case 'error':
+                const errorPartId = `${msg.id}-error`;
+                if (!seenPartIds.has(errorPartId)) {
+                    seenPartIds.add(errorPartId);
+                    parts.push({
+                        id: errorPartId,
+                        type: coding_agent_adapter_1.MessagePartType.ERROR,
+                        content: msg.error || 'Unknown error',
+                    });
+                }
+                break;
+        }
+        return parts;
+    }
+}
+exports.CodexAdapter = CodexAdapter;