@jingyi0605/codingns 0.1.1 → 0.1.3

package/node_modules/@codingns/session-sync-core/dist/runtime/codex-runtime.js

@@ -1,7 +1,9 @@
 import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
 import { DatabaseSync } from "node:sqlite";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { appendJsonLine, createRawRef, ensureDirectory, extractTextBlocks, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath } from "../providers/utils.js";
@@ -14,29 +16,70 @@ export class CodexRuntimeAdapter {
     }
     async startSession(request, sink) {
         const launchedAtMs = Date.now();
-        const client = await loadCodexClient();
-        const thread = client.startThread(createThreadOptions(request));
+        const transport = this.options.transportFactory
+            ? this.options.transportFactory()
+            : createCodexAppServerTransport(this.options);
+        await transport.initialize();
         const abortController = new AbortController();
-        const streamed = await thread.runStreamed(createCodexInput(request), {
-            signal: abortController.signal
-        });
-        const events = streamed.events[Symbol.asyncIterator]();
-        const startedSession = await this.awaitThreadStarted(thread, events, request.workspacePath, request.options.content, launchedAtMs);
+        const eventQueue = createAsyncEventQueue();
+        const startedSession = await transport.startThread(request);
         const providerSessionId = startedSession.providerSessionId;
-        const fallbackRawStoreRef = request.rawStoreRef ?? buildRuntimeRawStoreRef(resolveRuntimeStoreKey(providerSessionId, request.sessionId));
+        const fallbackRawStoreRef = startedSession.rawStoreRef ??
+            request.rawStoreRef ??
+            buildRuntimeRawStoreRef(resolveRuntimeStoreKey(providerSessionId, request.sessionId));
         const resolvedBinding = await this.resolveExistingSessionBinding(providerSessionId, fallbackRawStoreRef, request.workspacePath);
         const rawStoreRef = resolvedBinding?.rawStoreRef ?? fallbackRawStoreRef;
         sink.updateSessionBinding({
             providerSessionId,
             rawStoreRef
         });
+        transport.setNotificationHandler(async (notification) => {
+            const translated = translateCodexAppServerNotification(notification);
+            if (translated.turnId) {
+                eventQueue.setTurnId(translated.turnId);
+            }
+            if (translated.event) {
+                eventQueue.push(translated.event);
+            }
+            if (translated.terminal) {
+                eventQueue.close();
+            }
+        });
+        transport.setServerRequestHandler(async (serverRequest) => {
+            if (!this.options.handleServerRequest) {
+                throw new Error("CODEX_APP_SERVER_REQUEST_NOT_SUPPORTED");
+            }
+            return this.options.handleServerRequest({
+                sessionId: request.sessionId,
+                providerSessionId,
+                request: serverRequest
+            });
+        });
+        transport.setOnClose((error) => {
+            if (error) {
+                eventQueue.push({
+                    type: "turn.failed",
+                    timestamp: nextTimestamp(),
+                    error: error.message
+                });
+            }
+            eventQueue.close();
+        });
+        await transport.startTurn(request, providerSessionId);
         return {
             providerSessionId,
             rawStoreRef,
             interrupt: async () => {
                 abortController.abort();
+                await transport.interruptTurn().catch(() => {
+                    return;
+                });
+                transport.close();
             },
-            completed: this.runTurn(null, request, sink, providerSessionId, rawStoreRef, abortController, events, startedSession.bufferedEvents, launchedAtMs)
+            isAlive: () => transport.isClosed() === false,
+            completed: this.runTurn(null, request, sink, providerSessionId, rawStoreRef, abortController, eventQueue.iterator, [], launchedAtMs).finally(() => {
+                transport.close();
+            })
         };
     }
     async continueSession(request, sink) {
@@ -44,31 +87,77 @@ export class CodexRuntimeAdapter {
         if (!providerSessionId) {
             throw new Error("PROVIDER_SESSION_ID_REQUIRED");
         }
-        const client = await loadCodexClient();
-        const thread = client.resumeThread(providerSessionId, createThreadOptions(request));
+        const transport = this.options.transportFactory
+            ? this.options.transportFactory()
+            : createCodexAppServerTransport(this.options);
+        await transport.initialize();
         const fallbackRawStoreRef = request.rawStoreRef ?? buildRuntimeRawStoreRef(providerSessionId);
         const resolvedBinding = await this.resolveExistingSessionBinding(providerSessionId, fallbackRawStoreRef, request.workspacePath);
         const resolvedSessionId = resolvedBinding?.providerSessionId ?? providerSessionId;
-        const rawStoreRef = resolvedBinding?.rawStoreRef ?? fallbackRawStoreRef;
+        const resumed = await transport.resumeThread(request, resolvedSessionId);
+        const rawStoreRef = resolvedBinding?.rawStoreRef ?? resumed.rawStoreRef ?? fallbackRawStoreRef;
         const abortController = new AbortController();
+        const eventQueue = createAsyncEventQueue();
         sink.updateSessionBinding({
             providerSessionId: resolvedSessionId,
             rawStoreRef
         });
+        transport.setNotificationHandler(async (notification) => {
+            const translated = translateCodexAppServerNotification(notification);
+            if (translated.turnId) {
+                eventQueue.setTurnId(translated.turnId);
+            }
+            if (translated.event) {
+                eventQueue.push(translated.event);
+            }
+            if (translated.terminal) {
+                eventQueue.close();
+            }
+        });
+        transport.setServerRequestHandler(async (serverRequest) => {
+            if (!this.options.handleServerRequest) {
+                throw new Error("CODEX_APP_SERVER_REQUEST_NOT_SUPPORTED");
+            }
+            return this.options.handleServerRequest({
+                sessionId: request.sessionId,
+                providerSessionId: resolvedSessionId,
+                request: serverRequest
+            });
+        });
+        transport.setOnClose((error) => {
+            if (error) {
+                eventQueue.push({
+                    type: "turn.failed",
+                    timestamp: nextTimestamp(),
+                    error: error.message
+                });
+            }
+            eventQueue.close();
+        });
+        await transport.startTurn(request, resolvedSessionId);
         return {
             providerSessionId: resolvedSessionId,
             rawStoreRef,
             interrupt: async () => {
                 abortController.abort();
+                await transport.interruptTurn().catch(() => {
+                    return;
+                });
+                transport.close();
             },
-            completed: this.runTurn(thread, request, sink, resolvedSessionId, rawStoreRef, abortController, undefined, [], Date.now())
+            isAlive: () => transport.isClosed() === false,
+            completed: this.runTurn(null, request, sink, resolvedSessionId, rawStoreRef, abortController, eventQueue.iterator, [], Date.now()).finally(() => {
+                transport.close();
+            })
         };
     }
     async runTurn(thread, request, sink, providerSessionId, rawStoreRef, abortController, preparedEvents, bufferedEvents = [], launchedAtMs = Date.now()) {
         const context = {
             providerSessionId,
             rawStoreRef,
-            sequence: 0,
+            // 运行时消息必须接在历史消息后面，不能每轮都从 1 重新编号，
+            // 否则前端会把新 assistant/tool 消息排到旧消息前面，表现成用户消息一直挂在底部。
+            sequence: Math.max(0, request.sequenceBase ?? 0),
             toolNameByCallId: new Map(),
             sink,
             workspacePath: request.workspacePath,
@@ -148,12 +237,23 @@ export class CodexRuntimeAdapter {
                 status: "failed",
                 providerSessionId: context.providerSessionId,
                 rawStoreRef: context.rawStoreRef,
-                errorCode: "CODEX_CLI_TURN_FAILED",
+                errorCode: classifyCodexDetailErrorCode(detail, "CODEX_CLI_TURN_FAILED"),
                 detail,
                 timestamp: pickTimestamp(event)
             });
             return;
         }
+        if (eventType === "turn.interrupted") {
+            await context.sink.emit({
+                type: "interrupted",
+                status: "interrupted",
+                providerSessionId: context.providerSessionId,
+                rawStoreRef: context.rawStoreRef,
+                detail: "codex turn interrupted",
+                timestamp: pickTimestamp(event)
+            });
+            return;
+        }
         if (interrupted) {
             return;
         }
@@ -451,6 +551,400 @@ export class CodexRuntimeAdapter {
         }
     }
 }
