@northflare/runner 0.0.30 → 0.0.32

package/dist/components/codex-sdk-manager.js

@@ -1,1450 +0,0 @@
-import { statusLineManager } from '../utils/status-line.js';
-import { createScopedConsole } from '../utils/console.js';
-import { expandEnv } from '../utils/expand-env.js';
-import { mapReasoningEffortForCodex, parseModelValue } from '../utils/model.js';
-import jwt from "jsonwebtoken";
-import fs from "fs/promises";
-import path from "path";
-import { isDebugEnabledFor } from '../utils/debug.js';
-import { tmpdir } from "os";
-import crypto from "crypto";
-import { simpleGit } from "simple-git";
-const console = createScopedConsole(isDebugEnabledFor("manager") ? "manager" : "sdk");
-function buildSystemPromptWithNorthflare(basePrompt, northflarePrompt) {
-    const parts = [northflarePrompt, basePrompt]
-        .filter((p) => typeof p === "string" && p.trim().length > 0)
-        .map((p) => p.trim());
-    if (parts.length === 0)
-        return undefined;
-    return parts.join("\n\n");
-}
-let codexSdkPromise = null;
-async function loadCodexSdk() {
-    if (!codexSdkPromise) {
-        codexSdkPromise = import("@northflare/codex-sdk");
-    }
-    return codexSdkPromise;
-}
-export class CodexManager {
-    runner;
-    repositoryManager;
-    threadStates = new Map();
-    constructor(runner, repositoryManager) {
-        this.runner = runner;
-        this.repositoryManager = repositoryManager;
-    }
-    async startConversation(conversationObjectType, conversationObjectId, config, initialMessages, conversationData, provider) {
-        if (!conversationData?.id) {
-            throw new Error("startConversation requires conversationData with a valid conversation.id");
-        }
-        const conversationId = conversationData.id;
-        const agentSessionId = this.resolveSessionId(config, conversationData);
-        const pendingSummary = this.runner.consumePendingConversationSummary(conversationId);
-        const rawSummary = typeof conversationData.summary === "string"
-            ? conversationData.summary
-            : pendingSummary;
-        const normalizedSummary = typeof rawSummary === "string"
-            ? rawSummary.replace(/\s+/g, " ").trim()
-            : null;
-        const rawModel = conversationData?.model ||
-            config?.model ||
-            config?.defaultModel ||
-            "openai";
-        const { baseModel, reasoningEffort } = parseModelValue(rawModel);
-        const codexReasoningEffort = mapReasoningEffortForCodex(reasoningEffort);
-        const normalizedModel = baseModel || rawModel;
-        // Debug logging for model parsing
-        console.log("[CodexManager] Model parsing debug:", {
-            rawModel,
-            baseModel,
-            reasoningEffort,
-            codexReasoningEffort,
-            normalizedModel,
-        });
-        // Determine the actual provider - can be passed explicitly or detected from config
-        const resolvedProvider = provider ||
-            config?.providerType ||
-            conversationData?.providerType ||
-            "openai";
-        // Optional system prompt handling (matches Northflare/Claude managers)
-        const providedSystemPrompt = buildSystemPromptWithNorthflare(config.systemPrompt || conversationData?.systemPrompt, config?.northflareSystemPrompt ||
-            conversationData?.northflareSystemPrompt);
-        const systemPromptMode = config.systemPromptMode ||
-            conversationData?.systemPromptMode ||
-            "append";
-        const metadata = {
-            instructionsInjected: false,
-            originalModelValue: rawModel,
-        };
-        metadata["hasSystemPrompt"] = Boolean(providedSystemPrompt);
-        metadata["systemPromptMode"] = systemPromptMode;
-        if (reasoningEffort) {
-            metadata["modelReasoningEffort"] = reasoningEffort;
-        }
-        const context = {
-            conversationId,
-            agentSessionId,
-            conversationObjectType,
-            conversationObjectId,
-            taskId: conversationObjectType === "Task" ? conversationObjectId : undefined,
-            workspaceId: config.workspaceId,
-            status: "starting",
-            config,
-            startedAt: new Date(),
-            lastActivityAt: new Date(),
-            model: normalizedModel,
-            summary: normalizedSummary,
-            globalInstructions: conversationData.globalInstructions || "",
-            workspaceInstructions: conversationData.workspaceInstructions || "",
-            permissionsMode: conversationData.permissionsMode ||
-                config?.permissionsMode ||
-                "all",
-            provider: resolvedProvider,
-            metadata,
-        };
-        this.runner.activeConversations_.set(conversationId, context);
-        console.log(`[CodexManager] Stored conversation context`, {
-            conversationId,
-            agentSessionId,
-            model: context.model,
-            permissionsMode: context.permissionsMode,
-        });
-        const workspacePath = await this.resolveWorkspacePath(context, config);
-        context.metadata["workspacePath"] = workspacePath;
-        const githubToken = context.workspaceId
-            ? await this.fetchGithubTokens(context.workspaceId)
-            : undefined;
-        const toolToken = this.generateToolToken(context);
-        let mcpServers;
-        if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
-            const expandedServers = expandEnv(config.mcpServers, {
-                TOOL_TOKEN: toolToken,
-            });
-            mcpServers = this.normalizeMcpServersForCodex(expandedServers);
-            console.log("[CodexManager] MCP servers configuration:", JSON.stringify(mcpServers, null, 2));
-            context.metadata["mcpServers"] = mcpServers;
-        }
-        let configOverrides = this.buildConfigOverridesFromMcp(mcpServers);
-        // Add OpenRouter config overrides if using OpenRouter provider
-        if (resolvedProvider === "openrouter") {
-            const openRouterOverrides = this.buildOpenRouterConfigOverrides();
-            configOverrides = {
-                ...configOverrides,
-                ...openRouterOverrides,
-            };
-            console.log("[CodexManager] OpenRouter config overrides:", JSON.stringify(openRouterOverrides, null, 2));
-        }
-        // Inject system prompt via developer_instructions (developer role message)
-        if (providedSystemPrompt) {
-            const trimmedPrompt = providedSystemPrompt.trim();
-            if (trimmedPrompt.length) {
-                const systemPromptOverrides = {
-                    developer_instructions: trimmedPrompt,
-                };
-                configOverrides = {
-                    ...configOverrides,
-                    ...systemPromptOverrides,
-                };
-                console.log("[CodexManager] Applied system prompt overrides", {
-                    mode: systemPromptMode,
-                    hasSystemPrompt: true,
-                    replacesBase: systemPromptMode === "replace",
-                });
-            }
-        }
-        const envVars = await this.buildEnvVars(config, githubToken, toolToken, resolvedProvider);
-        const { Codex } = await loadCodexSdk();
-        const codex = new Codex({
-            baseUrl: config?.openaiBaseUrl ||
-                config?.codexBaseUrl ||
-                process.env["OPENAI_BASE_URL"],
-            apiKey: config?.openaiApiKey ||
-                config?.codexApiKey ||
-                process.env["CODEX_API_KEY"] ||
-                process.env["OPENAI_API_KEY"],
-            env: envVars,
-        });
-        // Strip provider prefix (e.g., "openrouter:") from model name if present
-        const modelName = context.model.includes(":")
-            ? context.model.split(":").slice(1).join(":")
-            : context.model;
-        // Debug: log what model name we're using
-        console.log("[CodexManager] Model name processing:", {
-            contextModel: context.model,
-            hasColon: context.model.includes(":"),
-            modelNameAfterStrip: modelName,
-        });
-        const threadOptions = {
-            model: modelName,
-            workingDirectory: workspacePath,
-            sandboxMode: this.mapSandboxMode(context.permissionsMode),
-            networkAccessEnabled: this.shouldEnableNetwork(context.permissionsMode),
-            webSearchEnabled: true,
-            // additionalDirectories: this.getAdditionalDirectories(config),
-            configOverrides,
-            skipGitRepoCheck: true,
-            modelReasoningEffort: codexReasoningEffort,
-        };
-        console.log("[CodexManager] Thread options:", JSON.stringify(threadOptions, null, 2));
-        const thread = agentSessionId
-            ? codex.resumeThread(agentSessionId, threadOptions)
-            : codex.startThread(threadOptions);
-        this.threadStates.set(conversationId, {
-            thread,
-            abortController: null,
-            runPromise: null,
-        });
-        context.conversation = thread;
-        // Launch the first turn using the provided initial messages.
-        // Supports multimodal (images/documents) by converting to Codex Input.
-        if (initialMessages?.length) {
-            const initialInput = await this.buildInitialInput(initialMessages, context);
-            this.launchTurn(context, initialInput);
-        }
-        return context;
-    }
-    async stopConversation(_agentSessionId, context, isRunnerShutdown = false, reason) {
-        context._stopRequested = true;
-        context._stopReason =
-            reason || (isRunnerShutdown ? "runner_shutdown" : undefined);
-        context.status = "stopping";
-        await this.abortActiveRun(context.conversationId);
-        try {
-            await this._finalizeConversation(context, false, undefined, context._stopReason);
-        }
-        catch (error) {
-            console.error(`[CodexManager] Error finalizing conversation ${context.conversationId}:`, error);
-        }
-        finally {
-            this.threadStates.delete(context.conversationId);
-        }
-        context.status = "stopped";
-    }
-    async resumeConversation(conversationObjectType, conversationObjectId, agentSessionId, config, conversationData, resumeMessage, provider) {
-        console.log(`[CodexManager] Resuming conversation ${agentSessionId}`);
-        const context = await this.startConversation(conversationObjectType, conversationObjectId, { ...config, sessionId: agentSessionId }, [], conversationData, provider);
-        if (resumeMessage) {
-            const prompt = this.buildPromptForMessage(context, resumeMessage, false);
-            this.launchTurn(context, prompt);
-        }
-        return context.agentSessionId;
-    }
-    async sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation, agentSessionIdOverride, provider) {
-        console.log(`[CodexManager] sendUserMessage called`, {
-            conversationId,
-            hasConfig: !!config,
-        });
-        let context = this.runner.getConversationContext(conversationId);
-        if (!context && conversation) {
-            const conversationDetails = conversation;
-            const resumeSessionId = this.resolveSessionId(config, conversationDetails, agentSessionIdOverride);
-            const startConfig = {
-                ...(config || {}),
-                workspaceId: conversationDetails.workspaceId || config?.workspaceId || undefined,
-                ...(resumeSessionId ? { sessionId: resumeSessionId } : {}),
-            };
-            context = await this.startConversation(conversationObjectType ||
-                conversationDetails.objectType, conversationObjectId || conversationDetails.objectId, startConfig, [], conversationDetails, provider);
-        }
-        if (!context) {
-            throw new Error(`No active or fetchable conversation found for ${conversationId}`);
-        }
-        await this.abortActiveRun(conversationId);
-        const input = await this.normalizeToInput(content, context, false);
-        this.launchTurn(context, input);
-        context.lastActivityAt = new Date();
-    }
-    async _handleRunCompletion(context, hadError, error) {
-        if (context._finalized)
-            return;
-        const inFlight = context._runCompletionInFlight;
-        if (inFlight)
-            return inFlight;
-        const promise = (async () => {
-            const isTaskConversation = context.conversationObjectType === "Task";
-            const stopRequested = context._stopRequested === true;
-            const taskHandle = context.taskHandle;
-            const shouldRunGitFlow = context.config.useWorktrees !== false &&
-                isTaskConversation &&
-                !!taskHandle &&
-                taskHandle.branch !== "local";
-            if (!shouldRunGitFlow || hadError || stopRequested) {
-                await this._finalizeConversation(context, hadError, error);
-                return;
-            }
-            const taskId = context.conversationObjectId;
-            const baseBranch = context.config.repository?.branch || "main";
-            try {
-                const taskState = await this.repositoryManager.getTaskState(taskId);
-                const taskRepoInfo = await this.repositoryManager.getTaskRepoInfo(taskId);
-                if (!taskState ||
-                    !taskRepoInfo ||
-                    !taskRepoInfo.worktreePath ||
-                    taskState.branch === "local") {
-                    await this._finalizeConversation(context, false);
-                    return;
-                }
-                const isLocalRepo = taskRepoInfo.repoKey.startsWith("local__");
-                const mergeWorkdir = isLocalRepo
-                    ? taskRepoInfo.controlPath
-                    : taskRepoInfo.worktreePath;
-                // If we already have unresolved conflicts, immediately ask the agent to resolve them.
-                const taskGit = simpleGit(taskRepoInfo.worktreePath);
-                const initialTaskStatus = await taskGit.status();
-                if (initialTaskStatus.conflicted.length > 0) {
-                    await this._resumeForGitConflictResolution(context, {
-                        kind: "conflicts",
-                        baseBranch,
-                        conflicts: initialTaskStatus.conflicted,
-                        workdir: taskRepoInfo.worktreePath,
-                    });
-                    return;
-                }
-                if (isLocalRepo && mergeWorkdir !== taskRepoInfo.worktreePath) {
-                    const mergeGit = simpleGit(mergeWorkdir);
-                    const mergeStatus = await mergeGit.status();
-                    if (mergeStatus.conflicted.length > 0) {
-                        await this._resumeForGitConflictResolution(context, {
-                            kind: "conflicts",
-                            baseBranch,
-                            conflicts: mergeStatus.conflicted,
-                            workdir: mergeWorkdir,
-                        });
-                        return;
-                    }
-                }
-                // Ensure we're on the task branch for commit/rebase operations.
-                const currentBranch = (await taskGit.revparse(["--abbrev-ref", "HEAD"])).trim();
-                if (currentBranch !== taskState.branch) {
-                    await taskGit.checkout(taskState.branch);
-                }
-                const status = await taskGit.status();
-                if (!status.isClean()) {
-                    await this.repositoryManager.stageAll(taskId);
-                    try {
-                        const previousCommitCount = taskState?.commitCount ?? 0;
-                        const baseSubject = (context.summary ?? "").replace(/\s+/g, " ").trim() ||
-                            `Task ${taskId}`;
-                        const message = previousCommitCount > 0
-                            ? `${baseSubject} (followup #${previousCommitCount})`
-                            : baseSubject;
-                        await this.repositoryManager.commit(taskId, message);
-                    }
-                    catch (commitError) {
-                        const msg = commitError instanceof Error
-                            ? commitError.message
-                            : String(commitError);
-                        if (!msg.toLowerCase().includes("nothing to commit")) {
-                            throw commitError;
-                        }
-                    }
-                }
-                const integrateResult = await this.repositoryManager.integrateTask(taskId, baseBranch, "no-ff");
-                if (!integrateResult.success) {
-                    await this._resumeForGitConflictResolution(context, {
-                        kind: integrateResult.phase,
-                        baseBranch,
-                        conflicts: integrateResult.conflicts ?? [],
-                        workdir: integrateResult.conflictWorkdir,
-                        error: integrateResult.error,
-                    });
-                    return;
-                }
-                // Worktree is no longer needed after a successful merge; preserve the branch
-                await this.repositoryManager.removeTaskWorktree(taskId, {
-                    preserveBranch: true,
-                });
-                const wsId = context.config.workspaceId || context.workspaceId;
-                const repoUrl = context.config.repository?.url;
-                if (wsId && repoUrl) {
-                    await this.repositoryManager.syncWorkspaceWorktree(wsId, repoUrl, baseBranch);
-                }
-                await this._finalizeConversation(context, false);
-            }
-            catch (mergeError) {
-                console.error("[CodexManager] Post-task git flow failed", mergeError);
-                await this._finalizeConversation(context, true, mergeError);
-            }
-        })();
-        context._runCompletionInFlight = promise.finally(() => {
-            delete context._runCompletionInFlight;
-        });
-        return context._runCompletionInFlight;
-    }
-    async _resumeForGitConflictResolution(context, payload) {
-        const { kind, baseBranch, conflicts, workdir, error } = payload;
-        const conflictsList = conflicts?.length
-            ? `\n\nConflicted files:\n${conflicts.map((f) => `- ${f}`).join("\n")}`
-            : "";
-        const workdirHint = workdir ? `\n\nWork directory:\n- ${workdir}` : "";
-        const errorHint = error ? `\n\nError:\n${error}` : "";
-        const hasConflicts = !!conflicts?.length;
-        let instruction;
-        if (kind === "rebase") {
-            instruction = hasConflicts
-                ? `<system-instructions>\nA git rebase onto \`${baseBranch}\` produced merge conflicts.${conflictsList}${workdirHint}${errorHint}\n\nPlease resolve the conflicts in that directory, then run:\n- git add -A\n- git rebase --continue\n\nWhen the rebase finishes cleanly, reply briefly so I can retry the integration.\n</system-instructions>`
-                : `<system-instructions>\nA git rebase onto \`${baseBranch}\` failed.${workdirHint}${errorHint}\n\nNo conflicted files were reported. Please run:\n- git status\n\nFix the error (or complete/abort any in-progress git operation) and reply briefly so I can retry the integration.\n</system-instructions>`;
-        }
-        else if (kind === "merge") {
-            instruction = hasConflicts
-                ? `<system-instructions>\nA git merge into \`${baseBranch}\` produced merge conflicts.${conflictsList}${workdirHint}${errorHint}\n\nPlease resolve the conflicts in that directory, then run:\n- git add -A\n- git commit -m \"Resolve merge conflicts for ${context.conversationObjectId}\"\n\nWhen the working tree is clean, reply briefly so I can retry the integration.\n</system-instructions>`
-                : `<system-instructions>\nA git merge into \`${baseBranch}\` failed.${workdirHint}${errorHint}\n\nNo conflicted files were reported. Please run:\n- git status\n\nFix the error (or complete/abort any in-progress git operation) and reply briefly so I can retry the integration.\n</system-instructions>`;
-        }
-        else {
-            instruction = `<system-instructions>\nGit has unresolved conflicts.${conflictsList}${workdirHint}${errorHint}\n\nPlease resolve the conflicts in that directory and complete the in-progress git operation (rebase or merge). When the working tree is clean, reply briefly so I can retry the integration.\n</system-instructions>`;
-        }
-        const conversationData = {
-            id: context.conversationId,
-            objectType: context.conversationObjectType,
-            objectId: context.conversationObjectId,
-            model: context.model,
-            summary: context.summary ?? null,
-            globalInstructions: context.globalInstructions,
-            workspaceInstructions: context.workspaceInstructions,
-            permissionsMode: context.permissionsMode,
-            agentSessionId: context.agentSessionId,
-            workspaceId: context.workspaceId,
-        };
-        await this.resumeConversation(context.conversationObjectType, context.conversationObjectId, context.agentSessionId, context.config, conversationData, instruction, context.provider);
-    }
-    async buildEnvVars(config, githubToken, toolToken, provider) {
-        const envVars = {
-            ...Object.fromEntries(Object.entries(process.env).filter(([, value]) => value !== undefined)),
-        };
-        if (config.codexAuth?.accessToken) {
-            envVars["OPENAI_ACCESS_TOKEN"] = config.codexAuth.accessToken;
-        }
-        else if (config.accessToken) {
-            envVars["OPENAI_ACCESS_TOKEN"] = config.accessToken;
-        }
-        if (githubToken) {
-            envVars["GITHUB_TOKEN"] = githubToken;
-        }
-        if (toolToken) {
-            envVars["TOOL_TOKEN"] = toolToken;
-        }
-        if (isDebugEnabledFor("sdk")) {
-            envVars["DEBUG"] = "1";
-        }
-        // Add OpenRouter/Groq API keys when using Northflare-routed providers
-        if (provider === "openrouter" || provider === "groq") {
-            const openRouterApiKey = config.openRouterApiKey ||
-                process.env["OPENROUTER_API_KEY"];
-            if (openRouterApiKey) {
-                envVars["OPENROUTER_API_KEY"] = openRouterApiKey;
-            }
-            const groqApiKey = config.groqApiKey ||
-                process.env["GROQ_API_KEY"];
-            if (groqApiKey) {
-                envVars["GROQ_API_KEY"] = groqApiKey;
-            }
-            if (!openRouterApiKey && !groqApiKey) {
-                console.warn("[CodexManager] OpenRouter/Groq provider selected but no API key found");
-            }
-        }
-        const codexHome = await this.ensureCodexAuthHome(config);
-        if (codexHome) {
-            envVars["CODEX_HOME"] = codexHome;
-        }
-        return envVars;
-    }
-    async ensureCodexAuthHome(config) {
-        if (!config.codexAuth) {
-            return null;
-        }
-        const runnerId = this.runner.getRunnerId();
-        const dataDir = this.runner.config_.dataDir;
-        if (!runnerId || !dataDir) {
-            console.warn("[CodexManager] Missing runnerId or dataDir; cannot prepare Codex auth directory");
-            return null;
-        }
-        const codexDir = path.join(dataDir, "codex", runnerId);
-        const authPayload = {
-            OPENAI_API_KEY: null,
-            tokens: {
-                id_token: config.codexAuth.idToken,
-                access_token: config.codexAuth.accessToken,
-                refresh_token: "",
-                account_id: config.codexAuth.accountId,
-            },
-            last_refresh: config.codexAuth.lastRefresh || new Date().toISOString(),
-        };
-        try {
-            await fs.mkdir(codexDir, { recursive: true });
-            await fs.writeFile(path.join(codexDir, "auth.json"), JSON.stringify(authPayload, null, 2), "utf-8");
-            return codexDir;
-        }
-        catch (error) {
-            console.error("[CodexManager] Failed to persist Codex auth configuration:", error);
-            throw new Error("Runner failed to persist Codex credentials. Check runner logs for details.");
-        }
-    }
-    buildPromptForMessage(context, text, forceInstructions) {
-        const trimmed = text ?? "";
-        const instructions = this.getInstructionPrefix(context);
-        const metadata = context.metadata || {};
-        const shouldInjectInstructions = forceInstructions || !metadata["instructionsInjected"];
-        if (instructions && shouldInjectInstructions) {
-            metadata["instructionsInjected"] = true;
-            context.metadata = metadata;
-            return `${instructions}\n\n${trimmed}`.trim();
-        }
-        return trimmed;
-    }
-    getInstructionPrefix(context) {
-        const parts = [];
-        if (context.globalInstructions) {
-            parts.push(`<global-instructions>\n${context.globalInstructions}\n</global-instructions>`);
-        }
-        if (context.workspaceInstructions) {
-            parts.push(`<workspace-instructions>\n${context.workspaceInstructions}\n</workspace-instructions>`);
-        }
-        return parts.join("\n\n");
-    }
-    formatInitialMessages(initialMessages) {
-        return initialMessages
-            .map((msg) => {
-            const role = msg.role || "user";
-            const content = this.normalizeToText(msg.content);
-            return `<${role}-message>\n${content}\n</${role}-message>`;
-        })
-            .join("\n\n");
-    }
-    async buildInitialInput(initialMessages, context) {
-        const hasMultimodal = initialMessages.some((msg) => this.hasMultimodalContent(msg.content));
-        if (!hasMultimodal) {
-            const promptText = this.formatInitialMessages(initialMessages);
-            return this.buildPromptForMessage(context, promptText, true);
-        }
-        // Preserve role markers while keeping image blocks attached
-        const combinedBlocks = [];
-        for (const msg of initialMessages) {
-            const role = msg.role || "user";
-            const content = msg.content;
-            // Start role section
-            combinedBlocks.push({
-                type: "text",
-                text: `<${role}-message>`,
-            });
-            if (Array.isArray(content)) {
-                for (const item of content) {
-                    if (!item || typeof item !== "object")
-                        continue;
-                    if (item.type === "text" && typeof item.text === "string") {
-                        combinedBlocks.push({ type: "text", text: item.text });
-                    }
-                    else if (item.type === "image" || item.type === "document") {
-                        combinedBlocks.push(item);
-                    }
-                }
-            }
-            else {
-                combinedBlocks.push({
-                    type: "text",
-                    text: this.normalizeToText(content),
-                });
-            }
-            // Close role section
-            combinedBlocks.push({
-                type: "text",
-                text: `</${role}-message>`,
-            });
-        }
-        const input = await this.normalizeToInput(combinedBlocks, context, true);
-        if (isDebugEnabledFor("manager") || isDebugEnabledFor("sdk")) {
-            console.log("[CodexManager] buildInitialInput multimodal payload", {
-                conversationId: context.conversationId,
-                blocks: combinedBlocks.map((b) => b.type),
-                inputType: Array.isArray(input) ? "array" : "string",
-                textItems: Array.isArray(input)
-                    ? input.filter((i) => i.type === "text").length
-                    : 1,
-                imageItems: Array.isArray(input)
-                    ? input.filter((i) => i.type === "local_image").length
-                    : 0,
-            });
-        }
-        return input;
-    }
-    launchTurn(context, prompt) {
-        const state = this.threadStates.get(context.conversationId);
-        if (!state || !state.thread) {
-            throw new Error(`Thread state missing for conversation ${context.conversationId}`);
-        }
-        const abortController = new AbortController();
-        state.abortController = abortController;
-        context.lastActivityAt = new Date();
-        const runPromise = this.streamThreadEvents(context, state.thread, prompt, abortController);
-        state.runPromise = runPromise;
-        runPromise
-            .catch((error) => {
-            if (!this.isAbortError(error)) {
-                console.error(`[CodexManager] Run failed for ${context.conversationId}:`, error);
-                this._handleConversationError(context, error);
-            }
-        })
-            .finally(() => {
-            if (state.runPromise === runPromise) {
-                state.runPromise = null;
-            }
-            if (state.abortController === abortController) {
-                state.abortController = null;
-            }
-        });
-    }
-    async streamThreadEvents(context, thread, prompt, abortController) {
-        try {
-            const { events } = await thread.runStreamed(prompt, {
-                signal: abortController.signal,
-            });
-            for await (const event of events) {
-                await this.handleThreadEvent(context, event);
-            }
-        }
-        catch (error) {
-            if (this.isAbortError(error)) {
-                console.log(`[CodexManager] Turn aborted for ${context.conversationId}`);
-                return;
-            }
-            throw error;
-        }
-    }
-    async abortActiveRun(conversationId) {
-        const state = this.threadStates.get(conversationId);
-        if (!state || !state.runPromise)
-            return;
-        if (state.abortController) {
-            state.abortController.abort();
-        }
-        try {
-            await state.runPromise;
-        }
-        catch (error) {
-            if (!this.isAbortError(error)) {
-                console.warn(`[CodexManager] Run aborted with error for ${conversationId}:`, error);
-            }
-        }
-    }
-    async handleThreadEvent(context, event) {
-        try {
-            this.logRawThreadEvent(event);
-            switch (event.type) {
-                case "thread.started": {
-                    await this.handleThreadStarted(context, event.thread_id);
-                    break;
-                }
-                case "turn.started": {
-                    context.status = "active";
-                    await this.sendAgentMessage(context, "system", {
-                        subtype: "turn.started",
-                        content: [
-                            {
-                                type: "text",
-                                text: `Turn started at ${new Date().toISOString()}`,
-                            },
-                        ],
-                    });
-                    break;
-                }
-                case "turn.completed": {
-                    await this.sendAgentMessage(context, "result", {
-                        subtype: "turn.completed",
-                        content: [
-                            {
-                                type: "usage",
-                                usage: event.usage,
-                            },
-                        ],
-                    });
-                    context.status = "stopped";
-                    await this._handleRunCompletion(context, false);
-                    break;
-                }
-                case "turn.failed": {
-                    const error = new Error(event.error?.message || "Turn failed");
-                    await this.sendAgentMessage(context, "error", {
-                        subtype: "turn.failed",
-                        content: [
-                            {
-                                type: "text",
-                                text: error.message,
-                            },
-                        ],
-                        isError: true,
-                    });
-                    await this._handleConversationError(context, error);
-                    context.status = "stopped";
-                    await this._finalizeConversation(context, true, error, "turn_failed");
-                    break;
-                }
-                case "item.started":
-                case "item.updated":
-                case "item.completed": {
-                    await this.forwardItemEvent(context, event.item, event.type.split(".")[1]);
-                    break;
-                }
-                case "error": {
-                    const fatalError = new Error(event.message || "Unknown error");
-                    await this.sendAgentMessage(context, "error", {
-                        subtype: "thread.error",
-                        content: [{ type: "text", text: fatalError.message }],
-                        isError: true,
-                    });
-                    await this._handleConversationError(context, fatalError);
-                    context.status = "stopped";
-                    await this._finalizeConversation(context, true, fatalError, "thread_error");
-                    break;
-                }
-            }
-        }
-        catch (error) {
-            console.error("[CodexManager] Failed to handle thread event", {
-                event,
-                error,
-            });
-        }
-    }
-    async forwardItemEvent(context, item, phase) {
-        const normalized = this.normalizeItemEvent(context, item, phase);
-        if (!normalized)
-            return;
-        const { subtype, content, isError, toolCalls, type } = normalized;
-        const payload = {
-            subtype,
-            content,
-            isError,
-        };
-        if (toolCalls) {
-            payload.toolCalls = toolCalls;
-        }
-        await this.sendAgentMessage(context, type, payload);
-    }
-    normalizeItemEvent(context, item, phase) {
-        switch (item.type) {
-            case "agent_message": {
-                if (phase !== "completed")
-                    return null;
-                return {
-                    type: "assistant",
-                    content: [
-                        {
-                            type: "text",
-                            text: item.text || "",
-                        },
-                    ],
-                };
-            }
-            case "reasoning": {
-                return {
-                    type: "thinking",
-                    content: [
-                        {
-                            type: "thinking",
-                            thinking: item.text,
-                            text: item.text,
-                            phase,
-                        },
-                    ],
-                };
-            }
-            case "command_execution": {
-                // Namespace command_execution tool use IDs so they don't collide
-                // with MCP tool call IDs that may reuse the same raw item.id.
-                const internalNamespace = "codex_command";
-                const toolUseId = this.buildToolUseId(context, `${internalNamespace}:${item.id}`);
-                const timestamp = new Date().toISOString();
-                const isTerminal = phase === "completed" ||
-                    item.status === "completed" ||
-                    item.status === "failed";
-                if (!isTerminal) {
-                    if (phase !== "started") {
-                        return null;
-                    }
-                    return {
-                        type: "assistant",
-                        subtype: "tool_use",
-                        content: [
-                            {
-                                toolCalls: [
-                                    {
-                                        id: toolUseId,
-                                        name: "codex_command",
-                                        arguments: {
-                                            command: item.command,
-                                            status: item.status,
-                                        },
-                                        status: item.status,
-                                    },
-                                ],
-                                timestamp,
-                            },
-                        ],
-                    };
-                }
-                const exitCode = typeof item.exit_code === "number" ? item.exit_code : null;
-                const isError = item.status === "failed" || (exitCode ?? 0) !== 0;
-                return {
-                    type: "tool_result",
-                    subtype: "tool_result",
-                    content: [
-                        {
-                            type: "tool_result",
-                            tool_use_id: toolUseId,
-                            content: {
-                                kind: "codex_command_result",
-                                command: item.command,
-                                output: item.aggregated_output || "",
-                                exitCode,
-                                status: item.status,
-                            },
-                            timestamp,
-                        },
-                    ],
-                    isError,
-                };
-            }
-            case "file_change": {
-                if (phase === "updated")
-                    return null;
-                return {
-                    type: "file_change",
-                    subtype: "file_change",
-                    content: [
-                        {
-                            type: "file_change",
-                            changes: item.changes,
-                            status: item.status,
-                        },
-                    ],
-                };
-            }
-            case "mcp_tool_call": {
-                const toolName = this.buildMcpToolName(item.server, item.tool);
-                // Namespace MCP tool call IDs with the MCP tool name so they don't
-                // collide with internal tool IDs or MCP calls from other servers.
-                const namespacedRawId = `mcp:${toolName}:${item.id}`;
-                const toolUseId = this.buildToolUseId(context, namespacedRawId);
-                if (item.status === "in_progress" || phase !== "completed") {
-                    return {
-                        type: "assistant",
-                        subtype: "tool_use",
-                        content: [
-                            {
-                                toolCalls: [
-                                    {
-                                        id: toolUseId,
-                                        name: toolName,
-                                        arguments: item.arguments,
-                                        server: item.server,
-                                        tool: item.tool,
-                                        status: item.status,
-                                    },
-                                ],
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                    };
-                }
-                if (item.status === "failed") {
-                    return {
-                        type: "error",
-                        subtype: "tool_result",
-                        content: [
-                            {
-                                type: "text",
-                                text: item.error?.message || "Tool call failed",
-                                tool_use_id: toolUseId,
-                                tool_name: toolName,
-                                timestamp: new Date().toISOString(),
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                return {
-                    type: "tool_result",
-                    subtype: "tool_result",
-                    content: [
-                        {
-                            type: "tool_result",
-                            subtype: "tool_result",
-                            tool_use_id: toolUseId,
-                            content: item.result?.content || [],
-                            structured_content: item.result?.structured_content,
-                            metadata: {
-                                server: item.server,
-                                tool: item.tool,
-                                name: toolName,
-                                original_tool_use_id: item.id,
-                            },
-                            timestamp: new Date().toISOString(),
-                        },
-                    ],
-                };
-            }
-            case "web_search": {
-                return {
-                    type: "system",
-                    subtype: `web_search.${phase}`,
-                    content: [
-                        {
-                            type: "web_search",
-                            query: item.query,
-                            status: phase,
-                        },
-                    ],
-                };
-            }
-            case "todo_list": {
-                return {
-                    type: "system",
-                    subtype: "todo_list",
-                    content: [
-                        {
-                            type: "todo_list",
-                            items: item.items,
-                            phase,
-                        },
-                    ],
-                };
-            }
-            case "error": {
-                return {
-                    type: "error",
-                    subtype: `item.${phase}`,
-                    content: [
-                        {
-                            type: "text",
-                            text: item.message,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            default:
-                return null;
-        }
-    }
-    async sendAgentMessage(context, type, { subtype, content, toolCalls, isError, }) {
-        const normalizedContent = Array.isArray(content)
-            ? content
-            : content
-                ? [content]
-                : [];
-        const payload = {
-            taskId: context.taskId,
-            conversationId: context.conversationId,
-            conversationObjectType: context.conversationObjectType,
-            conversationObjectId: context.conversationObjectId,
-            agentSessionId: context.agentSessionId,
-            type,
-            subtype,
-            content: normalizedContent,
-            toolCalls,
-            isError: Boolean(isError),
-            messageId: this.generateMessageId(context),
-            timestamp: new Date().toISOString(),
-        };
-        if (isDebugEnabledFor("manager")) {
-            console.log("[CodexManager] Sending message.agent", payload);
-        }
-        await this.runner.notify("message.agent", payload);
-    }
-    async handleThreadStarted(context, threadId) {
-        if (!threadId || threadId === context.agentSessionId) {
-            return;
-        }
-        const oldSessionId = context.agentSessionId;
-        context.agentSessionId = threadId;
-        await this.runner.notify("agentSessionId.changed", {
-            conversationId: context.conversationId,
-            conversationObjectType: context.conversationObjectType,
-            conversationObjectId: context.conversationObjectId,
-            oldAgentSessionId: oldSessionId,
-            newAgentSessionId: threadId,
-        });
-    }
-    mapSandboxMode(permissionsMode) {
-        const mode = (permissionsMode || "").toLowerCase();
-        if (mode === "read" || mode === "read_only") {
-            return "read-only";
-        }
-        // "project" mode allows bash but no file writes - Codex doesn't have fine-grained control,
-        // so we use workspace-write which allows both bash and file writes
-        if (mode === "project" || mode === "workspace" || mode === "workspace-write") {
-            return "workspace-write";
-        }
-        return "danger-full-access";
-    }
-    shouldEnableNetwork(permissionsMode) {
-        const mode = (permissionsMode || "").toLowerCase();
-        // project mode allows network (for fetching dependencies, running tests, etc.)
-        if (mode === "project")
-            return true;
-        return mode !== "read" && mode !== "read_only";
-    }
-    getAdditionalDirectories(config) {
-        const additionalDirs = [];
-        if (config.runnerRepoPath) {
-            additionalDirs.push(config.runnerRepoPath);
-        }
-        return additionalDirs.length ? additionalDirs : undefined;
-    }
-    buildConfigOverridesFromMcp(mcpServers) {
-        if (!mcpServers)
-            return undefined;
-        const overrides = {};
-        for (const [serverName, config] of Object.entries(mcpServers)) {
-            this.flattenOverrideObject(`mcp_servers.${serverName}`, config, overrides);
-        }
-        return Object.keys(overrides).length ? overrides : undefined;
-    }
-    /**
-     * Build Codex config overrides for OpenRouter provider.
-     * These correspond to the Codex CLI flags:
-     *   -c model_provider=openrouter
-     *   -c model_providers.openrouter.name=openrouter
-     *   -c model_providers.openrouter.base_url=https://openrouter.ai/api/v1
-     *   -c model_providers.openrouter.env_key=OPENROUTER_API_KEY
-     */
-    buildOpenRouterConfigOverrides() {
-        return {
-            model_provider: "openrouter",
-            "model_providers.openrouter.name": "openrouter",
-            "model_providers.openrouter.base_url": "https://openrouter.ai/api/v1",
-            "model_providers.openrouter.env_key": "OPENROUTER_API_KEY",
-        };
-    }
-    normalizeMcpServersForCodex(mcpServers) {
-        const normalized = {};
-        for (const [serverName, config] of Object.entries(mcpServers)) {
-            normalized[serverName] = this.stripAuthorizationHeader(config);
-        }
-        return normalized;
-    }
-    buildMcpToolName(server, tool) {
-        const safeServer = (server || "unknown").trim() || "unknown";
-        const safeTool = (tool || "unknown").trim() || "unknown";
-        return `mcp__${safeServer}__${safeTool}`;
-    }
-    logRawThreadEvent(event) {
-        if (!isDebugEnabledFor("sdk")) {
-            return;
-        }
-        try {
-            console.log("[CodexManager] RAW Codex event FULL:", this.safeStringify(event));
-            const summary = {
-                type: event?.type,
-                keys: Object.keys(event || {}),
-                hasItem: Boolean(event?.item),
-                itemType: event?.item?.type,
-                hasUsage: Boolean(event?.usage),
-                threadId: event?.thread_id,
-                turnId: event?.turn_id,
-            };
-            console.log("[CodexManager] RAW Codex event summary:", summary);
-            if (event?.item) {
-                console.log("[CodexManager] RAW Codex event item:", this.safeStringify(event.item));
-            }
-            if (event?.usage) {
-                console.log("[CodexManager] RAW Codex usage:", event.usage);
-            }
-        }
-        catch (error) {
-            console.warn("[CodexManager] Failed to log raw Codex event:", error);
-        }
-    }
-    safeStringify(value) {
-        const seen = new WeakSet();
-        return JSON.stringify(value, (key, nested) => {
-            if (typeof nested === "function")
-                return undefined;
-            if (typeof nested === "bigint")
-                return nested.toString();
-            if (typeof nested === "object" && nested !== null) {
-                if (seen.has(nested))
-                    return "[Circular]";
-                seen.add(nested);
-            }
-            return nested;
-        }, 2);
-    }
-    buildToolUseId(context, rawId) {
-        const scope = context.agentSessionId ||
-            context.conversationId ||
-            context.conversationObjectId ||
-            "codex";
-        return `${scope}:${rawId}`;
-    }
-    stripAuthorizationHeader(config) {
-        if (!config || typeof config !== "object" || Array.isArray(config)) {
-            return config;
-        }
-        const normalized = { ...config };
-        if (normalized.bearer_token_env_var &&
-            normalized.headers &&
-            typeof normalized.headers === "object" &&
-            !Array.isArray(normalized.headers)) {
-            const headers = { ...normalized.headers };
-            delete headers["Authorization"];
-            if (Object.keys(headers).length === 0) {
-                delete normalized.headers;
-            }
-            else {
-                normalized.headers = headers;
-            }
-        }
-        return normalized;
-    }
-    flattenOverrideObject(prefix, value, target) {
-        if (value === undefined) {
-            return;
-        }
-        if (value === null || typeof value !== "object" || Array.isArray(value)) {
-            target[prefix] = value;
-            return;
-        }
-        const entries = Object.entries(value);
-        if (!entries.length) {
-            target[prefix] = {};
-            return;
-        }
-        for (const [key, nested] of entries) {
-            this.flattenOverrideObject(`${prefix}.${key}`, nested, target);
-        }
-    }
-    async resolveWorkspacePath(context, config) {
-        let workspacePath;
-        const workspaceId = config.workspaceId;
-        const useWorktrees = config.useWorktrees !== false;
-        if (config.runnerRepoPath) {
-            workspacePath = config.runnerRepoPath;
-            console.log(`[CodexManager] Using local workspace path ${workspacePath}`);
-            if (context.conversationObjectType === "Task" && workspaceId) {
-                const hasGitDir = await fs
-                    .access(path.join(workspacePath, ".git"))
-                    .then(() => true)
-                    .catch(() => false);
-                if (hasGitDir && useWorktrees) {
-                    const repoUrl = config.repository?.url || `file://${workspacePath}`;
-                    const baseBranch = config.repository?.branch || "main";
-                    const taskHandle = await this.repositoryManager.createTaskWorktree(context.conversationObjectId, workspaceId, repoUrl, baseBranch, config.githubToken);
-                    context.taskHandle = taskHandle;
-                    workspacePath = taskHandle.worktreePath;
-                }
-            }
-            return workspacePath;
-        }
-        if (context.conversationObjectType === "Task" &&
-            config.repository &&
-            workspaceId &&
-            useWorktrees) {
-            if (!config.repository.url) {
-                throw new Error("Repository URL is required for task conversations");
-            }
-            const taskHandle = await this.repositoryManager.createTaskWorktree(context.conversationObjectId, workspaceId, config.repository.url, config.repository.branch, config.githubToken);
-            context.taskHandle = taskHandle;
-            workspacePath = taskHandle.worktreePath;
-            return workspacePath;
-        }
-        if (config.repository && workspaceId) {
-            if (config.repository.type === "local" && config.repository.localPath) {
-                workspacePath = config.repository.localPath;
-                return workspacePath;
-            }
-            workspacePath = await this.repositoryManager.checkoutRepository(workspaceId, config.repository.url, config.repository.branch, config.githubToken);
-            return workspacePath;
-        }
-        if (workspaceId) {
-            workspacePath =
-                await this.repositoryManager.getWorkspacePath(workspaceId);
-            return workspacePath;
-        }
-        return process.cwd();
-    }
-    async fetchGithubTokens(workspaceId) {
-        try {
-            const response = await fetch(`${this.runner.config_.orchestratorUrl}/api/runner/tokens?workspaceId=${workspaceId}`, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${process.env["NORTHFLARE_RUNNER_TOKEN"]}`,
-                },
-            });
-            if (!response.ok) {
-                console.error(`[CodexManager] Failed to fetch GitHub tokens: ${response.status}`);
-                return undefined;
-            }
-            const data = (await response.json());
-            return data.githubToken;
-        }
-        catch (error) {
-            console.error("[CodexManager] Error fetching GitHub tokens", error);
-            return undefined;
-        }
-    }
-    generateToolToken(context) {
-        if (!context.config.mcpServers)
-            return undefined;
-        const runnerToken = process.env["NORTHFLARE_RUNNER_TOKEN"];
-        const runnerUid = this.runner.getRunnerUid();
-        if (!runnerToken || !runnerUid)
-            return undefined;
-        return jwt.sign({
-            conversationId: context.conversationId,
-            runnerUid,
-        }, runnerToken, {
-            expiresIn: "60m",
-        });
-    }
-    /**
-     * Detect whether incoming content contains multimodal blocks (image/document).
-     */
-    hasMultimodalContent(value) {
-        if (!Array.isArray(value))
-            return false;
-        return value.some((item) => item &&
-            typeof item === "object" &&
-            (item.type === "image" || item.type === "document"));
-    }
-    /**
-     * Normalize incoming content into the Codex SDK Input shape.
-     * - Text-only -> single string (lets SDK do fast path)
-     * - Multimodal -> [{ text }, ...{ local_image }]
-     */
-    async normalizeToInput(value, context, forceInstructions) {
-        if (Array.isArray(value) && this.hasMultimodalContent(value)) {
-            const inputs = [];
-            // Collect any text blocks (or document placeholders) to keep context
-            const textChunks = [];
-            for (const item of value) {
-                if (!item || typeof item !== "object")
-                    continue;
-                if (item.type === "text" && typeof item.text === "string") {
-                    textChunks.push(item.text);
-                }
-                else if (item.type === "document" && item.source) {
-                    const docUrl = item.source.type === "url" ? item.source.url : item.source.data;
-                    if (docUrl) {
-                        textChunks.push(`[Document: ${docUrl}]`);
-                    }
-                }
-            }
-            const textPart = this.buildPromptForMessage(context, textChunks.join(" ").trim(), forceInstructions);
-            if (textPart) {
-                inputs.push({ type: "text", text: textPart });
-            }
-            // Download image blocks to temp files and attach as local_image
-            const imagePaths = [];
-            for (const item of value) {
-                if (!item || typeof item !== "object" || item.type !== "image" || !item.source) {
-                    continue;
-                }
-                const imageUrl = item.source.type === "url" ? item.source.url : item.source.data;
-                if (!imageUrl)
-                    continue;
-                const localPath = await this.downloadImageToTemp(imageUrl);
-                inputs.push({ type: "local_image", path: localPath });
-                imagePaths.push(localPath);
-            }
-            // If no text and instructions were never injected, inject an empty prompt to carry instructions
-            if (!inputs.some((i) => i.type === "text")) {
-                const instructionOnly = this.buildPromptForMessage(context, "", forceInstructions);
-                if (instructionOnly) {
-                    inputs.unshift({ type: "text", text: instructionOnly });
-                }
-            }
-            if (isDebugEnabledFor("manager") || isDebugEnabledFor("sdk")) {
-                console.log("[CodexManager] normalizeToInput multimodal", {
-                    conversationId: context.conversationId,
-                    imageCount: imagePaths.length,
-                    imagePaths,
-                    textIncluded: inputs.some((i) => i.type === "text"),
-                });
-            }
-            return inputs;
-        }
-        // Fallback to text-only path
-        const messageText = this.normalizeToText(value);
-        return this.buildPromptForMessage(context, messageText, forceInstructions);
-    }
-    /**
-     * Download an image (http(s) or data URL) to a temp file and return the path.
-     */
-    async downloadImageToTemp(url) {
-        // Allow local filesystem paths to be passed through unchanged
-        if (url.startsWith("/") || url.startsWith("./") || url.startsWith("../")) {
-            return path.isAbsolute(url) ? url : path.resolve(url);
-        }
-        // Handle data URLs (e.g., data:image/png;base64,...)
-        if (url.startsWith("data:")) {
-            const commaIdx = url.indexOf(",");
-            if (commaIdx === -1) {
-                throw new Error("Invalid data URL for image");
-            }
-            const header = url.slice(5, commaIdx); // remove "data:"
-            const dataPart = url.slice(commaIdx + 1);
-            const isBase64 = header.endsWith(";base64");
-            const mime = header.replace(";base64", "");
-            const ext = this.mimeToExtension(mime) || "png";
-            const buffer = isBase64
-                ? Buffer.from(dataPart, "base64")
-                : Buffer.from(decodeURIComponent(dataPart), "utf-8");
-            return await this.writeBufferToTemp(buffer, ext);
-        }
-        // Standard remote URL
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to download image (${response.status}) from ${url}`);
-        }
-        const arrayBuffer = await response.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        const ext = this.inferExtensionFromUrl(url) || "png";
-        return await this.writeBufferToTemp(buffer, ext);
-    }
-    async writeBufferToTemp(buffer, ext) {
-        const dir = path.join(tmpdir(), "codex-images");
-        await fs.mkdir(dir, { recursive: true });
-        const filename = `${crypto.randomUUID()}.${ext}`;
-        const fullPath = path.join(dir, filename);
-        await fs.writeFile(fullPath, buffer);
-        return fullPath;
-    }
-    inferExtensionFromUrl(url) {
-        try {
-            const parsed = new URL(url);
-            const pathname = parsed.pathname;
-            const ext = path.extname(pathname);
-            if (ext) {
-                return ext.replace(".", "").split(/[?#]/)[0] || null;
-            }
-        }
-        catch {
-            // Not a valid URL; fall through
-        }
-        return null;
-    }
-    mimeToExtension(mime) {
-        if (!mime)
-            return null;
-        const map = {
-            "image/png": "png",
-            "image/jpeg": "jpg",
-            "image/jpg": "jpg",
-            "image/webp": "webp",
-            "image/gif": "gif",
-        };
-        return map[mime] || null;
-    }
-    normalizeToText(value) {
-        if (typeof value === "string")
-            return value;
-        if (value == null)
-            return "";
-        if (typeof value === "object") {
-            if (typeof value.text === "string") {
-                return value.text;
-            }
-            if (Array.isArray(value)) {
-                const texts = value
-                    .map((entry) => {
-                    if (entry &&
-                        typeof entry === "object" &&
-                        typeof entry.text === "string") {
-                        return entry.text;
-                    }
-                    return null;
-                })
-                    .filter((entry) => Boolean(entry));
-                if (texts.length) {
-                    return texts.join(" ");
-                }
-            }
-            if (typeof value.content === "string") {
-                return value.content;
-            }
-        }
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return String(value);
-        }
-    }
-    normalizeSessionId(value) {
-        if (!value)
-            return undefined;
-        const trimmed = value.trim();
-        return trimmed.length ? trimmed : undefined;
-    }
-    resolveSessionId(config, conversationData, override) {
-        return (this.normalizeSessionId(override) ||
-            this.normalizeSessionId(config?.sessionId) ||
-            this.normalizeSessionId(conversationData?.agentSessionId) ||
-            this.normalizeSessionId(conversationData?.threadId) ||
-            this.normalizeSessionId(conversationData?.sessionId) ||
-            "");
-    }
-    isAbortError(error) {
-        if (!error)
-            return false;
-        return (error.name === "AbortError" ||
-            /aborted|abort/i.test(error.message || ""));
-    }
-    async _finalizeConversation(context, hadError, error, reason) {
-        // Synchronous idempotency check - must happen before any async operations
-        if (context._finalized)
-            return;
-        context._finalized = true;
-        // Mark as completed immediately to prevent restart on catch-up
-        // This is synchronous and happens before any async operations
-        this.runner.markConversationCompleted(context.conversationId);
-        // Clean up local state synchronously
-        this.threadStates.delete(context.conversationId);
-        this.runner.activeConversations_.delete(context.conversationId);
-        statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        // Now do async notification (after all sync cleanup)
-        try {
-            await this.runner.notify("conversation.end", {
-                conversationId: context.conversationId,
-                conversationObjectType: context.conversationObjectType,
-                conversationObjectId: context.conversationObjectId,
-                agentSessionId: context.agentSessionId,
-                isError: hadError,
-                errorMessage: error?.message,
-                reason,
-            });
-        }
-        catch (notifyError) {
-            console.error("[CodexManager] Failed to send conversation.end notification", notifyError);
-        }
-        // Notify update coordinator that a conversation has ended
-        // This may trigger an auto-update if one is pending and runner is now idle
-        try {
-            await this.runner.onConversationEnd();
-        }
-        catch (e) {
-            console.error("[CodexManager] Failed to notify onConversationEnd:", e);
-        }
-    }
-    async _handleConversationError(context, error) {
-        console.error(`[CodexManager] Conversation error for ${context.conversationId}:`, error);
-        await this.runner.notify("error.report", {
-            conversationId: context.conversationId,
-            conversationObjectType: context.conversationObjectType,
-            conversationObjectId: context.conversationObjectId,
-            agentSessionId: context.agentSessionId,
-            errorType: "codex_error",
-            message: error.message,
-            details: {
-                stack: error.stack,
-                timestamp: new Date(),
-            },
-        });
-    }
-    generateMessageId(context) {
-        return `${context.agentSessionId}-${Date.now()}-${Math.random()
-            .toString(36)
-            .slice(2)}`;
-    }
-}
-//# sourceMappingURL=codex-sdk-manager.js.map