@ccpocket-base-auth/bridge 1.26.0

package/dist/codex-process.js

@@ -0,0 +1,1928 @@
+import { EventEmitter } from "node:events";
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { rm, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+export class CodexProcess extends EventEmitter {
+    child = null;
+    _status = "starting";
+    _threadId = null;
+    _agentNickname = null;
+    _agentRole = null;
+    stopped = false;
+    startModel;
+    inputResolve = null;
+    pendingTurnId = null;
+    pendingTurnCompletion = null;
+    pendingApprovals = new Map();
+    pendingUserInputs = new Map();
+    lastTokenUsage = null;
+    /** Full skill metadata from the last `skills/list` response. */
+    _skills = [];
+    /** Project path stored for re-fetching skills on `skills/changed`. */
+    _projectPath = null;
+    /** Expose skill metadata so session/websocket can access it. */
+    get skills() {
+        return this._skills;
+    }
+    rpcSeq = 1;
+    pendingRpc = new Map();
+    stdoutBuffer = "";
+    // Collaboration mode & plan completion state
+    _approvalPolicy = "never";
+    _collaborationMode = "default";
+    lastPlanItemText = null;
+    pendingPlanCompletion = null;
+    /** Queued plan execution text when inputResolve wasn't ready at approval time. */
+    _pendingPlanInput = null;
+    get status() {
+        return this._status;
+    }
+    get isWaitingForInput() {
+        return this.inputResolve !== null;
+    }
+    get sessionId() {
+        return this._threadId;
+    }
+    get agentNickname() {
+        return this._agentNickname;
+    }
+    get agentRole() {
+        return this._agentRole;
+    }
+    get isRunning() {
+        return this.child !== null;
+    }
+    get approvalPolicy() {
+        return this._approvalPolicy;
+    }
+    /**
+     * Update approval policy at runtime.
+     * Takes effect on the next `turn/start` RPC call.
+     */
+    setApprovalPolicy(policy) {
+        this._approvalPolicy = policy;
+        console.log(`[codex-process] Approval policy changed to: ${policy}`);
+    }
+    /**
+     * Set collaboration mode ("plan" or "default").
+     * Takes effect on the next `turn/start` RPC call.
+     */
+    setCollaborationMode(mode) {
+        this._collaborationMode = mode;
+        console.log(`[codex-process] Collaboration mode changed to: ${mode}`);
+    }
+    get collaborationMode() {
+        return this._collaborationMode;
+    }
+    /**
+     * Rename a thread via the app-server RPC.
+     * Sends thread/name/set which persists to ~/.codex/session_index.jsonl.
+     */
+    async renameThread(name) {
+        if (!this._threadId) {
+            throw new Error("No thread ID available for rename");
+        }
+        await this.request("thread/name/set", {
+            threadId: this._threadId,
+            name,
+        });
+    }
+    /**
+     * Archive a Codex thread via the app-server `thread/archive` RPC.
+     * Accepts an explicit threadId so that historical (non-active) sessions
+     * can be archived without requiring a running process.
+     */
+    async archiveThread(threadId) {
+        await this.request("thread/archive", { threadId });
+    }
+    async listThreads(params = {}) {
+        const result = await this.request("thread/list", {
+            sortKey: "updated_at",
+            archived: false,
+            ...(params.limit != null ? { limit: params.limit } : {}),
+            ...(params.cursor !== undefined ? { cursor: params.cursor } : {}),
+            ...(params.cwd ? { cwd: params.cwd } : {}),
+            ...(params.searchTerm ? { searchTerm: params.searchTerm } : {}),
+        });
+        const data = Array.isArray(result.data)
+            ? result.data.map((entry) => toCodexThreadSummary(entry))
+            : [];
+        return {
+            data,
+            nextCursor: typeof result.nextCursor === "string" ? result.nextCursor : null,
+        };
+    }
+    start(projectPath, options) {
+        if (this.child) {
+            this.stop();
+        }
+        this.prepareLaunch(projectPath, options);
+        this.launchAppServer(projectPath, options);
+        void this.bootstrap(projectPath, options);
+    }
+    async initializeOnly(projectPath) {
+        if (this.child) {
+            this.stop();
+        }
+        this.prepareLaunch(projectPath);
+        this.launchAppServer(projectPath);
+        await this.initializeRpcConnection();
+        this.setStatus("idle");
+    }
+    stop() {
+        this.stopped = true;
+        if (this.inputResolve) {
+            this.inputResolve({ text: "" });
+            this.inputResolve = null;
+        }
+        this.pendingApprovals.clear();
+        this.pendingUserInputs.clear();
+        this.rejectAllPending(new Error("stopped"));
+        if (this.child) {
+            this.child.kill("SIGTERM");
+            this.child = null;
+        }
+        this.setStatus("idle");
+        console.log("[codex-process] Stopped");
+    }
+    prepareLaunch(projectPath, options) {
+        this.stopped = false;
+        this._threadId = null;
+        this._agentNickname = null;
+        this._agentRole = null;
+        this.pendingTurnId = null;
+        this.pendingTurnCompletion = null;
+        this.pendingApprovals.clear();
+        this.pendingUserInputs.clear();
+        this.lastTokenUsage = null;
+        this.startModel = options?.model;
+        this._approvalPolicy = options?.approvalPolicy ?? "never";
+        this._collaborationMode = options?.collaborationMode ?? "default";
+        this.lastPlanItemText = null;
+        this.pendingPlanCompletion = null;
+        this._pendingPlanInput = null;
+        this._projectPath = projectPath;
+    }
+    launchAppServer(projectPath, options) {
+        console.log(`[codex-process] Starting app-server (cwd: ${projectPath}, sandbox: ${options?.sandboxMode ?? "workspace-write"}, approval: ${options?.approvalPolicy ?? "never"}, model: ${options?.model ?? "default"}, collaboration: ${this._collaborationMode})`);
+        const child = spawn("codex", ["app-server", "--listen", "stdio://"], {
+            cwd: projectPath,
+            stdio: "pipe",
+            env: process.env,
+        });
+        this.child = child;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            this.handleStdoutChunk(chunk);
+        });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            const line = chunk.trim();
+            if (line) {
+                console.log(`[codex-process] stderr: ${line}`);
+            }
+        });
+        child.on("error", (err) => {
+            if (this.stopped)
+                return;
+            console.error("[codex-process] app-server process error:", err);
+            this.emitMessage({ type: "error", message: `Failed to start codex app-server: ${err.message}` });
+            this.setStatus("idle");
+            this.emit("exit", 1);
+        });
+        child.on("exit", (code) => {
+            const exitCode = code ?? 0;
+            this.child = null;
+            this.rejectAllPending(new Error("codex app-server exited"));
+            if (!this.stopped && exitCode !== 0) {
+                this.emitMessage({ type: "error", message: `codex app-server exited with code ${exitCode}` });
+            }
+            this.setStatus("idle");
+            this.emit("exit", code);
+        });
+    }
+    interrupt() {
+        if (!this._threadId || !this.pendingTurnId)
+            return;
+        void this.request("turn/interrupt", {
+            threadId: this._threadId,
+            turnId: this.pendingTurnId,
+        }).catch((err) => {
+            if (!this.stopped) {
+                console.warn(`[codex-process] turn/interrupt failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
+    }
+    sendInput(text) {
+        if (!this.inputResolve) {
+            console.error("[codex-process] No pending input resolver for sendInput");
+            return;
+        }
+        const resolve = this.inputResolve;
+        this.inputResolve = null;
+        resolve({ text });
+    }
+    sendInputWithImages(text, images) {
+        if (!this.inputResolve) {
+            console.error("[codex-process] No pending input resolver for sendInputWithImages");
+            return;
+        }
+        const resolve = this.inputResolve;
+        this.inputResolve = null;
+        resolve({ text, images });
+    }
+    sendInputWithSkill(text, skill) {
+        if (!this.inputResolve) {
+            console.error("[codex-process] No pending input resolver for sendInputWithSkill");
+            return;
+        }
+        const resolve = this.inputResolve;
+        this.inputResolve = null;
+        resolve({ text, skill });
+    }
+    approve(toolUseId, _updatedInput) {
+        // Check if this is a plan completion approval
+        if (this.pendingPlanCompletion && toolUseId === this.pendingPlanCompletion.toolUseId) {
+            this.handlePlanApproved(_updatedInput);
+            return;
+        }
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] approve() called but no pending permission requests");
+            return;
+        }
+        this.pendingApprovals.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "accept"));
+        this.emitToolResult(pending.toolUseId, "Approved");
+        if (this.pendingApprovals.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    approveAlways(toolUseId) {
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] approveAlways() called but no pending permission requests");
+            return;
+        }
+        this.pendingApprovals.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "acceptForSession"));
+        this.emitToolResult(pending.toolUseId, "Approved (always)");
+        if (this.pendingApprovals.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    reject(toolUseId, _message) {
+        // Check if this is a plan completion rejection
+        if (this.pendingPlanCompletion && toolUseId === this.pendingPlanCompletion.toolUseId) {
+            this.handlePlanRejected(_message);
+            return;
+        }
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] reject() called but no pending permission requests");
+            return;
+        }
+        this.pendingApprovals.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "decline"));
+        this.emitToolResult(pending.toolUseId, "Rejected");
+        if (this.pendingApprovals.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    answer(toolUseId, result) {
+        const pending = this.resolvePendingUserInput(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] answer() called but no pending AskUserQuestion");
+            return;
+        }
+        this.pendingUserInputs.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
+        this.emitToolResult(pending.toolUseId, "Answered");
+        if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    getPendingPermission(toolUseId) {
+        // Check plan completion first
+        if (this.pendingPlanCompletion) {
+            if (!toolUseId || toolUseId === this.pendingPlanCompletion.toolUseId) {
+                return {
+                    toolUseId: this.pendingPlanCompletion.toolUseId,
+                    toolName: "ExitPlanMode",
+                    input: { plan: this.pendingPlanCompletion.planText },
+                };
+            }
+        }
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (pending) {
+            return {
+                toolUseId: pending.toolUseId,
+                toolName: pending.toolName,
+                input: { ...pending.input },
+            };
+        }
+        const pendingAsk = this.resolvePendingUserInput(toolUseId);
+        if (!pendingAsk)
+            return undefined;
+        return {
+            toolUseId: pendingAsk.toolUseId,
+            toolName: "AskUserQuestion",
+            input: { ...pendingAsk.input },
+        };
+    }
+    /** Emit a synthetic tool_result so history replay can match it to a permission_request. */
+    emitToolResult(toolUseId, content) {
+        this.emitMessage({
+            type: "tool_result",
+            toolUseId,
+            content,
+        });
+    }
+    resolvePendingApproval(toolUseId) {
+        if (toolUseId)
+            return this.pendingApprovals.get(toolUseId);
+        const first = this.pendingApprovals.values().next();
+        return first.done ? undefined : first.value;
+    }
+    resolvePendingUserInput(toolUseId) {
+        if (toolUseId)
+            return this.pendingUserInputs.get(toolUseId);
+        const first = this.pendingUserInputs.values().next();
+        return first.done ? undefined : first.value;
+    }
+    // ---------------------------------------------------------------------------
+    // Plan completion handlers (native collaboration_mode)
+    // ---------------------------------------------------------------------------
+    /**
+     * Plan approved → switch to Default mode and auto-start execution.
+     */
+    handlePlanApproved(updatedInput) {
+        const planText = updatedInput?.plan ?? this.pendingPlanCompletion?.planText ?? "";
+        const resolvedToolUseId = this.pendingPlanCompletion?.toolUseId;
+        this.pendingPlanCompletion = null;
+        this._collaborationMode = "default";
+        console.log("[codex-process] Plan approved, switching to Default mode");
+        // Emit synthetic tool_result so history replay knows this approval is resolved
+        if (resolvedToolUseId) {
+            this.emitToolResult(resolvedToolUseId, "Plan approved");
+        }
+        // Resolve inputResolve to start the next turn (Default mode) automatically
+        if (this.inputResolve) {
+            const resolve = this.inputResolve;
+            this.inputResolve = null;
+            resolve({ text: `Execute the following plan:\n\n${planText}` });
+        }
+        else {
+            // inputResolve may not be ready yet if approval comes before the next
+            // input loop iteration.  Queue the text so sendInput() can pick it up.
+            console.warn("[codex-process] Plan approved but inputResolve not ready, queuing as pending input");
+            this._pendingPlanInput = `Execute the following plan:\n\n${planText}`;
+        }
+    }
+    /**
+     * Plan rejected → stay in Plan mode and re-plan with feedback.
+     */
+    handlePlanRejected(feedback) {
+        const resolvedToolUseId = this.pendingPlanCompletion?.toolUseId;
+        this.pendingPlanCompletion = null;
+        console.log("[codex-process] Plan rejected, continuing in Plan mode");
+        // Stay in Plan mode
+        // Emit synthetic tool_result so history replay knows this approval is resolved
+        if (resolvedToolUseId) {
+            this.emitToolResult(resolvedToolUseId, "Plan rejected");
+        }
+        if (feedback) {
+            if (this.inputResolve) {
+                const resolve = this.inputResolve;
+                this.inputResolve = null;
+                resolve({ text: feedback });
+            }
+            else {
+                console.warn("[codex-process] Plan rejected but inputResolve not ready, queuing feedback");
+                this._pendingPlanInput = feedback;
+            }
+        }
+        else {
+            this.setStatus("idle");
+        }
+    }
+    async bootstrap(projectPath, options) {
+        try {
+            await this.initializeRpcConnection();
+            const threadParams = {
+                cwd: projectPath,
+                approvalPolicy: normalizeApprovalPolicy(options?.approvalPolicy ?? "never"),
+                sandbox: normalizeSandboxMode(options?.sandboxMode ?? "workspace-write"),
+                experimentalRawEvents: false,
+                persistExtendedHistory: true,
+            };
+            if (options?.model)
+                threadParams.model = options.model;
+            if (options?.modelReasoningEffort) {
+                threadParams.effort = normalizeReasoningEffort(options.modelReasoningEffort);
+            }
+            if (options?.networkAccessEnabled !== undefined) {
+                threadParams.sandboxPolicy = {
+                    type: normalizeSandboxMode(options?.sandboxMode ?? "workspace-write"),
+                    networkAccess: options.networkAccessEnabled,
+                };
+            }
+            if (options?.webSearchMode) {
+                threadParams.webSearchMode = options.webSearchMode;
+            }
+            const method = options?.threadId ? "thread/resume" : "thread/start";
+            if (options?.threadId) {
+                threadParams.threadId = options.threadId;
+            }
+            else {
+                threadParams.experimentalRawEvents = false;
+            }
+            if (options?.threadId) {
+                threadParams.persistExtendedHistory = true;
+            }
+            const response = await this.request(method, threadParams);
+            const thread = response.thread;
+            const threadId = typeof thread?.id === "string"
+                ? thread.id
+                : options?.threadId;
+            if (!threadId) {
+                throw new Error(`${method} returned no thread id`);
+            }
+            // Capture the resolved model name from thread response
+            if (typeof thread?.model === "string" && thread.model) {
+                this.startModel = thread.model;
+            }
+            this._threadId = threadId;
+            this.emitMessage({
+                type: "system",
+                subtype: "init",
+                sessionId: threadId,
+                model: this.startModel ?? "codex",
+            });
+            this.setStatus("idle");
+            // Fetch skills in background (non-blocking)
+            this._projectPath = projectPath;
+            void this.fetchSkills(projectPath);
+            await this.runInputLoop(options);
+        }
+        catch (err) {
+            if (!this.stopped) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.error("[codex-process] bootstrap error:", err);
+                this.emitMessage({ type: "error", message: `Codex error: ${message}` });
+                this.emitMessage({ type: "result", subtype: "error", error: message, sessionId: this._threadId ?? undefined });
+            }
+            this.setStatus("idle");
+            this.emit("exit", 1);
+        }
+    }
+    async initializeRpcConnection() {
+        await this.request("initialize", {
+            clientInfo: {
+                name: "ccpocket_bridge",
+                version: "1.0.0",
+                title: "ccpocket bridge",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        this.notify("initialized", {});
+    }
+    /**
+     * Fetch skills from Codex app-server via `skills/list` RPC and emit them
+     * as a `supported_commands` system message so the Flutter client can display
+     * skill entries alongside built-in slash commands.
+     */
+    async fetchSkills(projectPath) {
+        const TIMEOUT_MS = 10_000;
+        try {
+            const result = await Promise.race([
+                this.request("skills/list", { cwds: [projectPath] }),
+                new Promise((resolve) => setTimeout(() => resolve(null), TIMEOUT_MS)),
+            ]);
+            if (this.stopped || !result?.data)
+                return;
+            const skills = [];
+            const slashCommands = [];
+            const skillMetadata = [];
+            for (const entry of result.data) {
+                for (const skill of entry.skills) {
+                    if (skill.enabled) {
+                        skills.push(skill.name);
+                        slashCommands.push(skill.name);
+                        skillMetadata.push({
+                            name: skill.name,
+                            path: skill.path,
+                            description: skill.description,
+                            shortDescription: skill.shortDescription ?? skill.interface?.shortDescription ?? undefined,
+                            enabled: skill.enabled,
+                            scope: skill.scope,
+                            displayName: skill.interface?.displayName ?? undefined,
+                            defaultPrompt: skill.interface?.defaultPrompt ?? undefined,
+                            brandColor: skill.interface?.brandColor ?? undefined,
+                        });
+                    }
+                }
+            }
+            this._skills = skillMetadata;
+            if (slashCommands.length > 0) {
+                console.log(`[codex-process] skills/list returned ${slashCommands.length} skills`);
+                this.emitMessage({
+                    type: "system",
+                    subtype: "supported_commands",
+                    slashCommands,
+                    skills,
+                    skillMetadata,
+                });
+            }
+        }
+        catch (err) {
+            console.log(`[codex-process] skills/list failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async runInputLoop(options) {
+        while (!this.stopped) {
+            const pendingInput = await new Promise((resolve) => {
+                this.inputResolve = resolve;
+                // If plan approval arrived before inputResolve was ready, drain it now.
+                if (this._pendingPlanInput) {
+                    const text = this._pendingPlanInput;
+                    this._pendingPlanInput = null;
+                    this.inputResolve = null;
+                    resolve({ text });
+                }
+            });
+            if (this.stopped || !pendingInput.text)
+                break;
+            if (!this._threadId) {
+                this.emitMessage({ type: "error", message: "Codex thread is not initialized" });
+                continue;
+            }
+            const { input, tempPaths } = await this.toRpcInput(pendingInput);
+            if (!input) {
+                continue;
+            }
+            this.setStatus("running");
+            this.lastTokenUsage = null;
+            const completion = await new Promise((resolve, reject) => {
+                this.pendingTurnCompletion = { resolve, reject };
+                const params = {
+                    threadId: this._threadId,
+                    input,
+                    approvalPolicy: normalizeApprovalPolicy(this._approvalPolicy),
+                };
+                if (options?.model)
+                    params.model = options.model;
+                if (options?.modelReasoningEffort) {
+                    params.effort = normalizeReasoningEffort(options.modelReasoningEffort);
+                }
+                // Always send collaborationMode so the server switches modes correctly.
+                // Omitting it causes the server to persist the previous turn's mode.
+                const modeSettings = {
+                    model: options?.model || this.startModel || "gpt-5.4",
+                };
+                if (this._collaborationMode === "plan") {
+                    modeSettings.reasoning_effort = "medium";
+                }
+                params.collaborationMode = {
+                    mode: this._collaborationMode,
+                    settings: modeSettings,
+                };
+                console.log(`[codex-process] turn/start: approval=${params.approvalPolicy}, collaboration=${this._collaborationMode}`);
+                void this.request("turn/start", params)
+                    .then((result) => {
+                    const turn = result.turn;
+                    if (typeof turn?.id === "string") {
+                        this.pendingTurnId = turn.id;
+                    }
+                })
+                    .catch((err) => {
+                    this.pendingTurnCompletion = null;
+                    reject(err instanceof Error ? err : new Error(String(err)));
+                });
+            }).catch((err) => {
+                if (!this.stopped) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    this.emitMessage({ type: "error", message });
+                    this.emitMessage({
+                        type: "result",
+                        subtype: "error",
+                        error: message,
+                        sessionId: this._threadId ?? undefined,
+                    });
+                    this.setStatus("idle");
+                }
+            });
+            await Promise.all(tempPaths.map((path) => rm(path, { force: true }).catch(() => { })));
+            void completion;
+        }
+    }
+    handleStdoutChunk(chunk) {
+        this.stdoutBuffer += chunk;
+        while (true) {
+            const newlineIndex = this.stdoutBuffer.indexOf("\n");
+            if (newlineIndex < 0)
+                break;
+            const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (!line)
+                continue;
+            try {
+                const envelope = JSON.parse(line);
+                this.handleRpcEnvelope(envelope);
+            }
+            catch (err) {
+                console.warn(`[codex-process] failed to parse app-server JSON line: ${line.slice(0, 200)}`);
+                if (!this.stopped) {
+                    this.emitMessage({
+                        type: "error",
+                        message: `Failed to parse codex app-server output: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                }
+            }
+        }
+    }
+    handleRpcEnvelope(envelope) {
+        if (envelope.id != null && envelope.method && envelope.result === undefined && envelope.error === undefined) {
+            this.handleServerRequest(envelope.id, envelope.method, envelope.params ?? {});
+            return;
+        }
+        if (envelope.id != null && (envelope.result !== undefined || envelope.error)) {
+            this.handleRpcResponse(envelope);
+            return;
+        }
+        if (envelope.method) {
+            this.handleNotification(envelope.method, envelope.params ?? {});
+        }
+    }
+    handleRpcResponse(envelope) {
+        if (typeof envelope.id !== "number") {
+            return;
+        }
+        const pending = this.pendingRpc.get(envelope.id);
+        if (!pending)
+            return;
+        this.pendingRpc.delete(envelope.id);
+        if ("error" in envelope && envelope.error) {
+            const message = envelope.error.message ?? `RPC error ${envelope.error.code ?? ""}`;
+            pending.reject(new Error(message));
+            return;
+        }
+        pending.resolve(envelope.result);
+    }
+    handleServerRequest(id, method, params) {
+        switch (method) {
+            case "item/commandExecution/requestApproval": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const input = {
+                    ...(typeof params.command === "string" ? { command: params.command } : {}),
+                    ...(typeof params.cwd === "string" ? { cwd: params.cwd } : {}),
+                    ...(params.commandActions ? { commandActions: params.commandActions } : {}),
+                    ...(params.networkApprovalContext ? { networkApprovalContext: params.networkApprovalContext } : {}),
+                    ...(params.additionalPermissions ? { additionalPermissions: params.additionalPermissions } : {}),
+                    ...(params.skillMetadata ? { skillMetadata: params.skillMetadata } : {}),
+                    ...(params.proposedExecpolicyAmendment ? { proposedExecpolicyAmendment: params.proposedExecpolicyAmendment } : {}),
+                    ...(params.proposedNetworkPolicyAmendments ? { proposedNetworkPolicyAmendments: params.proposedNetworkPolicyAmendments } : {}),
+                    ...(params.availableDecisions ? { availableDecisions: params.availableDecisions } : {}),
+                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                };
+                this.pendingApprovals.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "Bash",
+                    input,
+                    kind: "command",
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "Bash",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "item/fileChange/requestApproval": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const input = {
+                    ...(Array.isArray(params.changes) ? { changes: params.changes } : {}),
+                    ...(typeof params.grantRoot === "string" ? { grantRoot: params.grantRoot } : {}),
+                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                };
+                this.pendingApprovals.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "FileChange",
+                    input,
+                    kind: "file",
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "FileChange",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "item/tool/requestUserInput": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const questions = normalizeUserInputQuestions(params.questions);
+                const input = {
+                    questions: questions.map((q) => ({
+                        id: q.id,
+                        question: q.question,
+                        header: q.header,
+                        options: q.options,
+                        multiSelect: false,
+                        isOther: q.isOther,
+                        isSecret: q.isSecret,
+                    })),
+                };
+                this.pendingUserInputs.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "AskUserQuestion",
+                    questions: questions.map((q) => ({
+                        id: q.id,
+                        question: q.question,
+                    })),
+                    input,
+                    kind: "questions",
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "AskUserQuestion",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "item/permissions/requestApproval": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const requestedPermissions = asRecord(params.permissions) ?? {};
+                const input = {
+                    permissions: requestedPermissions,
+                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                };
+                this.pendingApprovals.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "Permissions",
+                    input,
+                    kind: "permissions",
+                    requestedPermissions,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "Permissions",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "mcpServer/elicitation/request": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const elicitation = createElicitationInput(params);
+                this.pendingUserInputs.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "McpElicitation",
+                    questions: elicitation.questions,
+                    input: elicitation.input,
+                    kind: elicitation.kind,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "McpElicitation",
+                    input: elicitation.input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            default:
+                this.respondToServerRequest(id, {});
+                break;
+        }
+    }
+    handleNotification(method, params) {
+        switch (method) {
+            case "thread/started": {
+                const thread = params.thread;
+                if (typeof thread?.id === "string") {
+                    this._threadId = thread.id;
+                }
+                this._agentNickname = stringOrNull(thread?.agentNickname);
+                this._agentRole = stringOrNull(thread?.agentRole);
+                break;
+            }
+            case "turn/started": {
+                const turn = params.turn;
+                if (typeof turn?.id === "string") {
+                    this.pendingTurnId = turn.id;
+                }
+                this.setStatus("running");
+                break;
+            }
+            case "turn/completed": {
+                this.handleTurnCompleted(params.turn);
+                break;
+            }
+            case "thread/name/updated": {
+                // Name change notification — handled by session manager
+                break;
+            }
+            case "thread/tokenUsage/updated": {
+                const usage = params.usage;
+                if (usage) {
+                    this.lastTokenUsage = {
+                        input: numberOrUndefined(usage.inputTokens ?? usage.input_tokens),
+                        cachedInput: numberOrUndefined(usage.cachedInputTokens ?? usage.cached_input_tokens),
+                        output: numberOrUndefined(usage.outputTokens ?? usage.output_tokens),
+                    };
+                }
+                break;
+            }
+            case "item/started": {
+                this.processItemStarted(params.item);
+                break;
+            }
+            case "item/completed": {
+                this.processItemCompleted(params.item);
+                break;
+            }
+            case "item/agentMessage/delta": {
+                const delta = typeof params.delta === "string"
+                    ? params.delta
+                    : typeof params.textDelta === "string"
+                        ? params.textDelta
+                        : "";
+                if (delta) {
+                    this.emitMessage({ type: "stream_delta", text: delta });
+                }
+                break;
+            }
+            case "item/reasoning/summaryTextDelta":
+            case "item/reasoning/textDelta": {
+                const delta = typeof params.delta === "string"
+                    ? params.delta
+                    : typeof params.textDelta === "string"
+                        ? params.textDelta
+                        : "";
+                if (delta) {
+                    this.emitMessage({ type: "thinking_delta", text: delta });
+                }
+                break;
+            }
+            case "item/plan/delta": {
+                const delta = typeof params.delta === "string" ? params.delta : "";
+                if (delta) {
+                    this.emitMessage({ type: "thinking_delta", text: delta });
+                }
+                break;
+            }
+            case "skills/changed": {
+                // Re-fetch skills when Codex notifies us of changes
+                if (this._projectPath) {
+                    void this.fetchSkills(this._projectPath);
+                }
+                break;
+            }
+            case "turn/plan/updated": {
+                // Default mode's update_plan tool output — always show as informational text
+                const text = formatPlanUpdateText(params);
+                if (!text)
+                    break;
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: randomUUID(),
+                        role: "assistant",
+                        content: [{ type: "text", text }],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            case "serverRequest/resolved": {
+                this.handleServerRequestResolved(params);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    handleTurnCompleted(turn) {
+        const status = String(turn?.status ?? "completed");
+        const usage = this.lastTokenUsage;
+        this.lastTokenUsage = null;
+        if (status === "failed") {
+            const errorObj = turn?.error;
+            const message = typeof errorObj?.message === "string"
+                ? errorObj.message
+                : "Turn failed";
+            this.emitMessage({
+                type: "result",
+                subtype: "error",
+                error: message,
+                sessionId: this._threadId ?? undefined,
+            });
+        }
+        else if (status === "interrupted") {
+            this.emitMessage({
+                type: "result",
+                subtype: "interrupted",
+                sessionId: this._threadId ?? undefined,
+            });
+        }
+        else {
+            this.emitMessage({
+                type: "result",
+                subtype: "success",
+                sessionId: this._threadId ?? undefined,
+                ...(usage?.input != null ? { inputTokens: usage.input } : {}),
+                ...(usage?.cachedInput != null ? { cachedInputTokens: usage.cachedInput } : {}),
+                ...(usage?.output != null ? { outputTokens: usage.output } : {}),
+            });
+        }
+        this.pendingTurnId = null;
+        // Plan mode: emit synthetic plan approval and wait for user decision
+        if (this._collaborationMode === "plan" && this.lastPlanItemText) {
+            const toolUseId = `plan_${randomUUID()}`;
+            this.pendingPlanCompletion = {
+                toolUseId,
+                planText: this.lastPlanItemText,
+            };
+            this.lastPlanItemText = null;
+            this.emitMessage({
+                type: "permission_request",
+                toolUseId,
+                toolName: "ExitPlanMode",
+                input: { plan: this.pendingPlanCompletion.planText },
+            });
+            this.setStatus("waiting_approval");
+            // Do NOT set idle — waiting for plan approval
+        }
+        else {
+            this.lastPlanItemText = null;
+            if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+                this.setStatus("idle");
+            }
+        }
+        if (this.pendingTurnCompletion) {
+            this.pendingTurnCompletion.resolve();
+            this.pendingTurnCompletion = null;
+        }
+    }
+    processItemStarted(item) {
+        if (!item || typeof item !== "object")
+            return;
+        const itemId = typeof item.id === "string" ? item.id : randomUUID();
+        const itemType = normalizeItemType(item.type);
+        switch (itemType) {
+            case "commandexecution": {
+                const commandText = typeof item.command === "string"
+                    ? item.command
+                    : Array.isArray(item.command)
+                        ? item.command.map((part) => String(part)).join(" ")
+                        : "";
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: "Bash",
+                                input: { command: commandText },
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            case "filechange": {
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: "FileChange",
+                                input: {
+                                    changes: Array.isArray(item.changes) ? item.changes : [],
+                                },
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            case "dynamictoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "DynamicTool";
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: tool,
+                                input: toToolUseInput(item.arguments),
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            case "collabagenttoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "subagent";
+                const toolName = "SubAgent";
+                const input = {
+                    tool,
+                    ...(typeof item.prompt === "string" ? { prompt: item.prompt } : {}),
+                    ...(typeof item.senderThreadId === "string" ? { senderThreadId: item.senderThreadId } : {}),
+                    ...(Array.isArray(item.receiverThreadIds) ? { receiverThreadIds: item.receiverThreadIds } : {}),
+                    ...(typeof item.model === "string" ? { model: item.model } : {}),
+                    ...(typeof item.reasoningEffort === "string" ? { reasoningEffort: item.reasoningEffort } : {}),
+                    ...(item.agentsStates ? { agentsStates: item.agentsStates } : {}),
+                };
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: toolName,
+                                input,
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    processItemCompleted(item) {
+        if (!item || typeof item !== "object")
+            return;
+        const itemId = typeof item.id === "string" ? item.id : randomUUID();
+        const itemType = normalizeItemType(item.type);
+        switch (itemType) {
+            case "agentmessage": {
+                const text = extractAgentText(item);
+                if (!text)
+                    return;
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [{ type: "text", text }],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            case "reasoning": {
+                const text = extractReasoningText(item);
+                if (text) {
+                    this.emitMessage({ type: "thinking_delta", text });
+                }
+                break;
+            }
+            case "commandexecution": {
+                const output = typeof item.aggregatedOutput === "string"
+                    ? item.aggregatedOutput
+                    : typeof item.output === "string"
+                        ? item.output
+                        : "";
+                const exitCode = numberOrUndefined(item.exitCode ?? item.exit_code);
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content: output || `exit code: ${exitCode ?? "unknown"}`,
+                    toolName: "Bash",
+                });
+                break;
+            }
+            case "filechange": {
+                const content = formatFileChangesWithDiff(item.changes);
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content,
+                    toolName: "FileChange",
+                });
+                break;
+            }
+            case "mcptoolcall": {
+                const server = typeof item.server === "string" ? item.server : "mcp";
+                const tool = typeof item.tool === "string" ? item.tool : "unknown";
+                const toolName = `mcp:${server}/${tool}`;
+                const result = item.result ?? item.error ?? "MCP call completed";
+                const normalized = normalizeMcpToolResult(result);
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: toolName,
+                                input: item.arguments ?? {},
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content: normalized.content,
+                    toolName,
+                    ...(normalized.rawContentBlocks.length > 0
+                        ? { rawContentBlocks: normalized.rawContentBlocks }
+                        : {}),
+                });
+                break;
+            }
+            case "dynamictoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "DynamicTool";
+                const content = formatDynamicToolResult(item);
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content,
+                    toolName: tool,
+                });
+                break;
+            }
+            case "websearch": {
+                const query = typeof item.query === "string" ? item.query : "";
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: "WebSearch",
+                                input: { query },
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content: query ? `Web search: ${query}` : "Web search completed",
+                    toolName: "WebSearch",
+                });
+                break;
+            }
+            case "collabagenttoolcall": {
+                const tool = typeof item.tool === "string" ? item.tool : "subagent";
+                const status = typeof item.status === "string" ? item.status : "completed";
+                const receiverThreadIds = Array.isArray(item.receiverThreadIds)
+                    ? item.receiverThreadIds.map((entry) => String(entry))
+                    : [];
+                const content = [
+                    `tool: ${tool}`,
+                    `status: ${status}`,
+                    ...(receiverThreadIds.length > 0
+                        ? [`agents: ${receiverThreadIds.join(", ")}`]
+                        : []),
+                ].join("\n");
+                this.emitMessage({
+                    type: "tool_result",
+                    toolUseId: itemId,
+                    content,
+                    toolName: "SubAgent",
+                });
+                break;
+            }
+            case "plan": {
+                // Plan item completed — save text for plan approval emission in handleTurnCompleted()
+                const planText = typeof item.text === "string" ? item.text : "";
+                this.lastPlanItemText = planText;
+                break;
+            }
+            case "error": {
+                const message = typeof item.message === "string" ? item.message : "Codex item error";
+                this.emitMessage({ type: "error", message });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    async toRpcInput(pendingInput) {
+        const input = [];
+        const tempPaths = [];
+        // Prepend SkillUserInput if a skill reference is attached
+        if (pendingInput.skill) {
+            input.push({ type: "skill", name: pendingInput.skill.name, path: pendingInput.skill.path });
+        }
+        input.push({ type: "text", text: pendingInput.text });
+        if (!pendingInput.images || pendingInput.images.length === 0) {
+            return { input, tempPaths };
+        }
+        for (const image of pendingInput.images) {
+            const ext = extensionFromMime(image.mimeType);
+            if (!ext) {
+                this.emitMessage({
+                    type: "error",
+                    message: `Unsupported image mime type for Codex: ${image.mimeType}`,
+                });
+                continue;
+            }
+            let buffer;
+            try {
+                buffer = Buffer.from(image.base64, "base64");
+            }
+            catch {
+                this.emitMessage({
+                    type: "error",
+                    message: "Invalid base64 image data for Codex input",
+                });
+                continue;
+            }
+            const tempPath = join(tmpdir(), `ccpocket-codex-image-${randomUUID()}.${ext}`);
+            await writeFile(tempPath, buffer);
+            tempPaths.push(tempPath);
+            input.push({ type: "localImage", path: tempPath });
+        }
+        return { input, tempPaths };
+    }
+    request(method, params) {
+        const id = this.rpcSeq++;
+        const envelope = { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pendingRpc.set(id, { resolve, reject, method });
+            try {
+                this.writeEnvelope(envelope);
+            }
+            catch (err) {
+                this.pendingRpc.delete(id);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    notify(method, params) {
+        this.writeEnvelope({ method, params });
+    }
+    respondToServerRequest(id, result) {
+        try {
+            this.writeEnvelope({ id, result });
+        }
+        catch (err) {
+            if (!this.stopped) {
+                console.warn(`[codex-process] failed to respond to server request: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    writeEnvelope(envelope) {
+        if (!this.child || this.child.killed) {
+            throw new Error("codex app-server is not running");
+        }
+        const line = `${JSON.stringify(envelope)}\n`;
+        this.child.stdin.write(line);
+    }
+    rejectAllPending(error) {
+        for (const pending of this.pendingRpc.values()) {
+            pending.reject(error);
+        }
+        this.pendingRpc.clear();
+        if (this.pendingTurnCompletion) {
+            this.pendingTurnCompletion.reject(error);
+            this.pendingTurnCompletion = null;
+        }
+    }
+    setStatus(status) {
+        if (this._status !== status) {
+            this._status = status;
+            this.emit("status", status);
+            this.emitMessage({ type: "status", status });
+        }
+    }
+    emitMessage(msg) {
+        this.emit("message", msg);
+    }
+    extractToolUseId(params, requestId) {
+        if (typeof params.approvalId === "string")
+            return params.approvalId;
+        if (typeof params.elicitationId === "string")
+            return params.elicitationId;
+        if (typeof params.itemId === "string")
+            return params.itemId;
+        if (typeof requestId === "string")
+            return requestId;
+        return `approval-${requestId}`;
+    }
+    handleServerRequestResolved(params) {
+        const requestId = params.requestId;
+        if (requestId === undefined || requestId === null)
+            return;
+        const approval = [...this.pendingApprovals.values()].find((entry) => entry.requestId === requestId);
+        if (approval) {
+            this.pendingApprovals.delete(approval.toolUseId);
+            this.emitMessage({ type: "permission_resolved", toolUseId: approval.toolUseId });
+        }
+        const inputRequest = [...this.pendingUserInputs.values()].find((entry) => entry.requestId === requestId);
+        if (inputRequest) {
+            this.pendingUserInputs.delete(inputRequest.toolUseId);
+            this.emitMessage({ type: "permission_resolved", toolUseId: inputRequest.toolUseId });
+        }
+        if (!this.pendingPlanCompletion && this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+            this.setStatus(this.pendingTurnId ? "running" : "idle");
+        }
+    }
+}
+function buildApprovalResponse(pending, decision) {
+    if (pending.kind === "permissions") {
+        return {
+            scope: decision === "acceptForSession" ? "session" : "turn",
+            permissions: decision === "decline" ? {} : (pending.requestedPermissions ?? {}),
+        };
+    }
+    return {
+        decision,
+    };
+}
+function buildUserInputResponse(pending, rawResult) {
+    if (pending.kind === "questions") {
+        return {
+            answers: buildUserInputAnswers(pending.questions, rawResult),
+        };
+    }
+    return buildElicitationResponse(pending, rawResult);
+}
+function normalizeApprovalPolicy(value) {
+    switch (value) {
+        case "on-request":
+            return "on-request";
+        case "on-failure":
+            return "on-failure";
+        case "untrusted":
+            return "untrusted";
+        case "never":
+        default:
+            return "never";
+    }
+}
+function normalizeSandboxMode(value) {
+    switch (value) {
+        case "read-only":
+            return "read-only";
+        case "danger-full-access":
+            return "danger-full-access";
+        case "workspace-write":
+        default:
+            return "workspace-write";
+    }
+}
+function normalizeReasoningEffort(value) {
+    switch (value) {
+        case "xhigh":
+            return "high";
+        default:
+            return value;
+    }
+}
+function normalizeItemType(raw) {
+    if (typeof raw !== "string")
+        return "";
+    return raw.replace(/[_\s-]/g, "").toLowerCase();
+}
+function numberOrUndefined(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringOrNull(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function summarizeFileChanges(changes) {
+    if (!Array.isArray(changes) || changes.length === 0) {
+        return "No file changes";
+    }
+    return changes
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return "changed";
+        const record = entry;
+        const kind = typeof record.kind === "string" ? record.kind : "changed";
+        const path = typeof record.path === "string" ? record.path : "(unknown)";
+        return `${kind}: ${path}`;
+    })
+        .join("\n");
+}
+function toToolUseInput(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return { items: value };
+    }
+    if (value === undefined || value === null) {
+        return {};
+    }
+    return { value };
+}
+function formatDynamicToolResult(item) {
+    const status = typeof item.status === "string" ? item.status : "completed";
+    const success = typeof item.success === "boolean" ? item.success : null;
+    const contentItems = Array.isArray(item.contentItems) ? item.contentItems : null;
+    const parts = [
+        `status: ${status}`,
+        ...(success != null ? [`success: ${success}`] : []),
+    ];
+    if (contentItems && contentItems.length > 0) {
+        for (const entry of contentItems) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const record = entry;
+            const type = typeof record.type === "string" ? record.type : "item";
+            if (type === "inputText" && typeof record.text === "string") {
+                parts.push(record.text);
+                continue;
+            }
+            if (type === "inputImage" && typeof record.imageUrl === "string") {
+                parts.push(`image: ${record.imageUrl}`);
+                continue;
+            }
+            parts.push(JSON.stringify(record));
+        }
+    }
+    return parts.join("\n");
+}
+function normalizeMcpToolResult(result) {
+    if (typeof result === "string") {
+        return { content: result, rawContentBlocks: [] };
+    }
+    const record = result && typeof result === "object" && !Array.isArray(result)
+        ? result
+        : null;
+    const contentItems = Array.isArray(record?.content) ? record.content : null;
+    if (!contentItems) {
+        return {
+            content: result == null ? "MCP call completed" : JSON.stringify(result),
+            rawContentBlocks: [],
+        };
+    }
+    const textParts = [];
+    const rawContentBlocks = [];
+    for (const entry of contentItems) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const item = entry;
+        const type = typeof item.type === "string" ? item.type : "";
+        if (type === "text" && typeof item.text === "string") {
+            textParts.push(item.text);
+            rawContentBlocks.push({ type: "text", text: item.text });
+            continue;
+        }
+        if (type === "image" && typeof item.data === "string") {
+            const mimeType = typeof item.mimeType === "string"
+                ? item.mimeType
+                : typeof item.mediaType === "string"
+                    ? item.mediaType
+                    : typeof item.media_type === "string"
+                        ? item.media_type
+                        : "image/png";
+            rawContentBlocks.push({
+                type: "image",
+                source: {
+                    type: "base64",
+                    data: item.data,
+                    media_type: mimeType,
+                },
+            });
+            continue;
+        }
+        rawContentBlocks.push(item);
+        textParts.push(JSON.stringify(item));
+    }
+    const content = textParts.join("\n").trim();
+    if (content.length > 0) {
+        return { content, rawContentBlocks };
+    }
+    const imageCount = rawContentBlocks.filter((entry) => entry.type === "image").length;
+    if (imageCount > 0) {
+        return {
+            content: imageCount === 1 ? "Generated 1 image" : `Generated ${imageCount} images`,
+            rawContentBlocks,
+        };
+    }
+    return {
+        content: result == null ? "MCP call completed" : JSON.stringify(result),
+        rawContentBlocks,
+    };
+}
+function toCodexThreadSummary(entry) {
+    const record = entry && typeof entry === "object"
+        ? entry
+        : {};
+    const gitInfo = record.gitInfo && typeof record.gitInfo === "object"
+        ? record.gitInfo
+        : {};
+    return {
+        id: typeof record.id === "string" ? record.id : "",
+        preview: typeof record.preview === "string" ? record.preview : "",
+        createdAt: numberOrUndefined(record.createdAt) ?? 0,
+        updatedAt: numberOrUndefined(record.updatedAt) ?? 0,
+        cwd: typeof record.cwd === "string" ? record.cwd : "",
+        agentNickname: stringOrNull(record.agentNickname),
+        agentRole: stringOrNull(record.agentRole),
+        gitBranch: stringOrNull(gitInfo.branch),
+        name: stringOrNull(record.name),
+    };
+}
+/**
+ * Format file changes including unified diff content for display in chat.
+ * Falls back to `kind: path` summary when no diff is available.
+ */
+function formatFileChangesWithDiff(changes) {
+    if (!Array.isArray(changes) || changes.length === 0) {
+        return "No file changes";
+    }
+    return changes
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return "changed";
+        const record = entry;
+        const kind = typeof record.kind === "string" ? record.kind : "changed";
+        const path = typeof record.path === "string" ? record.path : "(unknown)";
+        const diff = typeof record.diff === "string" ? record.diff.trim() : "";
+        if (diff) {
+            // If diff already has unified headers, use as-is; otherwise add them
+            if (diff.startsWith("---") || diff.startsWith("@@")) {
+                return `--- a/${path}\n+++ b/${path}\n${diff}`;
+            }
+            return diff;
+        }
+        return `${kind}: ${path}`;
+    })
+        .join("\n\n");
+}
+function extractAgentText(item) {
+    if (typeof item.text === "string")
+        return item.text;
+    const parts = item.content;
+    if (Array.isArray(parts)) {
+        const text = parts
+            .filter((part) => part && typeof part === "object")
+            .map((part) => {
+            const record = part;
+            if (record.type === "text" && typeof record.text === "string") {
+                return record.text;
+            }
+            return "";
+        })
+            .filter((part) => part.length > 0)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    return "";
+}
+function extractReasoningText(item) {
+    if (typeof item.text === "string")
+        return item.text;
+    const summary = item.summary;
+    if (Array.isArray(summary)) {
+        const text = summary
+            .map((entry) => {
+            if (!entry || typeof entry !== "object")
+                return "";
+            const record = entry;
+            return typeof record.text === "string" ? record.text : "";
+        })
+            .filter((part) => part.length > 0)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    return "";
+}
+function normalizeUserInputQuestions(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((entry) => !!entry && typeof entry === "object")
+        .map((entry, index) => {
+        const id = typeof entry.id === "string" ? entry.id : `question_${index + 1}`;
+        const question = typeof entry.question === "string" ? entry.question : "";
+        const header = typeof entry.header === "string" ? entry.header : `Question ${index + 1}`;
+        const optionsRaw = Array.isArray(entry.options) ? entry.options : [];
+        const options = optionsRaw
+            .filter((option) => !!option && typeof option === "object")
+            .map((option) => ({
+            label: typeof option.label === "string" ? option.label : "",
+            description: typeof option.description === "string" ? option.description : "",
+        }))
+            .filter((option) => option.label.length > 0);
+        return {
+            id,
+            question,
+            header,
+            options,
+            isOther: Boolean(entry.isOther),
+            isSecret: Boolean(entry.isSecret),
+        };
+    })
+        .filter((question) => question.question.length > 0);
+}
+function buildUserInputAnswers(questions, rawResult) {
+    const parsed = parseResultObject(rawResult);
+    const answerMap = {};
+    for (const question of questions) {
+        const candidate = parsed.byId[question.id] ?? parsed.byQuestion[question.question];
+        const answers = normalizeAnswerValues(candidate);
+        if (answers.length > 0) {
+            answerMap[question.id] = { answers };
+        }
+    }
+    if (Object.keys(answerMap).length === 0 && questions.length > 0) {
+        answerMap[questions[0].id] = { answers: normalizeAnswerValues(rawResult) };
+    }
+    return answerMap;
+}
+function parseResultObject(rawResult) {
+    try {
+        const parsed = JSON.parse(rawResult);
+        const byId = {};
+        const byQuestion = {};
+        if (parsed && typeof parsed === "object") {
+            const answers = parsed.answers;
+            if (answers && typeof answers === "object" && !Array.isArray(answers)) {
+                for (const [key, value] of Object.entries(answers)) {
+                    byId[key] = value;
+                    byQuestion[key] = value;
+                }
+            }
+        }
+        return { byId, byQuestion };
+    }
+    catch {
+        return { byId: {}, byQuestion: {} };
+    }
+}
+function normalizeAnswerValues(value) {
+    if (typeof value === "string") {
+        return value
+            .split(",")
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0);
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => String(entry).trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        if (Array.isArray(record.answers)) {
+            return record.answers
+                .map((entry) => String(entry).trim())
+                .filter((entry) => entry.length > 0);
+        }
+    }
+    if (value == null)
+        return [];
+    const normalized = String(value).trim();
+    return normalized ? [normalized] : [];
+}
+function buildElicitationResponse(pending, rawResult) {
+    if (pending.kind === "elicitation_url") {
+        const action = parseElicitationAction(rawResult);
+        return {
+            action,
+            content: null,
+            _meta: null,
+        };
+    }
+    const parsed = parseResultObject(rawResult);
+    const content = {};
+    for (const question of pending.questions) {
+        const candidate = parsed.byId[question.id] ?? parsed.byQuestion[question.question];
+        const answers = normalizeAnswerValues(candidate);
+        if (answers.length === 1) {
+            content[question.id] = answers[0];
+        }
+        else if (answers.length > 1) {
+            content[question.id] = answers;
+        }
+    }
+    if (Object.keys(content).length === 0 && pending.questions.length === 1) {
+        const answers = normalizeAnswerValues(rawResult);
+        if (answers.length === 1) {
+            content[pending.questions[0].id] = answers[0];
+        }
+        else if (answers.length > 1) {
+            content[pending.questions[0].id] = answers;
+        }
+    }
+    return {
+        action: "accept",
+        content: Object.keys(content).length > 0 ? content : null,
+        _meta: null,
+    };
+}
+function parseElicitationAction(rawResult) {
+    const normalized = rawResult.trim().toLowerCase();
+    if (normalized.includes("cancel"))
+        return "cancel";
+    if (normalized.includes("decline") || normalized.includes("deny"))
+        return "decline";
+    try {
+        const parsed = JSON.parse(rawResult);
+        const answers = parsed.answers;
+        if (answers && typeof answers === "object" && !Array.isArray(answers)) {
+            const first = Object.values(answers)[0];
+            const answer = normalizeAnswerValues(first).join(" ").toLowerCase();
+            if (answer.includes("cancel"))
+                return "cancel";
+            if (answer.includes("decline") || answer.includes("deny"))
+                return "decline";
+        }
+    }
+    catch {
+        // Fall through to accept.
+    }
+    return "accept";
+}
+function createElicitationInput(params) {
+    const serverName = typeof params.serverName === "string" ? params.serverName : "MCP";
+    const message = typeof params.message === "string" ? params.message : "Provide input";
+    if (params.mode === "url") {
+        const url = typeof params.url === "string" ? params.url : "";
+        const question = url ? `${message}\n${url}` : message;
+        return {
+            kind: "elicitation_url",
+            questions: [{ id: "elicitation_action", question }],
+            input: {
+                mode: "url",
+                serverName,
+                url,
+                message,
+                questions: [
+                    {
+                        id: "elicitation_action",
+                        header: serverName,
+                        question,
+                        options: [
+                            { label: "Accept", description: "Continue with this request" },
+                            { label: "Decline", description: "Reject this request" },
+                            { label: "Cancel", description: "Cancel without accepting" },
+                        ],
+                        multiSelect: false,
+                        isOther: false,
+                        isSecret: false,
+                    },
+                ],
+            },
+        };
+    }
+    const schema = asRecord(params.requestedSchema);
+    const properties = asRecord(schema?.properties) ?? {};
+    const requiredFields = new Set(Array.isArray(schema?.required)
+        ? schema.required.map((entry) => String(entry))
+        : []);
+    const questions = Object.entries(properties)
+        .filter(([, value]) => value && typeof value === "object")
+        .map(([key, value]) => {
+        const field = value;
+        const title = typeof field.title === "string" ? field.title : key;
+        const description = typeof field.description === "string" ? field.description : message;
+        const enumValues = Array.isArray(field.enum) ? field.enum.map((entry) => String(entry)) : [];
+        const type = typeof field.type === "string" ? field.type : "";
+        const options = enumValues.length > 0
+            ? enumValues.map((entry, index) => ({
+                label: entry,
+                description: index === 0 ? description : "",
+            }))
+            : type === "boolean"
+                ? [
+                    { label: "true", description: description },
+                    { label: "false", description: "" },
+                ]
+                : [];
+        return {
+            id: key,
+            question: requiredFields.has(key) ? `${title} (required)` : title,
+            header: serverName,
+            options,
+            isOther: options.length === 0,
+            isSecret: false,
+        };
+    });
+    const normalizedQuestions = questions.length > 0
+        ? questions
+        : [
+            {
+                id: "value",
+                question: message,
+                header: serverName,
+                options: [],
+                isOther: true,
+                isSecret: false,
+            },
+        ];
+    return {
+        kind: "elicitation_form",
+        questions: normalizedQuestions.map((question) => ({
+            id: question.id,
+            question: question.question,
+        })),
+        input: {
+            mode: "form",
+            serverName,
+            message,
+            requestedSchema: schema,
+            questions: normalizedQuestions.map((question) => ({
+                id: question.id,
+                header: question.header,
+                question: question.question,
+                options: question.options,
+                multiSelect: false,
+                isOther: question.isOther,
+                isSecret: question.isSecret,
+            })),
+        },
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function formatPlanUpdateText(params) {
+    const stepsRaw = params.plan;
+    if (!Array.isArray(stepsRaw) || stepsRaw.length === 0)
+        return "";
+    const explanation = typeof params.explanation === "string" ? params.explanation.trim() : "";
+    const lines = stepsRaw
+        .filter((entry) => !!entry && typeof entry === "object")
+        .map((entry, index) => {
+        const step = typeof entry.step === "string" ? entry.step : `Step ${index + 1}`;
+        const status = normalizePlanStatus(entry.status);
+        return `${index + 1}. [${status}] ${step}`;
+    });
+    if (lines.length === 0)
+        return "";
+    const header = explanation ? `Plan update: ${explanation}` : "Plan update:";
+    return `${header}\n${lines.join("\n")}`;
+}
+function normalizePlanStatus(raw) {
+    switch (raw) {
+        case "inProgress":
+            return "in progress";
+        case "completed":
+            return "completed";
+        case "pending":
+        default:
+            return "pending";
+    }
+}
+function extensionFromMime(mimeType) {
+    switch (mimeType) {
+        case "image/png":
+            return "png";
+        case "image/jpeg":
+            return "jpg";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=codex-process.js.map