cyrus-codex-runner 0.2.64-test.6 → 0.2.64

package/dist/CodexRunner.js

@@ -1,297 +1,48 @@
 import crypto from "node:crypto";
 import { EventEmitter } from "node:events";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, relative as pathRelative } from "node:path";
-import { cwd } from "node:process";
-import { Codex } from "@openai/codex-sdk";
+import { AppServerCodexBackend } from "./backend/AppServerCodexBackend.js";
+import { CodexEventMapper } from "./CodexEventMapper.js";
+import { CodexSkillStager } from "./CodexSkillStager.js";
+import { CodexConfigBuilder } from "./config/CodexConfigBuilder.js";
 import { CodexMessageFormatter } from "./formatter.js";
-const DEFAULT_CODEX_MODEL = "gpt-5.5";
-const CODEX_MCP_DOCS_URL = "https://platform.openai.com/docs/docs-mcp";
-function toFiniteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function safeStringify(value) {
-    try {
-        return JSON.stringify(value, null, 2);
-    }
-    catch {
-        return String(value);
-    }
-}
-function createAssistantToolUseMessage(toolUseId, toolName, toolInput, messageId = crypto.randomUUID()) {
-    const contentBlocks = [
-        {
-            type: "tool_use",
-            id: toolUseId,
-            name: toolName,
-            input: toolInput,
-        },
-    ];
-    return {
-        id: messageId,
-        type: "message",
-        role: "assistant",
-        content: contentBlocks,
-        model: DEFAULT_CODEX_MODEL,
-        stop_reason: null,
-        stop_sequence: null,
-        stop_details: null,
-        usage: {
-            input_tokens: 0,
-            output_tokens: 0,
-            cache_creation_input_tokens: 0,
-            cache_read_input_tokens: 0,
-            output_tokens_details: null,
-            cache_creation: null,
-            inference_geo: null,
-            iterations: null,
-            server_tool_use: null,
-            service_tier: null,
-            speed: null,
-        },
-        container: null,
-        context_management: null,
-        diagnostics: null,
-    };
-}
-function createUserToolResultMessage(toolUseId, result, isError) {
-    const contentBlocks = [
-        {
-            type: "tool_result",
-            tool_use_id: toolUseId,
-            content: result,
-            is_error: isError,
-        },
-    ];
-    return {
-        role: "user",
-        content: contentBlocks,
-    };
-}
-function createAssistantBetaMessage(content, messageId = crypto.randomUUID()) {
-    const contentBlocks = [
-        { type: "text", text: content },
-    ];
-    return {
-        id: messageId,
-        type: "message",
-        role: "assistant",
-        content: contentBlocks,
-        model: DEFAULT_CODEX_MODEL,
-        stop_reason: null,
-        stop_sequence: null,
-        stop_details: null,
-        usage: {
-            input_tokens: 0,
-            output_tokens: 0,
-            cache_creation_input_tokens: 0,
-            cache_read_input_tokens: 0,
-            output_tokens_details: null,
-            cache_creation: null,
-            inference_geo: null,
-            iterations: null,
-            server_tool_use: null,
-            service_tier: null,
-            speed: null,
-        },
-        container: null,
-        context_management: null,
-        diagnostics: null,
-    };
-}
-function parseUsage(usage) {
-    if (!usage) {
-        return {
-            inputTokens: 0,
-            outputTokens: 0,
-            cachedInputTokens: 0,
-        };
-    }
-    return {
-        inputTokens: toFiniteNumber(usage.input_tokens),
-        outputTokens: toFiniteNumber(usage.output_tokens),
-        cachedInputTokens: toFiniteNumber(usage.cached_input_tokens),
-    };
-}
-function createResultUsage(parsed) {
-    return {
-        input_tokens: parsed.inputTokens,
-        output_tokens: parsed.outputTokens,
-        cache_creation_input_tokens: 0,
-        cache_read_input_tokens: parsed.cachedInputTokens,
-        output_tokens_details: { thinking_tokens: 0 },
-        cache_creation: {
-            ephemeral_1h_input_tokens: 0,
-            ephemeral_5m_input_tokens: 0,
-        },
-        inference_geo: "unknown",
-        iterations: [],
-        server_tool_use: {
-            web_fetch_requests: 0,
-            web_search_requests: 0,
-        },
-        service_tier: "standard",
-        speed: "standard",
-    };
-}
-function getDefaultReasoningEffortForModel(model) {
-    // All gpt-5 variants (including plain "gpt-5") reject xhigh; pin to "high".
-    return /^gpt-5/i.test(model || "") ? "high" : undefined;
-}
-function normalizeError(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (typeof error === "string") {
-        return error;
-    }
-    return "Codex execution failed";
-}
-function inferCommandToolName(command) {
-    const normalized = command.toLowerCase();
-    if (/\brg\b|\bgrep\b/.test(normalized)) {
-        return "Grep";
-    }
-    if (/\bglob\.glob\b|\bfind\b.+\s-name\s/.test(normalized)) {
-        return "Glob";
-    }
-    if (/\bcat\b/.test(normalized) && !/>/.test(normalized)) {
-        return "Read";
-    }
-    if (/<<\s*['"]?eof['"]?\s*>/i.test(command) ||
-        /\becho\b.+>/.test(normalized)) {
-        return "Write";
-    }
-    return "Bash";
-}
-function normalizeFilePath(path, workingDirectory) {
-    if (!path) {
-        return path;
-    }
-    if (workingDirectory && path.startsWith(workingDirectory)) {
-        const relativePath = pathRelative(workingDirectory, path);
-        if (relativePath && relativePath !== ".") {
-            return relativePath;
-        }
-    }
-    return path;
-}
-function summarizeFileChanges(item, workingDirectory) {
-    if (!item.changes.length) {
-        return item.status === "failed" ? "Patch failed" : "No file changes";
-    }
-    return item.changes
-        .map((change) => {
-        const filePath = normalizeFilePath(change.path, workingDirectory);
-        return `${change.kind} ${filePath}`;
-    })
-        .join("\n");
-}
-function asRecord(value) {
-    if (value && typeof value === "object") {
-        return value;
-    }
-    return null;
-}
-function toMcpResultString(item) {
-    if (item.error?.message) {
-        return item.error.message;
-    }
-    const textBlocks = [];
-    for (const block of item.result?.content || []) {
-        const text = asRecord(block)?.text;
-        if (typeof text === "string" && text.trim().length > 0) {
-            textBlocks.push(text);
-        }
-    }
-    if (textBlocks.length > 0) {
-        return textBlocks.join("\n");
-    }
-    if (item.result?.structured_content !== undefined) {
-        return safeStringify(item.result.structured_content);
-    }
-    return item.status === "failed"
-        ? "MCP tool call failed"
-        : "MCP tool call completed";
-}
-function normalizeMcpIdentifier(value) {
-    const normalized = value
-        .toLowerCase()
-        .replace(/[^a-z0-9_]+/g, "_")
-        .replace(/^_+|_+$/g, "");
-    return normalized || "unknown";
-}
-function autoDetectMcpConfigPath(workingDirectory) {
-    if (!workingDirectory) {
-        return undefined;
-    }
-    const mcpPath = join(workingDirectory, ".mcp.json");
-    if (!existsSync(mcpPath)) {
-        return undefined;
-    }
-    try {
-        JSON.parse(readFileSync(mcpPath, "utf8"));
-        return mcpPath;
-    }
-    catch {
-        console.warn(`[CodexRunner] Found .mcp.json at ${mcpPath} but it is invalid JSON, skipping`);
-        return undefined;
-    }
-}
-function loadMcpConfigFromPaths(configPaths) {
-    if (!configPaths) {
-        return {};
-    }
-    const paths = Array.isArray(configPaths) ? configPaths : [configPaths];
-    let mcpServers = {};
-    for (const configPath of paths) {
-        try {
-            const mcpConfigContent = readFileSync(configPath, "utf8");
-            const mcpConfig = JSON.parse(mcpConfigContent);
-            const servers = mcpConfig &&
-                typeof mcpConfig === "object" &&
-                !Array.isArray(mcpConfig) &&
-                mcpConfig.mcpServers &&
-                typeof mcpConfig.mcpServers === "object" &&
-                !Array.isArray(mcpConfig.mcpServers)
-                ? mcpConfig.mcpServers
-                : {};
-            mcpServers = { ...mcpServers, ...servers };
-            console.log(`[CodexRunner] Loaded MCP config from ${configPath}: ${Object.keys(servers).join(", ")}`);
-        }
-        catch (error) {
-            console.warn(`[CodexRunner] Failed to load MCP config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return mcpServers;
-}
 /**
- * Runner that adapts Codex SDK streaming output to Cyrus SDK message types.
+ * Adapts Codex to Cyrus's {@link IAgentRunner} contract.
+ *
+ * The runner is a thin orchestrator: it owns session lifecycle and delegates
+ * configuration assembly ({@link CodexConfigBuilder}), skill staging
+ * ({@link CodexSkillStager}), event→message mapping ({@link CodexEventMapper}),
+ * and transport ({@link CodexBackend}) to dedicated collaborators. Codex is
+ * driven exclusively through the app-server backend, which supports mid-turn
+ * input injection (`turn/steer`).
  */
 export class CodexRunner extends EventEmitter {
-    supportsStreamingInput = false;
+    supportsStreamingInput = true;
     config;
-    sessionInfo = null;
-    messages = [];
     formatter;
-    hasInitMessage = false;
-    pendingResultMessage = null;
-    lastAssistantText = null;
-    lastUsage = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cachedInputTokens: 0,
-    };
-    errorMessages = [];
-    startTimestampMs = 0;
+    skillStager;
+    mapper;
+    sessionInfo = null;
+    backend = null;
     wasStopped = false;
-    abortController = null;
-    emittedToolUseIds = new Set();
+    /** Set once the turn reaches a terminal state; gates {@link isStreaming}. */
+    turnFinished = false;
+    /**
+     * Follow-up messages that arrived before the turn became steerable (during
+     * config build / process spawn / thread start). Flushed via `steer` once the
+     * turn starts, so a fast follow-up is never lost or wrongly deferred.
+     */
+    pendingFollowups = [];
     constructor(config) {
         super();
         this.config = config;
         this.formatter = new CodexMessageFormatter();
+        this.skillStager = new CodexSkillStager({
+            workingDirectory: config.workingDirectory,
+            additionalDirectories: config.additionalDirectories,
+            skills: config.skills,
+            plugins: config.plugins,
+        });
+        this.mapper = new CodexEventMapper(this.buildMapperContext());
         if (config.onMessage)
             this.on("message", config.onMessage);
         if (config.onError)
@@ -303,49 +54,79 @@ export class CodexRunner extends EventEmitter {
         return this.startWithPrompt(prompt);
     }
     async startStreaming(initialPrompt) {
-        return this.startWithPrompt(null, initialPrompt);
+        return this.startWithPrompt(initialPrompt);
     }
-    addStreamMessage(_content) {
-        throw new Error("CodexRunner does not support streaming input messages");
+    /**
+     * Inject a message mid-session. While a turn is steerable it is sent
+     * immediately (`turn/steer`); during the startup window (before the turn
+     * begins) it is buffered and flushed once the turn starts. Throws only once
+     * the turn has finished, where the caller should resume with a new turn.
+     */
+    addStreamMessage(content) {
+        if (this.backend?.isTurnActive()) {
+            this.steer(content);
+            return;
+        }
+        if (this.isRunning() && !this.turnFinished) {
+            this.pendingFollowups.push(content);
+            return;
+        }
+        throw new Error("Cannot stream message: no active Codex turn");
     }
     completeStream() {
-        // No-op: CodexRunner does not support streaming input.
+        // No-op: each turn's input is delivered up front (or via steer); there is
+        // no open input stream to close.
+    }
+    isStreaming() {
+        // True for the whole running, not-yet-finished window — including the
+        // startup gap before the turn is active — so callers stream follow-ups in
+        // (buffered if needed) rather than deferring them.
+        return (this.supportsStreamingInput && this.isRunning() && !this.turnFinished);
+    }
+    stop() {
+        if (this.sessionInfo?.isRunning) {
+            this.wasStopped = true;
+        }
+        this.cleanupRuntimeState();
+    }
+    isRunning() {
+        return this.sessionInfo?.isRunning ?? false;
     }
-    async startWithPrompt(stringPrompt, streamingInitialPrompt) {
+    getMessages() {
+        return this.mapper.getMessages();
+    }
+    getFormatter() {
+        return this.formatter;
+    }
+    // ---- internals ----------------------------------------------------------
+    async startWithPrompt(prompt) {
         if (this.isRunning()) {
             throw new Error("Codex session already running");
         }
-        const sessionId = this.config.resumeSessionId || crypto.randomUUID();
         this.sessionInfo = {
-            sessionId,
+            sessionId: this.config.resumeSessionId || crypto.randomUUID(),
             startedAt: new Date(),
             isRunning: true,
         };
-        this.messages = [];
-        this.hasInitMessage = false;
-        this.pendingResultMessage = null;
-        this.lastAssistantText = null;
-        this.lastUsage = {
-            inputTokens: 0,
-            outputTokens: 0,
-            cachedInputTokens: 0,
-        };
-        this.errorMessages = [];
         this.wasStopped = false;
-        this.startTimestampMs = Date.now();
-        this.emittedToolUseIds.clear();
-        await this.resolveModelWithFallback();
-        const prompt = (stringPrompt ?? streamingInitialPrompt ?? "").trim();
-        const threadOptions = this.buildThreadOptions();
-        const codex = this.createCodexClient();
-        const thread = this.config.resumeSessionId
-            ? codex.resumeThread(this.config.resumeSessionId, threadOptions)
-            : codex.startThread(threadOptions);
-        const abortController = new AbortController();
-        this.abortController = abortController;
+        this.turnFinished = false;
+        this.pendingFollowups = [];
+        this.mapper.reset();
+        // Create the backend up front (before the slow config build / process
+        // spawn) so addStreamMessage can buffer follow-ups that arrive during the
+        // startup window rather than throwing.
+        const backend = this.createBackend();
+        this.backend = backend;
+        backend.on("event", (event) => this.handleBackendEvent(event));
+        const resolved = await new CodexConfigBuilder(this.config).build();
+        this.skillStager.stage();
+        const input = prompt?.trim()
+            ? [{ type: "text", text: prompt.trim() }]
+            : [];
         let caughtError;
         try {
-            await this.runTurn(thread, prompt, abortController.signal);
+            await backend.open(resolved);
+            await backend.runTurn(input);
         }
         catch (error) {
             caughtError = error;
@@ -355,440 +136,52 @@ export class CodexRunner extends EventEmitter {
         }
         return this.sessionInfo;
     }
-    /**
-     * Check if the configured model is accessible via the OpenAI API.
-     * If not, swap to the fallback model before starting the session.
-     *
-     * Skipped when:
-     * - No OPENAI_API_KEY is set (Codex-native auth handles model access)
-     * - The user has a ChatGPT subscription (`codex login status` reports "Logged in using ChatGPT")
-     */
-    async resolveModelWithFallback() {
-        const model = this.config.model;
-        const fallback = this.config.fallbackModel;
-        if (!model || !fallback || fallback === model)
-            return;
-        const apiKey = process.env.OPENAI_API_KEY;
-        if (!apiKey)
-            return;
-        if (await this.hasCodexSubscription())
-            return;
-        const baseUrl = (process.env.OPENAI_BASE_URL ||
-            process.env.OPENAI_API_BASE ||
-            "https://api.openai.com/v1").replace(/\/+$/, "");
-        try {
-            const response = await fetch(`${baseUrl}/models/${encodeURIComponent(model)}`, {
-                method: "GET",
-                headers: { Authorization: `Bearer ${apiKey}` },
-                signal: AbortSignal.timeout(10_000),
-            });
-            if (response.status === 404) {
-                console.log(`[CodexRunner] Model "${model}" not found (404), falling back to "${fallback}"`);
-                this.config.model = fallback;
-            }
-        }
-        catch {
-            // Network error or timeout — proceed with the original model
-            // and let the Codex SDK handle any downstream failure.
-        }
+    createBackend() {
+        return new AppServerCodexBackend();
     }
-    /**
-     * Check if the user has a ChatGPT/Codex subscription by running `codex login status`.
-     * Returns true when the output contains "Logged in using ChatGPT",
-     * meaning the user has native Codex auth and can access the default Codex model.
-     */
-    async hasCodexSubscription() {
-        const codexBin = this.config.codexPath || "codex";
-        try {
-            const { execFile } = await import("node:child_process");
-            const { promisify } = await import("node:util");
-            const execFileAsync = promisify(execFile);
-            const { stdout, stderr } = await execFileAsync(codexBin, ["login", "status"], { timeout: 5_000 });
-            const result = /logged in using chatgpt/i.test(stdout + stderr);
-            console.log(`[CodexRunner] hasCodexSubscription: ${result} (stdout: "${stdout.trim()}"${stderr.trim() ? `, stderr: "${stderr.trim()}"` : ""})`);
-            return result;
+    handleBackendEvent(event) {
+        if (event.kind === "turn-started") {
+            // Turn is now steerable — deliver anything buffered during startup.
+            this.flushPendingFollowups();
         }
-        catch (error) {
-            console.warn(`[CodexRunner] hasCodexSubscription error (returning false): ${error instanceof Error ? error.message : String(error)}`);
-            return false;
+        else if (event.kind === "turn-completed" ||
+            event.kind === "turn-failed") {
+            this.turnFinished = true;
         }
+        this.mapper.handle(event);
     }
-    createCodexClient() {
-        const codexHome = this.resolveCodexHome();
-        const envOverride = this.buildEnvOverride(codexHome);
-        const configOverrides = this.buildConfigOverrides();
-        return new Codex({
-            ...(this.config.codexPath
-                ? { codexPathOverride: this.config.codexPath }
-                : {}),
-            ...(envOverride ? { env: envOverride } : {}),
-            ...(configOverrides ? { config: configOverrides } : {}),
+    steer(content) {
+        void this.backend
+            ?.steer?.([{ type: "text", text: content }])
+            .catch((error) => {
+            this.emit("error", error instanceof Error ? error : new Error(String(error)));
         });
     }
-    buildThreadOptions() {
-        const additionalDirectories = this.getAdditionalDirectories();
-        const reasoningEffort = this.config.modelReasoningEffort ??
-            getDefaultReasoningEffortForModel(this.config.model);
-        const webSearchMode = this.config.webSearchMode ??
-            (this.config.includeWebSearch ? "live" : undefined);
-        const threadOptions = {
-            model: this.config.model,
-            sandboxMode: this.config.sandbox || "workspace-write",
-            workingDirectory: this.config.workingDirectory,
-            skipGitRepoCheck: this.config.skipGitRepoCheck ?? true,
-            approvalPolicy: this.config.askForApproval || "never",
-            ...(reasoningEffort ? { modelReasoningEffort: reasoningEffort } : {}),
-            ...(webSearchMode ? { webSearchMode } : {}),
-            ...(additionalDirectories.length > 0 ? { additionalDirectories } : {}),
-        };
-        return threadOptions;
-    }
-    getAdditionalDirectories() {
-        const workingDirectory = this.config.workingDirectory;
-        const uniqueDirectories = new Set();
-        for (const directory of this.config.allowedDirectories || []) {
-            if (!directory || directory === workingDirectory) {
-                continue;
-            }
-            uniqueDirectories.add(directory);
+    flushPendingFollowups() {
+        const queued = this.pendingFollowups;
+        this.pendingFollowups = [];
+        for (const content of queued) {
+            this.steer(content);
         }
-        return [...uniqueDirectories];
-    }
-    resolveCodexHome() {
-        const codexHome = this.config.codexHome ||
-            process.env.CODEX_HOME ||
-            join(homedir(), ".codex");
-        mkdirSync(codexHome, { recursive: true });
-        return codexHome;
     }
-    buildEnvOverride(codexHome) {
-        if (!this.config.codexHome) {
-            return undefined;
-        }
-        const env = {};
-        for (const [key, value] of Object.entries(process.env)) {
-            if (typeof value === "string") {
-                env[key] = value;
-            }
-        }
-        env.CODEX_HOME = codexHome;
-        return env;
-    }
-    buildCodexMcpServersConfig() {
-        const autoDetectedPath = autoDetectMcpConfigPath(this.config.workingDirectory);
-        const configPaths = autoDetectedPath
-            ? [autoDetectedPath]
-            : [];
-        if (this.config.mcpConfigPath) {
-            const explicitPaths = Array.isArray(this.config.mcpConfigPath)
-                ? this.config.mcpConfigPath
-                : [this.config.mcpConfigPath];
-            configPaths.push(...explicitPaths);
-        }
-        const fileBasedServers = loadMcpConfigFromPaths(configPaths);
-        const mergedServers = this.config.mcpConfig
-            ? { ...fileBasedServers, ...this.config.mcpConfig }
-            : fileBasedServers;
-        if (Object.keys(mergedServers).length === 0) {
-            return undefined;
-        }
-        // Codex MCP configuration reference:
-        // https://platform.openai.com/docs/docs-mcp
-        const codexServers = {};
-        for (const [serverName, rawConfig] of Object.entries(mergedServers)) {
-            const configAny = rawConfig;
-            if (typeof configAny.listTools === "function" ||
-                typeof configAny.callTool === "function") {
-                console.warn(`[CodexRunner] Skipping MCP server '${serverName}' because in-process SDK server instances cannot be mapped to codex config`);
-                continue;
-            }
-            const mapped = {};
-            if (typeof configAny.command === "string") {
-                mapped.command = configAny.command;
-            }
-            if (Array.isArray(configAny.args)) {
-                mapped.args =
-                    configAny.args;
-            }
-            if (configAny.env &&
-                typeof configAny.env === "object" &&
-                !Array.isArray(configAny.env)) {
-                mapped.env =
-                    configAny.env;
-            }
-            if (typeof configAny.cwd === "string") {
-                mapped.cwd = configAny.cwd;
-            }
-            if (typeof configAny.url === "string") {
-                mapped.url = configAny.url;
-            }
-            if (configAny.http_headers &&
-                typeof configAny.http_headers === "object" &&
-                !Array.isArray(configAny.http_headers)) {
-                mapped.http_headers =
-                    configAny.http_headers;
-            }
-            if (configAny.headers &&
-                typeof configAny.headers === "object" &&
-                !Array.isArray(configAny.headers)) {
-                mapped.http_headers =
-                    configAny.headers;
-            }
-            if (configAny.env_http_headers &&
-                typeof configAny.env_http_headers === "object" &&
-                !Array.isArray(configAny.env_http_headers)) {
-                mapped.env_http_headers =
-                    configAny.env_http_headers;
-            }
-            if (typeof configAny.bearer_token_env_var === "string") {
-                mapped.bearer_token_env_var = configAny.bearer_token_env_var;
-            }
-            if (typeof configAny.timeout === "number") {
-                mapped.timeout = configAny.timeout;
-            }
-            if (!mapped.command && !mapped.url) {
-                console.warn(`[CodexRunner] Skipping MCP server '${serverName}' because it has no command/url transport`);
-                continue;
-            }
-            codexServers[serverName] = mapped;
-        }
-        if (Object.keys(codexServers).length === 0) {
-            return undefined;
-        }
-        console.log(`[CodexRunner] Configured ${Object.keys(codexServers).length} MCP server(s) for codex config (docs: ${CODEX_MCP_DOCS_URL})`);
-        return codexServers;
-    }
-    buildConfigOverrides() {
-        const appendSystemPrompt = (this.config.appendSystemPrompt ?? "").trim();
-        const configOverrides = this.config.configOverrides
-            ? { ...this.config.configOverrides }
-            : {};
-        const mcpServers = this.buildCodexMcpServersConfig();
-        if (mcpServers) {
-            const existingMcpServers = configOverrides.mcp_servers;
-            if (existingMcpServers &&
-                typeof existingMcpServers === "object" &&
-                !Array.isArray(existingMcpServers)) {
-                configOverrides.mcp_servers = {
-                    ...existingMcpServers,
-                    ...mcpServers,
-                };
-            }
-            else {
-                configOverrides.mcp_servers = mcpServers;
-            }
-        }
-        const sandboxWorkspaceWrite = configOverrides.sandbox_workspace_write;
-        // Keep workspace-write as the default sandbox, but enable outbound network so
-        // common remote workflows (for example `git`/`gh` against GitHub) work without
-        // requiring danger-full-access.
-        if (sandboxWorkspaceWrite &&
-            typeof sandboxWorkspaceWrite === "object" &&
-            !Array.isArray(sandboxWorkspaceWrite)) {
-            configOverrides.sandbox_workspace_write = {
-                ...sandboxWorkspaceWrite,
-                network_access: sandboxWorkspaceWrite
-                    .network_access ?? true,
-            };
-        }
-        else if (!sandboxWorkspaceWrite) {
-            configOverrides.sandbox_workspace_write = { network_access: true };
-        }
-        if (!appendSystemPrompt) {
-            return Object.keys(configOverrides).length > 0
-                ? configOverrides
-                : undefined;
-        }
+    buildMapperContext() {
+        const self = this;
         return {
-            ...configOverrides,
-            developer_instructions: appendSystemPrompt,
-        };
-    }
-    async runTurn(thread, prompt, signal) {
-        const streamedTurn = await thread.runStreamed(prompt, {
-            signal,
-            ...(this.config.outputSchema
-                ? { outputSchema: this.config.outputSchema }
-                : {}),
-        });
-        for await (const event of streamedTurn.events) {
-            this.handleEvent(event);
-        }
-    }
-    handleEvent(event) {
-        this.emit("streamEvent", event);
-        switch (event.type) {
-            case "thread.started": {
-                if (this.sessionInfo) {
-                    this.sessionInfo.sessionId = event.thread_id;
+            get workingDirectory() {
+                return self.config.workingDirectory;
+            },
+            get model() {
+                return self.config.model;
+            },
+            getSessionId: () => self.sessionInfo?.sessionId || "pending",
+            getStagedSkillNames: () => self.skillStager.getStagedSkillNames(),
+            emitMessage: (message) => self.emit("message", message),
+            onThreadStarted: (threadId) => {
+                if (self.sessionInfo) {
+                    self.sessionInfo.sessionId = threadId;
                 }
-                this.emitSystemInitMessage(event.thread_id);
-                break;
-            }
-            case "item.completed": {
-                if (event.item.type === "agent_message") {
-                    this.emitAssistantMessage(event.item.text);
-                }
-                else {
-                    this.emitToolMessagesForItem(event.item, true);
-                }
-                break;
-            }
-            case "item.started": {
-                this.emitToolMessagesForItem(event.item, false);
-                break;
-            }
-            case "turn.completed": {
-                this.lastUsage = parseUsage(event.usage);
-                this.pendingResultMessage = this.createSuccessResultMessage(this.lastAssistantText || "Codex session completed successfully");
-                break;
-            }
-            case "turn.failed": {
-                // Prefer event.error.message; fallback to last standalone "error" event
-                const message = event.error?.message ||
-                    this.errorMessages.at(-1) ||
-                    "Codex execution failed";
-                this.errorMessages.push(message);
-                this.pendingResultMessage = this.createErrorResultMessage(message);
-                break;
-            }
-            case "error": {
-                this.errorMessages.push(event.message);
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    projectItemToTool(item) {
-        switch (item.type) {
-            case "command_execution": {
-                const commandItem = item;
-                const isError = commandItem.status === "failed" ||
-                    (typeof commandItem.exit_code === "number" &&
-                        commandItem.exit_code !== 0);
-                const result = commandItem.aggregated_output?.trim() ||
-                    (isError
-                        ? `Command failed (exit code ${commandItem.exit_code ?? "unknown"})`
-                        : "Command completed with no output");
-                return {
-                    toolUseId: commandItem.id,
-                    toolName: inferCommandToolName(commandItem.command),
-                    toolInput: { command: commandItem.command },
-                    result,
-                    isError,
-                };
-            }
-            case "file_change": {
-                const fileChangeItem = item;
-                const primaryPath = fileChangeItem.changes[0]?.path &&
-                    normalizeFilePath(fileChangeItem.changes[0].path, this.config.workingDirectory);
-                return {
-                    toolUseId: fileChangeItem.id,
-                    toolName: "Edit",
-                    toolInput: {
-                        ...(primaryPath ? { file_path: primaryPath } : {}),
-                        changes: fileChangeItem.changes.map((change) => ({
-                            kind: change.kind,
-                            path: normalizeFilePath(change.path, this.config.workingDirectory),
-                        })),
-                    },
-                    result: summarizeFileChanges(fileChangeItem, this.config.workingDirectory),
-                    isError: fileChangeItem.status === "failed",
-                };
-            }
-            case "web_search": {
-                const webSearchItem = item;
-                const extendedItem = item;
-                const action = asRecord(extendedItem.action);
-                const actionType = typeof action?.type === "string" ? action.type : undefined;
-                const isFetch = actionType === "open_page";
-                const url = typeof action?.url === "string"
-                    ? action.url
-                    : typeof extendedItem.url === "string"
-                        ? extendedItem.url
-                        : undefined;
-                const pattern = typeof action?.pattern === "string"
-                    ? action.pattern
-                    : typeof extendedItem.pattern === "string"
-                        ? extendedItem.pattern
-                        : undefined;
-                return {
-                    toolUseId: webSearchItem.id,
-                    toolName: isFetch ? "WebFetch" : "WebSearch",
-                    toolInput: isFetch
-                        ? {
-                            url: url || webSearchItem.query,
-                            ...(pattern ? { pattern } : {}),
-                        }
-                        : { query: webSearchItem.query },
-                    result: action && Object.keys(action).length > 0
-                        ? safeStringify(action)
-                        : `Search completed for query: ${webSearchItem.query}`,
-                    isError: false,
-                };
-            }
-            case "mcp_tool_call": {
-                const mcpItem = item;
-                return {
-                    toolUseId: mcpItem.id,
-                    toolName: `mcp__${normalizeMcpIdentifier(mcpItem.server)}__${normalizeMcpIdentifier(mcpItem.tool)}`,
-                    toolInput: asRecord(mcpItem.arguments) || {
-                        arguments: mcpItem.arguments,
-                    },
-                    result: toMcpResultString(mcpItem),
-                    isError: mcpItem.status === "failed" || Boolean(mcpItem.error),
-                };
-            }
-            case "todo_list": {
-                const todoItem = item;
-                return {
-                    toolUseId: todoItem.id,
-                    toolName: "TodoWrite",
-                    toolInput: {
-                        todos: todoItem.items.map((todo) => ({
-                            content: todo.text,
-                            status: todo.completed ? "completed" : "pending",
-                        })),
-                    },
-                    result: `Updated todo list (${todoItem.items.length} items)`,
-                    isError: false,
-                };
-            }
-            default:
-                return null;
-        }
-    }
-    emitToolMessagesForItem(item, includeResult) {
-        const projection = this.projectItemToTool(item);
-        if (!projection) {
-            return;
-        }
-        if (!this.emittedToolUseIds.has(projection.toolUseId)) {
-            const assistantMessage = {
-                type: "assistant",
-                message: createAssistantToolUseMessage(projection.toolUseId, projection.toolName, projection.toolInput),
-                parent_tool_use_id: null,
-                uuid: crypto.randomUUID(),
-                session_id: this.sessionInfo?.sessionId || "pending",
-            };
-            this.messages.push(assistantMessage);
-            this.emit("message", assistantMessage);
-            this.emittedToolUseIds.add(projection.toolUseId);
-        }
-        if (!includeResult) {
-            return;
-        }
-        const userMessage = {
-            type: "user",
-            message: createUserToolResultMessage(projection.toolUseId, projection.result, projection.isError),
-            parent_tool_use_id: null,
-            uuid: crypto.randomUUID(),
-            session_id: this.sessionInfo?.sessionId || "pending",
+            },
         };
-        this.messages.push(userMessage);
-        this.emit("message", userMessage);
-        this.emittedToolUseIds.delete(projection.toolUseId);
     }
     finalizeSession(caughtError) {
         if (!this.sessionInfo) {
@@ -796,128 +189,20 @@ export class CodexRunner extends EventEmitter {
             return;
         }
         this.sessionInfo.isRunning = false;
-        // Ensure init is emitted even if stream fails before thread.started.
-        if (!this.hasInitMessage) {
-            this.emitSystemInitMessage(this.sessionInfo.sessionId || this.config.resumeSessionId || "pending");
-        }
-        if (caughtError && !this.wasStopped) {
-            const errorMessage = normalizeError(caughtError);
-            this.errorMessages.push(errorMessage);
-        }
-        if (!this.pendingResultMessage && !this.wasStopped) {
-            if (caughtError) {
-                this.pendingResultMessage = this.createErrorResultMessage(this.errorMessages.at(-1) || "Codex execution failed");
-            }
-            else {
-                this.pendingResultMessage = this.createSuccessResultMessage(this.lastAssistantText || "Codex session completed successfully");
-            }
-        }
-        if (this.pendingResultMessage) {
-            this.messages.push(this.pendingResultMessage);
-            this.emit("message", this.pendingResultMessage);
-            this.pendingResultMessage = null;
-        }
-        this.emit("complete", [...this.messages]);
+        const messages = this.mapper.finalize({
+            caughtError,
+            wasStopped: this.wasStopped,
+        });
+        this.emit("complete", messages);
         this.cleanupRuntimeState();
     }
-    emitAssistantMessage(text) {
-        const normalized = text.trim();
-        if (!normalized) {
-            return;
-        }
-        this.lastAssistantText = normalized;
-        const assistantMessage = {
-            type: "assistant",
-            message: createAssistantBetaMessage(normalized),
-            parent_tool_use_id: null,
-            uuid: crypto.randomUUID(),
-            session_id: this.sessionInfo?.sessionId || "pending",
-        };
-        this.messages.push(assistantMessage);
-        this.emit("message", assistantMessage);
-    }
-    emitSystemInitMessage(sessionId) {
-        if (this.hasInitMessage) {
-            return;
-        }
-        this.hasInitMessage = true;
-        const initMessage = {
-            type: "system",
-            subtype: "init",
-            agents: undefined,
-            apiKeySource: "user",
-            claude_code_version: "codex-cli",
-            cwd: this.config.workingDirectory || cwd(),
-            tools: [],
-            mcp_servers: [],
-            model: this.config.model || DEFAULT_CODEX_MODEL,
-            permissionMode: "default",
-            slash_commands: [],
-            output_style: "default",
-            skills: [],
-            plugins: [],
-            uuid: crypto.randomUUID(),
-            session_id: sessionId,
-        };
-        this.messages.push(initMessage);
-        this.emit("message", initMessage);
-    }
-    createSuccessResultMessage(result) {
-        const durationMs = Math.max(Date.now() - this.startTimestampMs, 0);
-        return {
-            type: "result",
-            subtype: "success",
-            duration_ms: durationMs,
-            duration_api_ms: 0,
-            is_error: false,
-            num_turns: 1,
-            result,
-            stop_reason: null,
-            total_cost_usd: 0,
-            usage: createResultUsage(this.lastUsage),
-            modelUsage: {},
-            permission_denials: [],
-            uuid: crypto.randomUUID(),
-            session_id: this.sessionInfo?.sessionId || "pending",
-        };
-    }
-    createErrorResultMessage(errorMessage) {
-        const durationMs = Math.max(Date.now() - this.startTimestampMs, 0);
-        return {
-            type: "result",
-            subtype: "error_during_execution",
-            duration_ms: durationMs,
-            duration_api_ms: 0,
-            is_error: true,
-            num_turns: 1,
-            stop_reason: null,
-            errors: [errorMessage],
-            total_cost_usd: 0,
-            usage: createResultUsage(this.lastUsage),
-            modelUsage: {},
-            permission_denials: [],
-            uuid: crypto.randomUUID(),
-            session_id: this.sessionInfo?.sessionId || "pending",
-        };
-    }
     cleanupRuntimeState() {
-        this.abortController = null;
-    }
-    stop() {
-        if (!this.sessionInfo?.isRunning) {
-            return;
+        const backend = this.backend;
+        this.backend = null;
+        if (backend) {
+            void backend.close();
         }
-        this.wasStopped = true;
-        this.abortController?.abort();
-    }
-    isRunning() {
-        return this.sessionInfo?.isRunning ?? false;
-    }
-    getMessages() {
-        return [...this.messages];
-    }
-    getFormatter() {
-        return this.formatter;
+        this.skillStager.cleanup();
     }
 }
 //# sourceMappingURL=CodexRunner.js.map