+function createCodexAppServerTransport(options) {
+    const commandPath = resolveCodexCommand(options.commandPath);
+    const launch = resolveCodexCommandLaunch(commandPath, ["app-server"]);
+    const child = spawn(launch.command, launch.args, {
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: launch.shell,
+        windowsHide: true
+    });
+    const stdout = createInterface({ input: child.stdout });
+    let notificationHandler = () => undefined;
+    let serverRequestHandler = async () => {
+        throw new Error("CODEX_APP_SERVER_REQUEST_NOT_SUPPORTED");
+    };
+    let requestSequence = 0;
+    let closed = false;
+    let activeTurnId = null;
+    let activeThreadId = null;
+    let closeHandler = null;
+    const pendingResponses = new Map();
+    const finalize = (error) => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        stdout.close();
+        for (const pending of pendingResponses.values()) {
+            pending.reject(error ?? new Error("CODEX_APP_SERVER_CLOSED"));
+        }
+        pendingResponses.clear();
+        closeHandler?.(error);
+    };
+    child.on("error", (error) => {
+        finalize(error);
+    });
+    child.on("exit", (code, signal) => {
+        if (closed) {
+            return;
+        }
+        const detail = signal
+            ? `codex app-server exited with signal ${signal}`
+            : `codex app-server exited with code ${String(code ?? "unknown")}`;
+        finalize(new Error(detail));
+    });
+    stdout.on("line", (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        if (typeof parsed.method === "string" && parsed.id !== undefined) {
+            void Promise.resolve(serverRequestHandler(parsed))
+                .then((result) => {
+                writeJsonRpcMessage(child, {
+                    jsonrpc: "2.0",
+                    id: parsed.id,
+                    result
+                });
+            })
+                .catch((error) => {
+                writeJsonRpcMessage(child, {
+                    jsonrpc: "2.0",
+                    id: parsed.id,
+                    error: {
+                        code: -32000,
+                        message: error instanceof Error ? error.message : "CODEX_APP_SERVER_REQUEST_FAILED"
+                    }
+                });
+            });
+            return;
+        }
+        if (typeof parsed.method === "string") {
+            const method = parsed.method.trim();
+            const params = readJsonRpcParams(parsed);
+            if (method === "turn/started") {
+                activeTurnId = ensureText(readProp(readProp(params, "turn"), "id")).trim() || activeTurnId;
+            }
+            if (method === "thread/started") {
+                activeThreadId = ensureText(readProp(readProp(params, "thread"), "id")).trim() || activeThreadId;
+            }
+            void notificationHandler({
+                method,
+                params
+            });
+            return;
+        }
+        const responseId = String(parsed.id ?? "");
+        const pending = pendingResponses.get(responseId);
+        if (!pending) {
+            return;
+        }
+        pendingResponses.delete(responseId);
+        if (parsed.error && typeof parsed.error === "object") {
+            const message = ensureText(readProp(parsed.error, "message")).trim() || "CODEX_APP_SERVER_ERROR";
+            pending.reject(new Error(message));
+            return;
+        }
+        pending.resolve(readJsonRpcResult(parsed));
+    });
+    return {
+        async initialize() {
+            await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("initialize", () => ++requestSequence), {
+                method: "initialize",
+                params: {
+                    clientInfo: {
+                        name: "codingns-runtime",
+                        version: "0.0.0"
+                    },
+                    capabilities: null
+                }
+            });
+            writeJsonRpcMessage(child, {
+                jsonrpc: "2.0",
+                method: "initialized",
+                params: {}
+            });
+        },
+        async startThread(request) {
+            const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("thread-start", () => ++requestSequence), {
+                method: "thread/start",
+                params: createThreadStartParams(request)
+            });
+            const thread = toRecord(result.thread);
+            const providerSessionId = ensureText(thread?.id).trim();
+            if (!providerSessionId) {
+                throw new Error("CODEX_APP_SERVER_THREAD_ID_MISSING");
+            }
+            activeThreadId = providerSessionId;
+            return {
+                providerSessionId,
+                rawStoreRef: normalizeText(thread?.path) || null
+            };
+        },
+        async resumeThread(request, providerSessionId) {
+            const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("thread-resume", () => ++requestSequence), {
+                method: "thread/resume",
+                params: createThreadResumeParams(request, providerSessionId)
+            });
+            const thread = toRecord(result.thread);
+            activeThreadId = ensureText(thread?.id).trim() || providerSessionId;
+            return {
+                providerSessionId: activeThreadId,
+                rawStoreRef: normalizeText(thread?.path) || null
+            };
+        },
+        async startTurn(request, providerSessionId) {
+            const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("turn-start", () => ++requestSequence), {
+                method: "turn/start",
+                params: createTurnStartParams(request, providerSessionId)
+            });
+            activeTurnId = ensureText(readProp(readProp(result, "turn"), "id")).trim() || activeTurnId;
+        },
+        async interruptTurn() {
+            if (!activeThreadId || !activeTurnId) {
+                return;
+            }
+            await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("turn-interrupt", () => ++requestSequence), {
+                method: "turn/interrupt",
+                params: {
+                    threadId: activeThreadId,
+                    turnId: activeTurnId
+                }
+            });
+        },
+        setNotificationHandler(handler) {
+            notificationHandler = handler;
+        },
+        setServerRequestHandler(handler) {
+            serverRequestHandler = handler;
+        },
+        setOnClose(handler) {
+            closeHandler = handler;
+        },
+        isClosed() {
+            return closed;
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            finalize(null);
+            if (!child.stdin.destroyed) {
+                child.stdin.end();
+            }
+            if (!child.killed) {
+                child.kill("SIGTERM");
+            }
+        }
+    };
+}
+function createAsyncEventQueue() {
+    const values = [];
+    const waiters = [];
+    let closed = false;
+    let turnId = null;
+    return {
+        iterator: {
+            next() {
+                if (values.length > 0) {
+                    return Promise.resolve({
+                        done: false,
+                        value: values.shift()
+                    });
+                }
+                if (closed) {
+                    return Promise.resolve({
+                        done: true,
+                        value: undefined
+                    });
+                }
+                return new Promise((resolve) => {
+                    waiters.push(resolve);
+                });
+            }
+        },
+        push(value) {
+            if (closed) {
+                return;
+            }
+            const waiter = waiters.shift();
+            if (waiter) {
+                waiter({
+                    done: false,
+                    value
+                });
+                return;
+            }
+            values.push(value);
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            while (waiters.length > 0) {
+                waiters.shift()?.({
+                    done: true,
+                    value: undefined
+                });
+            }
+        },
+        setTurnId(nextTurnId) {
+            turnId = nextTurnId;
+        },
+        getTurnId() {
+            return turnId;
+        }
+    };
+}
+function translateCodexAppServerNotification(notification) {
+    const method = ensureText(notification.method).trim();
+    const params = toRecord(notification.params) ?? {};
+    if (method === "turn/started") {
+        return {
+            event: null,
+            terminal: false,
+            turnId: ensureText(readProp(readProp(params, "turn"), "id")).trim() || null
+        };
+    }
+    if (method === "turn/completed") {
+        const turn = toRecord(params.turn);
+        const status = ensureText(turn?.status).trim();
+        if (status === "failed") {
+            return {
+                event: {
+                    type: "turn.failed",
+                    timestamp: nextTimestamp(),
+                    error: ensureText(readProp(turn?.error, "message")).trim() || "codex turn failed"
+                },
+                terminal: true,
+                turnId: ensureText(turn?.id).trim() || null
+            };
+        }
+        if (status === "interrupted") {
+            return {
+                event: {
+                    type: "turn.interrupted",
+                    timestamp: nextTimestamp()
+                },
+                terminal: true,
+                turnId: ensureText(turn?.id).trim() || null
+            };
+        }
+        return {
+            event: {
+                type: "turn.completed",
+                timestamp: nextTimestamp()
+            },
+            terminal: true,
+            turnId: ensureText(turn?.id).trim() || null
+        };
+    }
+    if (method === "item/started" || method === "item/completed") {
+        const item = translateCodexAppServerItem(toRecord(params.item));
+        if (!item) {
+            return {
+                event: null,
+                terminal: false,
+                turnId: null
+            };
+        }
+        return {
+            event: {
+                type: method === "item/started" ? "item.started" : "item.completed",
+                item,
+                timestamp: nextTimestamp()
+            },
+            terminal: false,
+            turnId: null
+        };
+    }
+    return {
+        event: null,
+        terminal: false,
+        turnId: null
+    };
+}
+function translateCodexAppServerItem(item) {
+    if (!item) {
+        return null;
+    }
+    const itemType = ensureText(item.type).trim();
+    if (!itemType) {
+        return null;
+    }
+    if (itemType === "agentMessage") {
+        return {
+            type: "agent_message",
+            id: item.id,
+            text: item.text
+        };
+    }
+    if (itemType === "reasoning") {
+        return {
+            type: "reasoning",
+            id: item.id,
+            text: Array.isArray(item.content) ? item.content.join("\n") : "",
+            summary: Array.isArray(item.summary) ? item.summary.join("\n") : ""
+        };
+    }
+    if (itemType === "commandExecution") {
+        return {
+            type: "command_execution",
+            id: item.id,
+            command: item.command,
+            cwd: item.cwd,
+            status: normalizeCodexItemStatus(item.status),
+            commandActions: item.commandActions,
+            aggregated_output: item.aggregatedOutput,
+            exit_code: item.exitCode
+        };
+    }
+    if (itemType === "fileChange") {
+        const diffText = buildCodexFileChangeOutput(item.changes);
+        return {
+            type: "custom_tool_call",
+            id: item.id,
+            tool: "apply_patch",
+            input: diffText,
+            output: diffText,
+            status: normalizeCodexItemStatus(item.status)
+        };
+    }
+    if (itemType === "mcpToolCall") {
+        return {
+            type: "mcp_tool_call",
+            id: item.id,
+            tool: item.tool,
+            server: item.server,
+            arguments: item.arguments,
+            result: item.result,
+            error: item.error,
+            status: normalizeCodexItemStatus(item.status)
+        };
+    }
+    if (itemType === "dynamicToolCall") {
+        return {
+            type: "custom_tool_call",
+            id: item.id,
+            tool: item.tool,
+            input: item.arguments,
+            output: item.contentItems,
+            success: item.success,
+            status: normalizeCodexItemStatus(item.status)
+        };
+    }
+    return null;
+}
 export function createThreadOptions(request) {
     const options = {
         workingDirectory: request.workspacePath,
@@ -470,6 +964,61 @@ export function createThreadOptions(request) {
     }
     return options;
 }
+function createThreadStartParams(request) {
+    const permissionOptions = createCodexThreadPermissionOptions(request.options.permissionMode ?? "default");
+    const params = {
+        cwd: request.workspacePath,
+        approvalsReviewer: "user"
+    };
+    if (permissionOptions.approvalPolicy) {
+        params.approvalPolicy = permissionOptions.approvalPolicy;
+    }
+    if (permissionOptions.sandboxMode) {
+        params.sandbox = permissionOptions.sandboxMode;
+    }
+    if (request.options.model) {
+        params.model = request.options.model;
+    }
+    return params;
+}
+function createThreadResumeParams(request, providerSessionId) {
+    const permissionOptions = createCodexThreadPermissionOptions(request.options.permissionMode ?? "default");
+    const params = {
+        threadId: providerSessionId,
+        cwd: request.workspacePath,
+        approvalsReviewer: "user"
+    };
+    if (permissionOptions.approvalPolicy) {
+        params.approvalPolicy = permissionOptions.approvalPolicy;
+    }
+    if (permissionOptions.sandboxMode) {
+        params.sandbox = permissionOptions.sandboxMode;
+    }
+    if (request.options.model) {
+        params.model = request.options.model;
+    }
+    return params;
+}
+function createTurnStartParams(request, providerSessionId) {
+    const permissionOptions = createCodexThreadPermissionOptions(request.options.permissionMode ?? "default");
+    const params = {
+        threadId: providerSessionId,
+        input: createCodexAppServerInput(request),
+        cwd: request.workspacePath,
+        approvalsReviewer: "user"
+    };
+    if (permissionOptions.approvalPolicy) {
+        params.approvalPolicy = permissionOptions.approvalPolicy;
+    }
+    if (request.options.model) {
+        params.model = request.options.model;
+    }
+    const reasoningEffort = normalizeCodexReasoningEffort(request.options.reasoningLevel);
+    if (reasoningEffort) {
+        params.effort = reasoningEffort;
+    }
+    return params;
+}
 function normalizeCodexReasoningEffort(value) {
     const normalized = value?.trim().toLowerCase() ?? null;
     if (!normalized) {
@@ -507,6 +1056,23 @@ function createCodexInput(request) {
     });
     return input;
 }
+function createCodexAppServerInput(request) {
+    const input = [];
+    const promptText = (request.options.providerPrompt ?? request.options.content).trim();
+    if (promptText.length > 0) {
+        input.push({
+            type: "text",
+            text: promptText
+        });
+    }
+    for (const attachment of request.options.attachments) {
+        input.push({
+            type: "localImage",
+            path: attachment.filePath
+        });
+    }
+    return input;
+}
 async function loadCodexClient() {
     const moduleName = "@openai/codex-sdk";
     const runtimeImport = new Function("name", "return import(name);");
@@ -553,6 +1119,80 @@ function buildRuntimeRawStoreRef(providerSessionId) {
 function resolveRuntimeStoreKey(providerSessionId, sessionId) {
     return providerSessionId.trim() || sessionId;
 }
+function resolveCodexCommand(explicitPath) {
+    const explicitCandidate = explicitPath?.trim() ||
+        process.env.CODINGNS_CODEX_COMMAND?.trim() ||
+        "codex";
+    return explicitCandidate;
+}
+function resolveCodexCommandLaunch(commandPath, args) {
+    const normalizedCommandPath = commandPath.trim();
+    if (isNodeScriptPath(normalizedCommandPath)) {
+        return {
+            command: process.execPath,
+            args: [normalizedCommandPath, ...args],
+            shell: false
+        };
+    }
+    return {
+        command: normalizedCommandPath,
+        args: [...args],
+        shell: shouldSpawnViaShellOnWindows(normalizedCommandPath)
+    };
+}
+function isNodeScriptPath(commandPath) {
+    return /\.(?:c|m)?js$/i.test(commandPath);
+}
+function shouldSpawnViaShellOnWindows(commandPath) {
+    if (process.platform !== "win32") {
+        return false;
+    }
+    if (/\.(cmd|bat)$/i.test(commandPath)) {
+        return true;
+    }
+    // Windows 上裸名命令（无扩展名、无路径分隔符）需要 shell 才能从 PATH 解析 .cmd 文件
+    const extension = commandPath.split(".").pop()?.toLowerCase();
+    const hasPathSep = commandPath.includes("\\") || commandPath.includes("/");
+    if (!extension || extension === commandPath.toLowerCase()) {
+        if (!hasPathSep) {
+            return true;
+        }
+    }
+    return false;
+}
+function nextJsonRpcId(prefix, allocate) {
+    return `${prefix}:${allocate()}`;
+}
+function writeJsonRpcMessage(child, payload) {
+    if (!child.stdin || child.stdin.destroyed || !child.stdin.writable) {
+        throw new Error("CODEX_APP_SERVER_STDIN_UNAVAILABLE");
+    }
+    child.stdin.write(`${JSON.stringify(payload)}\n`, "utf8");
+}
+function sendJsonRpcRequest(child, pendingResponses, createRequestId, input) {
+    const id = createRequestId();
+    return new Promise((resolve, reject) => {
+        pendingResponses.set(id, { resolve, reject });
+        try {
+            writeJsonRpcMessage(child, {
+                jsonrpc: "2.0",
+                id,
+                method: input.method,
+                params: input.params
+            });
+        }
+        catch (error) {
+            pendingResponses.delete(id);
+            reject(error instanceof Error ? error : new Error("CODEX_APP_SERVER_REQUEST_WRITE_FAILED"));
+        }
+    });
+}
+function readJsonRpcParams(parsed) {
+    return toRecord(parsed.params) ?? {};
+}
+function readJsonRpcResult(parsed) {
+    return toRecord(parsed.result) ?? {};
+}
 function resolveResumeThreadId(providerSessionId, rawStoreRef) {
     const normalizedProviderSessionId = ensureText(providerSessionId).trim();
     const fromRawStore = readThreadIdFromRawStore(rawStoreRef);
@@ -570,6 +1210,12 @@ function readProp(value, key) {
     }
     return value[key];
 }
+function toRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
 function ensureText(value) {
     if (typeof value === "string") {
         return value;
@@ -584,6 +1230,10 @@ function ensureText(value) {
         return String(value);
     }
 }
+function normalizeText(value) {
+    const normalized = ensureText(value).trim();
+    return normalized.length > 0 ? normalized : null;
+}
 function readThreadIdFromRawStore(rawStoreRef) {
     const filePath = ensureText(rawStoreRef).trim();
     if (!filePath || !existsSync(filePath)) {
@@ -715,9 +1365,14 @@ function pickFirstNonEmpty(...values) {
 }
 function isToolItem(itemType) {
     return (itemType === "command_execution" ||
+        itemType === "file_change" ||
         itemType === "mcp_tool_call" ||
         itemType === "function_call" ||
-        itemType === "custom_tool_call");
+        itemType === "custom_tool_call" ||
+        itemType === "commandExecution" ||
+        itemType === "fileChange" ||
+        itemType === "mcpToolCall" ||
+        itemType === "dynamicToolCall");
 }
 function inferToolSuccess(item, output) {
     const status = ensureText(readProp(item, "status")).trim().toLowerCase();
@@ -758,10 +1413,23 @@ function classifyCodexRuntimeFailure(error) {
         };
     }
     return {
-        errorCode: "CODEX_RUNTIME_ERROR",
+        errorCode: classifyCodexDetailErrorCode(detail, "CODEX_RUNTIME_ERROR"),
         detail
     };
 }
+function classifyCodexDetailErrorCode(detail, fallback) {
+    const normalized = detail.trim();
+    if (!normalized) {
+        return fallback;
+    }
+    const statusMatch = normalized.match(/\bstatus\s+(\d{3})\b/i)
+        ?? normalized.match(/\bHTTP\s+(\d{3})\b/i)
+        ?? normalized.match(/\b(\d{3})\s+(?:Bad Gateway|Too Many Requests|Gateway Timeout|Service Unavailable)\b/i);
+    if (!statusMatch) {
+        return fallback;
+    }
+    return `CODEX_HTTP_${statusMatch[1]}`;
+}
 function persistSyntheticUserMessageIfNeeded(rawStoreRef, providerSessionId, input) {
     if (!isSyntheticRawStoreRef(rawStoreRef) || input.content.trim().length === 0) {
         return;
@@ -921,4 +1589,37 @@ function mapToolStartItemType(itemType) {
 function mapToolResultItemType(itemType) {
     return itemType === "custom_tool_call" ? "custom_tool_call_output" : "function_call_output";
 }
+function normalizeCodexItemStatus(value) {
+    const normalized = ensureText(value).trim();
+    if (!normalized) {
+        return "in_progress";
+    }
+    if (normalized === "inProgress") {
+        return "running";
+    }
+    if (normalized === "declined") {
+        return "failed";
+    }
+    return normalized;
+}
+function buildCodexFileChangeOutput(value) {
+    if (!Array.isArray(value)) {
+        return "";
+    }
+    return value
+        .map((change) => {
+        const record = toRecord(change);
+        if (!record) {
+            return "";
+        }
+        const diff = ensureText(record.diff).trim();
+        if (diff.length > 0) {
+            return diff;
+        }
+        const path = ensureText(record.path).trim();
+        return path.length > 0 ? `Updated ${path}` : "";
+    })
+        .filter((entry) => entry.length > 0)
+        .join("\n\n");
+}
 //# sourceMappingURL=codex-runtime.js.map