factory-factory 0.3.2 → 0.3.4

package/dist/src/backend/domains/session/acp/codex-app-server-adapter/codex-app-server-acp-adapter.js

@@ -0,0 +1,1794 @@
+import { Readable, Writable } from 'node:stream';
+import { AgentSideConnection, ndJsonStream, PROTOCOL_VERSION, RequestError, } from '@agentclientprotocol/sdk';
+import { CodexRequestError, CodexRpcClient } from './codex-rpc-client.js';
+import { collaborationModeListResponseSchema, configRequirementsReadResponseSchema, knownCodexNotificationSchema, knownCodexServerRequestSchema, modelListResponseSchema, threadReadResponseSchema, threadResumeResponseSchema, threadStartResponseSchema, turnStartResponseSchema, } from './codex-zod.js';
+const PENDING_TURN_ID = '__pending_turn__';
+const MAX_CLOSE_WATCHER_ATTACH_RETRIES = 50;
+const DEFAULT_APPROVAL_POLICIES = ['on-failure', 'on-request', 'never'];
+const DEFAULT_SANDBOX_MODES = ['read-only', 'workspace-write', 'danger-full-access'];
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function dedupeStrings(values) {
+    return Array.from(new Set(values));
+}
+function humanizeToken(value) {
+    return value
+        .split(/[-_]/)
+        .filter((part) => part.length > 0)
+        .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function sanitizeModeName(mode) {
+    return mode
+        .split('_')
+        .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function formatApprovalPolicyLabel(policy) {
+    if (policy === 'on-request') {
+        return 'On Request';
+    }
+    if (policy === 'on-failure') {
+        return 'On Failure';
+    }
+    if (policy === 'never') {
+        return 'Never Ask';
+    }
+    if (policy === 'untrusted') {
+        return 'Untrusted';
+    }
+    return humanizeToken(policy);
+}
+function formatSandboxModeLabel(mode) {
+    if (mode === 'workspace-write') {
+        return 'Workspace Write';
+    }
+    if (mode === 'read-only') {
+        return 'Read-only';
+    }
+    if (mode === 'danger-full-access') {
+        return 'Full Access';
+    }
+    return humanizeToken(mode);
+}
+function formatExecutionPresetName(approvalPolicy, sandboxMode) {
+    if (approvalPolicy === 'never' && sandboxMode === 'danger-full-access') {
+        return 'YOLO (Full Access)';
+    }
+    return `${formatApprovalPolicyLabel(approvalPolicy)} (${formatSandboxModeLabel(sandboxMode)})`;
+}
+function createWorkspaceWriteSandboxPolicy(cwd) {
+    return {
+        type: 'workspaceWrite',
+        writableRoots: [cwd],
+        readOnlyAccess: { type: 'fullAccess' },
+        networkAccess: true,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false,
+    };
+}
+function createDangerFullAccessSandboxPolicy() {
+    return {
+        type: 'dangerFullAccess',
+    };
+}
+function parseSandboxModeFromPolicy(policy) {
+    if (!isRecord(policy)) {
+        return null;
+    }
+    const policyType = asString(policy.type);
+    if (policyType === 'workspaceWrite') {
+        return 'workspace-write';
+    }
+    if (policyType === 'readOnly') {
+        return 'read-only';
+    }
+    if (policyType === 'dangerFullAccess') {
+        return 'danger-full-access';
+    }
+    return null;
+}
+function createSandboxPolicyFromMode(mode, cwd) {
+    if (mode === 'danger-full-access') {
+        return createDangerFullAccessSandboxPolicy();
+    }
+    if (mode === 'read-only') {
+        return {
+            type: 'readOnly',
+            access: { type: 'fullAccess' },
+        };
+    }
+    return createWorkspaceWriteSandboxPolicy(cwd);
+}
+function toSessionId(threadId) {
+    return `sess_${threadId}`;
+}
+function toThreadId(sessionId) {
+    return sessionId.startsWith('sess_') ? sessionId.slice('sess_'.length) : sessionId;
+}
+function createToolCallId(threadId, turnId, itemId) {
+    return `codex:${threadId}:${turnId}:${itemId}`;
+}
+function isPlanLikeMode(mode) {
+    return /plan/i.test(mode);
+}
+const PLAN_EXIT_MODE_PREFERENCE = ['default', 'code', 'acceptEdits', 'ask'];
+const PLAN_TEXT_MAX_DEPTH = 8;
+const PLAN_TEXT_PREFERRED_KEYS = [
+    'plan',
+    'text',
+    'content',
+    'markdown',
+    'value',
+    'message',
+];
+function extractFirstPlanText(values, depth) {
+    for (const entry of values) {
+        const extracted = extractPlanTextLocal(entry, depth + 1);
+        if (extracted) {
+            return extracted;
+        }
+    }
+    return null;
+}
+function extractPlanTextFromRecord(value, depth) {
+    const preferred = extractFirstPlanText(PLAN_TEXT_PREFERRED_KEYS.map((key) => value[key]), depth);
+    if (preferred) {
+        return preferred;
+    }
+    return extractFirstPlanText(Object.values(value), depth);
+}
+function extractPlanTextLocal(value, depth = 0) {
+    if (depth > PLAN_TEXT_MAX_DEPTH) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? value : null;
+    }
+    if (Array.isArray(value)) {
+        return extractFirstPlanText(value, depth);
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    return extractPlanTextFromRecord(value, depth);
+}
+function toMcpEnvRecord(envVars) {
+    const env = {};
+    for (const entry of envVars) {
+        env[entry.name] = entry.value;
+    }
+    return env;
+}
+function toMcpHeadersRecord(headers) {
+    const result = {};
+    for (const header of headers) {
+        result[header.name] = header.value;
+    }
+    return result;
+}
+function sanitizeMcpServerName(name, index) {
+    const trimmed = name.trim();
+    return trimmed.length > 0 ? trimmed : `mcp_server_${index + 1}`;
+}
+function toCodexMcpServerConfig(server) {
+    if ('command' in server) {
+        const env = toMcpEnvRecord(server.env);
+        return {
+            enabled: true,
+            command: server.command,
+            args: [...server.args],
+            ...(Object.keys(env).length > 0 ? { env } : {}),
+        };
+    }
+    const httpHeaders = toMcpHeadersRecord(server.headers);
+    return {
+        enabled: true,
+        url: server.url,
+        ...(Object.keys(httpHeaders).length > 0 ? { http_headers: httpHeaders } : {}),
+        ...(server.type === 'sse' ? { transport: 'sse' } : {}),
+    };
+}
+function toCodexMcpConfigMap(mcpServers) {
+    const mcpServersByName = {};
+    const usedNames = new Set();
+    for (const [index, server] of mcpServers.entries()) {
+        const baseName = sanitizeMcpServerName(server.name, index);
+        let nextName = baseName;
+        let suffix = 2;
+        while (usedNames.has(nextName)) {
+            nextName = `${baseName}_${suffix}`;
+            suffix += 1;
+        }
+        usedNames.add(nextName);
+        mcpServersByName[nextName] = toCodexMcpServerConfig(server);
+    }
+    return mcpServersByName;
+}
+function buildToolUserInputPermissionOptions(questions) {
+    if (questions.length !== 1) {
+        return [
+            { optionId: 'allow_once', name: 'Submit', kind: 'allow_once' },
+            { optionId: 'reject_once', name: 'Cancel', kind: 'reject_once' },
+        ];
+    }
+    const firstQuestionWithOptions = questions.find((question) => Array.isArray(question.options) && question.options.length > 0);
+    if (!firstQuestionWithOptions?.options) {
+        return [
+            { optionId: 'allow_once', name: 'Submit', kind: 'allow_once' },
+            { optionId: 'reject_once', name: 'Cancel', kind: 'reject_once' },
+        ];
+    }
+    const mappedOptions = firstQuestionWithOptions.options.slice(0, 6).map((option, index) => ({
+        optionId: `answer_${index}`,
+        name: option.label,
+        kind: 'allow_once',
+    }));
+    mappedOptions.push({ optionId: 'reject_once', name: 'Cancel', kind: 'reject_once' });
+    return mappedOptions;
+}
+function buildToolUserInputAnswers(params) {
+    if (params.selectedOptionId === null || params.selectedOptionId === 'reject_once') {
+        return {};
+    }
+    const parsedAnswers = parseToolUserInputAnswersFromPermissionMeta({
+        questions: params.questions,
+        permission: params.permission,
+    });
+    if (parsedAnswers) {
+        return parsedAnswers;
+    }
+    if (params.questions.length !== 1) {
+        throw new Error('Missing structured answers for multi-question requestUserInput');
+    }
+    const selectedIndex = params.selectedOptionId.startsWith('answer_')
+        ? Number.parseInt(params.selectedOptionId.slice('answer_'.length), 10)
+        : Number.NaN;
+    const answers = {};
+    const [question] = params.questions;
+    if (!(question && Array.isArray(question.options)) || question.options.length === 0) {
+        return answers;
+    }
+    const selectedOption = Number.isNaN(selectedIndex)
+        ? question.options[0]
+        : (question.options[selectedIndex] ?? question.options[0]);
+    if (!selectedOption) {
+        return answers;
+    }
+    answers[question.id] = { answers: [selectedOption.label] };
+    return answers;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseToolUserInputAnswersFromPermissionMeta(params) {
+    const meta = params.permission._meta;
+    if (!isRecord(meta)) {
+        return null;
+    }
+    const factoryFactoryMeta = isRecord(meta.factoryFactory) ? meta.factoryFactory : null;
+    const answersRaw = (factoryFactoryMeta?.toolUserInputAnswers ?? meta.toolUserInputAnswers);
+    if (!isRecord(answersRaw)) {
+        return null;
+    }
+    const knownQuestionIds = new Set(params.questions.map((question) => question.id));
+    const answers = {};
+    for (const [questionId, value] of Object.entries(answersRaw)) {
+        if (!knownQuestionIds.has(questionId)) {
+            continue;
+        }
+        const values = (Array.isArray(value) ? value : [value])
+            .filter((entry) => typeof entry === 'string')
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0);
+        if (values.length === 0) {
+            continue;
+        }
+        answers[questionId] = { answers: values };
+    }
+    return answers;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : null;
+}
+function parseTextFromPromptBlock(block) {
+    if (block.type === 'text') {
+        return block.text;
+    }
+    if (block.type === 'resource_link') {
+        return `[ACP_RESOURCE_LINK uri="${block.uri}" name="${block.name}"]\n[/ACP_RESOURCE_LINK]`;
+    }
+    if (block.type === 'resource') {
+        const resource = block.resource;
+        const mime = resource.mimeType ?? 'unknown';
+        const payload = 'text' in resource && typeof resource.text === 'string'
+            ? resource.text
+            : 'blob' in resource && typeof resource.blob === 'string'
+                ? resource.blob
+                : JSON.stringify(resource);
+        return `[ACP_RESOURCE uri="${resource.uri}" mime="${mime}"]\n${payload}\n[/ACP_RESOURCE]`;
+    }
+    if (block.type === 'image') {
+        const mime = block.mimeType ?? 'application/octet-stream';
+        return `[ACP_IMAGE mime="${mime}" bytes=${block.data.length}]`;
+    }
+    return JSON.stringify(block);
+}
+function toToolStatus(status) {
+    if (status === 'inProgress') {
+        return 'in_progress';
+    }
+    if (status === 'completed') {
+        return 'completed';
+    }
+    if (status === 'failed' || status === 'declined') {
+        return 'failed';
+    }
+    return undefined;
+}
+function createCollaborationModeConfigOption(currentMode, collaborationModes) {
+    const options = collaborationModes
+        .filter((entry) => isNonEmptyString(entry.mode))
+        .map((entry) => ({
+        value: entry.mode,
+        name: entry.name,
+    }));
+    if (!options.some((option) => option.value === currentMode)) {
+        options.unshift({ value: currentMode, name: sanitizeModeName(currentMode) });
+    }
+    return {
+        id: 'mode',
+        category: 'mode',
+        name: 'Collaboration Mode',
+        type: 'select',
+        currentValue: currentMode,
+        options,
+    };
+}
+function createModelConfigOption(currentModel, modelCatalog) {
+    const options = modelCatalog.map((model) => ({
+        value: model.id,
+        name: model.displayName,
+        description: model.description,
+    }));
+    if (!options.some((option) => option.value === currentModel)) {
+        options.unshift({ value: currentModel, name: currentModel });
+    }
+    return {
+        id: 'model',
+        category: 'model',
+        name: 'Model',
+        type: 'select',
+        currentValue: currentModel,
+        options,
+    };
+}
+function createReasoningEffortConfigOption(currentReasoningEffort, modelCatalog, currentModel) {
+    const modelEntry = modelCatalog.find((model) => model.id === currentModel);
+    if (!modelEntry) {
+        return null;
+    }
+    const supportedEntries = modelEntry.supportedReasoningEfforts.filter((entry) => isNonEmptyString(entry.reasoningEffort));
+    if (supportedEntries.length === 0) {
+        return null;
+    }
+    const supportedByValue = new Map();
+    for (const entry of supportedEntries) {
+        if (!supportedByValue.has(entry.reasoningEffort)) {
+            supportedByValue.set(entry.reasoningEffort, entry.description);
+        }
+    }
+    const supportedValues = [...supportedByValue.keys()];
+    const resolvedCurrent = currentReasoningEffort && supportedByValue.has(currentReasoningEffort)
+        ? currentReasoningEffort
+        : supportedByValue.has(modelEntry.defaultReasoningEffort)
+            ? modelEntry.defaultReasoningEffort
+            : supportedValues[0];
+    if (!resolvedCurrent) {
+        return null;
+    }
+    return {
+        id: 'reasoning_effort',
+        category: 'thought_level',
+        name: 'Reasoning Effort',
+        type: 'select',
+        currentValue: resolvedCurrent,
+        options: supportedValues.map((value) => ({
+            value,
+            name: value,
+            ...(supportedByValue.get(value) ? { description: supportedByValue.get(value) } : {}),
+        })),
+    };
+}
+function createExecutionModeConfigOption(currentPresetId, presets) {
+    return {
+        id: 'execution_mode',
+        category: 'permission',
+        name: 'Execution Mode',
+        type: 'select',
+        currentValue: currentPresetId,
+        options: presets.map((preset) => ({
+            value: preset.id,
+            name: preset.name,
+            ...(preset.description ? { description: preset.description } : {}),
+        })),
+    };
+}
+function toExecutionPresetId(approvalPolicy, sandboxMode) {
+    return JSON.stringify([approvalPolicy, sandboxMode]);
+}
+export class CodexAppServerAcpAdapter {
+    connection;
+    codex;
+    sessions = new Map();
+    sessionIdByThreadId = new Map();
+    modelCatalog = [];
+    allowedApprovalPolicies = [];
+    allowedSandboxModes = [];
+    collaborationModes = [];
+    mcpServersByThreadId = new Map();
+    appliedMcpServerConfigJson = '{}';
+    constructor(connection, codexClient) {
+        this.connection = connection;
+        this.codex =
+            codexClient ??
+                new CodexRpcClient({
+                    cwd: process.cwd(),
+                    env: { ...process.env },
+                    onStderr: (line) => {
+                        process.stderr.write(line);
+                    },
+                    onNotification: (notification) => {
+                        void this.handleCodexNotification(notification.method, notification.params);
+                    },
+                    onRequest: (request) => {
+                        void this.handleCodexServerRequest(request).catch((error) => {
+                            const message = error instanceof Error ? error.message : String(error);
+                            this.codex.respondError(request.id, {
+                                code: -32_600,
+                                message: 'Failed to process codex approval request',
+                                data: { error: message },
+                            });
+                        });
+                    },
+                    onProtocolError: (error) => {
+                        process.stderr.write(`[codex-app-server-acp] protocol-error: ${error.reason}\n`);
+                    },
+                });
+        this.monitorConnectionClose();
+    }
+    monitorConnectionClose() {
+        let attachAttempts = 0;
+        const attachCloseWatcher = () => {
+            try {
+                void this.connection.closed
+                    .finally(async () => {
+                    await this.codex.stop();
+                })
+                    .catch(() => {
+                });
+            }
+            catch {
+                attachAttempts += 1;
+                if (attachAttempts >= MAX_CLOSE_WATCHER_ATTACH_RETRIES) {
+                    process.stderr.write(`[codex-app-server-acp] failed to attach close watcher after ${MAX_CLOSE_WATCHER_ATTACH_RETRIES} attempts\n`);
+                    void this.codex.stop();
+                    return;
+                }
+                const retryTimer = setTimeout(attachCloseWatcher, 0);
+                retryTimer.unref?.();
+            }
+        };
+        queueMicrotask(attachCloseWatcher);
+    }
+    async initialize(_params) {
+        this.codex.start();
+        await this.codex.request('initialize', {
+            clientInfo: {
+                name: 'factory-factory-codex-app-server-acp',
+                version: '0.1.0',
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+        this.codex.notify('initialized');
+        const configRequirements = await this.loadConfigRequirements();
+        this.allowedApprovalPolicies = configRequirements.allowedApprovalPolicies;
+        this.allowedSandboxModes = configRequirements.allowedSandboxModes;
+        this.collaborationModes = await this.loadCollaborationModes();
+        this.modelCatalog = await this.loadModelCatalog();
+        return {
+            protocolVersion: PROTOCOL_VERSION,
+            agentInfo: {
+                name: 'factory-factory-codex-app-server-acp',
+                version: '0.1.0',
+            },
+            agentCapabilities: {
+                loadSession: true,
+                promptCapabilities: {
+                    image: false,
+                    embeddedContext: true,
+                },
+            },
+            authMethods: [],
+        };
+    }
+    async newSession(params) {
+        const defaultModel = this.resolveDefaultModel();
+        const responseRaw = await this.codex.request('thread/start', {
+            cwd: params.cwd,
+            model: defaultModel,
+        });
+        const response = threadStartResponseSchema.parse(responseRaw);
+        const sessionId = toSessionId(response.thread.id);
+        const approvalPolicy = this.requireApprovalPolicy(response.approvalPolicy, 'thread/start');
+        const model = this.resolveSessionModel(response.model, defaultModel);
+        const sandboxPolicy = this.resolveSandboxPolicy(response.sandbox, params.cwd);
+        const reasoningEffort = this.resolveReasoningEffortForModel(model, response.reasoningEffort);
+        const collaborationMode = this.resolveDefaultCollaborationMode();
+        const session = {
+            sessionId,
+            threadId: response.thread.id,
+            cwd: params.cwd,
+            defaults: {
+                model,
+                approvalPolicy,
+                sandboxPolicy,
+                reasoningEffort,
+                collaborationMode,
+            },
+            activeTurn: null,
+            toolCallsByItemId: new Map(),
+            planTextByItemId: new Map(),
+            planApprovalRequestedByTurnId: new Set(),
+            pendingPlanApprovalsByTurnId: new Map(),
+            pendingTurnCompletionsByTurnId: new Map(),
+        };
+        this.sessions.set(sessionId, session);
+        this.sessionIdByThreadId.set(session.threadId, sessionId);
+        try {
+            await this.applyMcpServers(session.threadId, params.mcpServers);
+        }
+        catch (error) {
+            this.sessions.delete(sessionId);
+            this.sessionIdByThreadId.delete(session.threadId);
+            throw error;
+        }
+        return {
+            sessionId,
+            configOptions: this.buildConfigOptions(session),
+        };
+    }
+    async loadSession(params) {
+        const threadId = toThreadId(params.sessionId);
+        const responseRaw = await this.codex.request('thread/resume', {
+            threadId,
+            cwd: params.cwd,
+        });
+        const response = threadResumeResponseSchema.parse(responseRaw);
+        const approvalPolicy = this.requireApprovalPolicy(response.approvalPolicy, 'thread/resume');
+        const model = this.resolveSessionModel(response.model, this.resolveDefaultModel());
+        const sandboxPolicy = this.resolveSandboxPolicy(response.sandbox, params.cwd);
+        const reasoningEffort = this.resolveReasoningEffortForModel(model, response.reasoningEffort);
+        const collaborationMode = this.resolveDefaultCollaborationMode();
+        const session = {
+            sessionId: params.sessionId,
+            threadId: response.thread.id,
+            cwd: params.cwd,
+            defaults: {
+                model,
+                approvalPolicy,
+                sandboxPolicy,
+                reasoningEffort,
+                collaborationMode,
+            },
+            activeTurn: null,
+            toolCallsByItemId: new Map(),
+            planTextByItemId: new Map(),
+            planApprovalRequestedByTurnId: new Set(),
+            pendingPlanApprovalsByTurnId: new Map(),
+            pendingTurnCompletionsByTurnId: new Map(),
+        };
+        this.sessions.set(session.sessionId, session);
+        this.sessionIdByThreadId.set(session.threadId, session.sessionId);
+        try {
+            await this.applyMcpServers(session.threadId, params.mcpServers);
+            await this.replayThreadHistory(session.sessionId, session.threadId);
+        }
+        catch (error) {
+            try {
+                await this.removeMcpServersForThread(session.threadId);
+            }
+            catch {
+            }
+            this.sessions.delete(session.sessionId);
+            this.sessionIdByThreadId.delete(session.threadId);
+            throw error;
+        }
+        return {
+            configOptions: this.buildConfigOptions(session),
+        };
+    }
+    async authenticate(_params) {
+        await Promise.resolve();
+        return {};
+    }
+    async setSessionMode(params) {
+        await Promise.resolve();
+        const session = this.requireSession(params.sessionId);
+        const availableModes = this.getCollaborationModeValues(session.defaults.collaborationMode);
+        if (!availableModes.includes(params.modeId)) {
+            throw RequestError.invalidParams({
+                modeId: params.modeId,
+            });
+        }
+        session.defaults.collaborationMode = params.modeId;
+        return {};
+    }
+    async setSessionConfigOption(params) {
+        await Promise.resolve();
+        const session = this.requireSession(params.sessionId);
+        switch (params.configId) {
+            case 'mode': {
+                const availableModes = this.getCollaborationModeValues(session.defaults.collaborationMode);
+                if (!availableModes.includes(params.value)) {
+                    throw RequestError.invalidParams({
+                        configId: params.configId,
+                        value: params.value,
+                    });
+                }
+                session.defaults.collaborationMode = params.value;
+                break;
+            }
+            case 'execution_mode': {
+                const presets = this.getExecutionPresets(session);
+                const selectedPreset = presets.find((preset) => preset.id === params.value);
+                if (!selectedPreset) {
+                    throw RequestError.invalidParams({
+                        configId: params.configId,
+                        value: params.value,
+                    });
+                }
+                session.defaults.approvalPolicy = selectedPreset.approvalPolicy;
+                session.defaults.sandboxPolicy = createSandboxPolicyFromMode(selectedPreset.sandboxMode, session.cwd);
+                break;
+            }
+            case 'model': {
+                if (!this.modelCatalog.some((model) => model.id === params.value)) {
+                    throw RequestError.invalidParams({
+                        configId: params.configId,
+                        value: params.value,
+                    });
+                }
+                session.defaults.model = params.value;
+                session.defaults.reasoningEffort = this.resolveReasoningEffortForModel(session.defaults.model, session.defaults.reasoningEffort);
+                break;
+            }
+            case 'reasoning_effort':
+            case 'thought_level': {
+                const modelEntry = this.modelCatalog.find((model) => model.id === session.defaults.model);
+                const supportedReasoningEfforts = modelEntry?.supportedReasoningEfforts ?? [];
+                const supportedValues = new Set(supportedReasoningEfforts
+                    .map((entry) => entry.reasoningEffort)
+                    .filter((effort) => isNonEmptyString(effort)));
+                if (!supportedValues.has(params.value)) {
+                    throw RequestError.invalidParams({
+                        configId: params.configId,
+                        value: params.value,
+                    });
+                }
+                session.defaults.reasoningEffort = params.value;
+                break;
+            }
+            default:
+                throw RequestError.invalidParams({ configId: params.configId });
+        }
+        return {
+            configOptions: this.buildConfigOptions(session),
+        };
+    }
+    async prompt(params) {
+        const session = this.requireSession(params.sessionId);
+        if (session.activeTurn) {
+            throw RequestError.invalidRequest({
+                reason: 'A turn is already in progress for this session',
+            });
+        }
+        const input = params.prompt
+            .map((block) => parseTextFromPromptBlock(block))
+            .filter((text) => text.trim().length > 0)
+            .map((text) => ({ type: 'text', text, text_elements: [] }));
+        if (input.length === 0) {
+            throw RequestError.invalidParams({
+                reason: 'Prompt must include at least one non-empty content block',
+            });
+        }
+        const stopReasonPromise = this.createPendingTurnPromise(session);
+        try {
+            const turnStartParams = {
+                threadId: session.threadId,
+                input,
+                cwd: session.cwd,
+                approvalPolicy: session.defaults.approvalPolicy,
+                sandboxPolicy: session.defaults.sandboxPolicy,
+                model: session.defaults.model,
+                effort: session.defaults.reasoningEffort,
+            };
+            const collaborationModeParams = this.resolveTurnCollaborationMode(session);
+            if (collaborationModeParams) {
+                turnStartParams.collaborationMode = collaborationModeParams;
+            }
+            const turnStartRaw = await this.codex.request('turn/start', turnStartParams);
+            const turnStart = turnStartResponseSchema.parse(turnStartRaw);
+            await this.bindTurnToActivePrompt(session, turnStart.turn.id);
+            const immediateStopReason = await this.resolveImmediateTurnStopReason(session, turnStart);
+            if (immediateStopReason) {
+                this.settleTurn(session, immediateStopReason);
+                return { stopReason: await stopReasonPromise };
+            }
+            if (this.isActiveTurnCancelRequested(session)) {
+                await this.requestTurnInterrupt(session);
+            }
+            return { stopReason: await stopReasonPromise };
+        }
+        catch (error) {
+            if (error instanceof CodexRequestError && error.code === -32_001) {
+                await this.emitTurnFailureMessage(session.sessionId, error.message || 'Codex app-server request failed with overload response.');
+                this.settleTurn(session, 'end_turn');
+                return { stopReason: await stopReasonPromise };
+            }
+            this.settleTurn(session, 'end_turn');
+            throw error;
+        }
+    }
+    async resolveImmediateTurnStopReason(session, turnStart) {
+        const status = turnStart.turn.status;
+        if (status === 'interrupted') {
+            return 'cancelled';
+        }
+        if (status === 'failed') {
+            const failureMessage = asString(isRecord(turnStart.turn.error) ? turnStart.turn.error.message : null);
+            if (failureMessage) {
+                await this.emitTurnFailureMessage(session.sessionId, failureMessage);
+            }
+            return 'end_turn';
+        }
+        if (status === 'completed') {
+            return 'end_turn';
+        }
+        return null;
+    }
+    createPendingTurnPromise(session) {
+        return new Promise((resolve) => {
+            session.activeTurn = {
+                turnId: PENDING_TURN_ID,
+                cancelRequested: false,
+                settled: false,
+                resolve,
+            };
+        });
+    }
+    async bindTurnToActivePrompt(session, turnId) {
+        if (!session.activeTurn || session.activeTurn.settled) {
+            return;
+        }
+        session.activeTurn.turnId = turnId;
+        const pendingCompletion = session.pendingTurnCompletionsByTurnId.get(turnId);
+        if (!pendingCompletion) {
+            return;
+        }
+        session.pendingTurnCompletionsByTurnId.delete(turnId);
+        if (pendingCompletion.errorMessage) {
+            await this.emitTurnFailureMessage(session.sessionId, pendingCompletion.errorMessage);
+        }
+        this.settleTurn(session, pendingCompletion.stopReason);
+    }
+    async requestTurnInterrupt(session) {
+        if (!session.activeTurn || session.activeTurn.turnId === PENDING_TURN_ID) {
+            return;
+        }
+        await this.codex.request('turn/interrupt', {
+            threadId: session.threadId,
+            turnId: session.activeTurn.turnId,
+        });
+    }
+    isActiveTurnCancelRequested(session) {
+        return Boolean(session.activeTurn?.cancelRequested);
+    }
+    async emitTurnFailureMessage(sessionId, errorMessage) {
+        await this.emitSessionUpdate(sessionId, {
+            sessionUpdate: 'agent_message_chunk',
+            content: {
+                type: 'text',
+                text: errorMessage,
+            },
+        });
+    }
+    async cancel(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session?.activeTurn) {
+            return;
+        }
+        session.activeTurn.cancelRequested = true;
+        if (session.activeTurn.turnId === PENDING_TURN_ID) {
+            return;
+        }
+        try {
+            await this.requestTurnInterrupt(session);
+        }
+        catch {
+            this.settleTurn(session, 'cancelled');
+        }
+    }
+    resolveDefaultModel() {
+        const preferred = this.modelCatalog.find((model) => model.isDefault);
+        const fallback = this.modelCatalog[0]?.id;
+        if (preferred?.id) {
+            return preferred.id;
+        }
+        if (fallback) {
+            return fallback;
+        }
+        throw new Error('Codex app-server model/list returned no models');
+    }
+    buildMergedMcpServersConfig() {
+        const merged = {};
+        const threadIds = [...this.mcpServersByThreadId.keys()].sort();
+        for (const threadId of threadIds) {
+            const threadConfig = this.mcpServersByThreadId.get(threadId);
+            if (!threadConfig) {
+                continue;
+            }
+            for (const serverName of Object.keys(threadConfig).sort()) {
+                const nextServerConfig = threadConfig[serverName];
+                if (!nextServerConfig) {
+                    continue;
+                }
+                const existingConfig = merged[serverName];
+                if (!existingConfig) {
+                    merged[serverName] = nextServerConfig;
+                    continue;
+                }
+                if (JSON.stringify(existingConfig) === JSON.stringify(nextServerConfig)) {
+                    continue;
+                }
+                merged[`${serverName}__${threadId}`] = nextServerConfig;
+            }
+        }
+        return merged;
+    }
+    async writeMergedMcpServersConfig() {
+        const mergedConfig = this.buildMergedMcpServersConfig();
+        const nextConfigJson = JSON.stringify(mergedConfig);
+        if (nextConfigJson === this.appliedMcpServerConfigJson) {
+            return;
+        }
+        await this.codex.request('config/value/write', {
+            keyPath: 'mcp_servers',
+            value: mergedConfig,
+            mergeStrategy: 'replace',
+        });
+        await this.codex.request('config/mcpServer/reload', {});
+        this.appliedMcpServerConfigJson = nextConfigJson;
+    }
+    async removeMcpServersForThread(threadId) {
+        if (!this.mcpServersByThreadId.has(threadId)) {
+            return;
+        }
+        this.mcpServersByThreadId.delete(threadId);
+        await this.writeMergedMcpServersConfig();
+    }
+    async applyMcpServers(threadId, mcpServers) {
+        const previousConfig = this.mcpServersByThreadId.get(threadId);
+        const hadPreviousConfig = this.mcpServersByThreadId.has(threadId);
+        const threadConfig = toCodexMcpConfigMap(mcpServers);
+        if (Object.keys(threadConfig).length === 0) {
+            this.mcpServersByThreadId.delete(threadId);
+        }
+        else {
+            this.mcpServersByThreadId.set(threadId, threadConfig);
+        }
+        try {
+            await this.writeMergedMcpServersConfig();
+        }
+        catch (error) {
+            if (hadPreviousConfig && previousConfig) {
+                this.mcpServersByThreadId.set(threadId, previousConfig);
+            }
+            else {
+                this.mcpServersByThreadId.delete(threadId);
+            }
+            throw error;
+        }
+    }
+    buildConfigOptions(session) {
+        const executionPresets = this.getExecutionPresets(session);
+        const currentExecutionPreset = this.resolveExecutionPresetId(session, executionPresets);
+        const configOptions = [
+            createModelConfigOption(session.defaults.model, this.modelCatalog),
+            createCollaborationModeConfigOption(session.defaults.collaborationMode, this.collaborationModes),
+            createExecutionModeConfigOption(currentExecutionPreset, executionPresets),
+        ];
+        const reasoningOption = createReasoningEffortConfigOption(session.defaults.reasoningEffort, this.modelCatalog, session.defaults.model);
+        if (reasoningOption) {
+            configOptions.push(reasoningOption);
+        }
+        return configOptions;
+    }
+    requireApprovalPolicy(approvalPolicy, source) {
+        if (!isNonEmptyString(approvalPolicy)) {
+            throw new Error(`Codex ${source} response did not include approvalPolicy`);
+        }
+        return approvalPolicy;
+    }
+    resolveSessionModel(model, fallbackModel) {
+        return isNonEmptyString(model) ? model : fallbackModel;
+    }
+    resolveSandboxPolicy(sandbox, cwd) {
+        return isRecord(sandbox) ? sandbox : createWorkspaceWriteSandboxPolicy(cwd);
+    }
+    resolveDefaultCollaborationMode() {
+        if (this.collaborationModes.length === 0) {
+            throw new Error('Codex collaborationMode/list returned no modes');
+        }
+        const preferredDefault = this.collaborationModes.find((entry) => entry.mode === 'default');
+        const firstMode = this.collaborationModes[0]?.mode;
+        if (!firstMode) {
+            throw new Error('Codex collaborationMode/list returned an invalid mode entry');
+        }
+        return preferredDefault?.mode ?? firstMode;
+    }
+    resolveTurnCollaborationMode(session) {
+        const modeEntry = this.collaborationModes.find((entry) => entry.mode === session.defaults.collaborationMode);
+        return {
+            mode: modeEntry?.mode ?? session.defaults.collaborationMode,
+            settings: {
+                model: modeEntry?.model ?? session.defaults.model,
+                reasoning_effort: modeEntry?.reasoningEffort ?? session.defaults.reasoningEffort,
+                developer_instructions: modeEntry?.developerInstructions ?? null,
+            },
+        };
+    }
+    resolveReasoningEffortForModel(modelId, candidateReasoningEffort) {
+        const modelEntry = this.modelCatalog.find((entry) => entry.id === modelId);
+        if (!modelEntry) {
+            return null;
+        }
+        const supportedEntries = modelEntry.supportedReasoningEfforts.filter((entry) => isNonEmptyString(entry.reasoningEffort));
+        if (supportedEntries.length === 0) {
+            return null;
+        }
+        const supportedValues = dedupeStrings(supportedEntries.map((entry) => entry.reasoningEffort));
+        if (isNonEmptyString(candidateReasoningEffort) &&
+            supportedValues.includes(candidateReasoningEffort)) {
+            return candidateReasoningEffort;
+        }
+        if (supportedValues.includes(modelEntry.defaultReasoningEffort)) {
+            return modelEntry.defaultReasoningEffort;
+        }
+        return supportedValues[0] ?? null;
+    }
+    getCollaborationModeValues(currentMode) {
+        const values = this.collaborationModes
+            .map((entry) => entry.mode)
+            .filter((mode) => isNonEmptyString(mode));
+        if (!values.includes(currentMode)) {
+            values.unshift(currentMode);
+        }
+        return dedupeStrings(values);
+    }
+    resolveCurrentSandboxMode(session) {
+        const currentSandboxMode = parseSandboxModeFromPolicy(session.defaults.sandboxPolicy);
+        if (currentSandboxMode) {
+            return currentSandboxMode;
+        }
+        const allowedSandboxMode = this.allowedSandboxModes[0];
+        if (allowedSandboxMode) {
+            return allowedSandboxMode;
+        }
+        throw new Error('Unable to resolve current sandbox mode for execution-mode options');
+    }
+    getExecutionPresets(session) {
+        const currentSandboxMode = this.resolveCurrentSandboxMode(session);
+        const policies = this.allowedApprovalPolicies.length > 0
+            ? this.allowedApprovalPolicies
+            : [session.defaults.approvalPolicy];
+        const sandboxModes = this.allowedSandboxModes.length > 0 ? this.allowedSandboxModes : [currentSandboxMode];
+        const presets = [];
+        const seen = new Set();
+        const addPreset = (approvalPolicy, sandboxMode, description) => {
+            const id = toExecutionPresetId(approvalPolicy, sandboxMode);
+            if (seen.has(id)) {
+                return;
+            }
+            seen.add(id);
+            presets.push({
+                id,
+                name: formatExecutionPresetName(approvalPolicy, sandboxMode),
+                ...(description ? { description } : {}),
+                approvalPolicy,
+                sandboxMode,
+            });
+        };
+        addPreset(session.defaults.approvalPolicy, currentSandboxMode, `Current session: ${formatExecutionPresetName(session.defaults.approvalPolicy, currentSandboxMode)}`);
+        for (const policy of policies) {
+            for (const sandboxMode of sandboxModes) {
+                addPreset(policy, sandboxMode);
+            }
+        }
+        return presets;
+    }
+    resolveExecutionPresetId(session, presets) {
+        const currentSandboxMode = this.resolveCurrentSandboxMode(session);
+        const currentPresetId = toExecutionPresetId(session.defaults.approvalPolicy, currentSandboxMode);
+        const fallbackPresetId = presets[0]?.id;
+        if (!fallbackPresetId) {
+            throw new Error('Execution-mode presets are unavailable for this session');
+        }
+        return presets.some((preset) => preset.id === currentPresetId)
+            ? currentPresetId
+            : fallbackPresetId;
+    }
+    requireSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw RequestError.invalidParams({ sessionId });
+        }
+        return session;
+    }
+    async loadConfigRequirements() {
+        const raw = await this.codex.request('configRequirements/read', undefined);
+        const parsed = configRequirementsReadResponseSchema.parse(raw);
+        const requirements = parsed.requirements;
+        const allowedApprovalPolicies = dedupeStrings((requirements?.allowedApprovalPolicies ?? []).filter(isNonEmptyString));
+        const allowedSandboxModes = dedupeStrings((requirements?.allowedSandboxModes ?? []).filter((mode) => mode === 'read-only' || mode === 'workspace-write' || mode === 'danger-full-access'));
+        const hasExplicitApprovalPolicies = Array.isArray(requirements?.allowedApprovalPolicies);
+        const hasExplicitSandboxModes = Array.isArray(requirements?.allowedSandboxModes);
+        return {
+            allowedApprovalPolicies: allowedApprovalPolicies.length > 0
+                ? allowedApprovalPolicies
+                : hasExplicitApprovalPolicies
+                    ? []
+                    : DEFAULT_APPROVAL_POLICIES,
+            allowedSandboxModes: allowedSandboxModes.length > 0
+                ? allowedSandboxModes
+                : hasExplicitSandboxModes
+                    ? []
+                    : DEFAULT_SANDBOX_MODES,
+        };
+    }
+    async loadCollaborationModes() {
+        const entries = [];
+        let cursor = null;
+        for (;;) {
+            const response = await this.requestCollaborationModeListWithRetry(cursor);
+            entries.push(...response.data.flatMap((entry) => isNonEmptyString(entry.mode)
+                ? [
+                    {
+                        mode: entry.mode,
+                        name: entry.name,
+                        model: entry.model ?? null,
+                        reasoningEffort: entry.reasoning_effort ?? null,
+                        developerInstructions: entry.developer_instructions ?? null,
+                    },
+                ]
+                : []));
+            cursor = response.nextCursor ?? null;
+            if (!cursor) {
+                break;
+            }
+        }
+        if (entries.length === 0) {
+            throw new Error('Codex collaborationMode/list returned no modes');
+        }
+        return entries;
+    }
+    async requestCollaborationModeListWithRetry(cursor, maxAttempts = 3) {
+        let attempt = 0;
+        let lastError;
+        while (attempt < maxAttempts) {
+            attempt += 1;
+            try {
+                const raw = await this.codex.request('collaborationMode/list', cursor ? { cursor } : {});
+                return collaborationModeListResponseSchema.parse(raw);
+            }
+            catch (error) {
+                lastError = error;
+                if (!(error instanceof CodexRequestError) ||
+                    error.code !== -32_001 ||
+                    attempt >= maxAttempts) {
+                    throw error;
+                }
+                const delayMs = Math.round(2 ** attempt * 100 + Math.random() * 120);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+        throw lastError;
+    }
+    async loadModelCatalog() {
+        const models = [];
+        let cursor = null;
+        for (;;) {
+            const response = await this.requestModelListWithRetry(cursor);
+            models.push(...response.data.map((model) => ({
+                id: model.id,
+                displayName: model.displayName,
+                description: model.description,
+                defaultReasoningEffort: model.defaultReasoningEffort,
+                supportedReasoningEfforts: (model.supportedReasoningEfforts ?? [])
+                    .filter((entry) => isNonEmptyString(entry.reasoningEffort))
+                    .map((entry) => ({
+                    reasoningEffort: entry.reasoningEffort,
+                    description: entry.description,
+                })),
+                inputModalities: model.inputModalities ?? [],
+                isDefault: model.isDefault ?? false,
+            })));
+            cursor = response.nextCursor ?? null;
+            if (!cursor) {
+                return models;
+            }
+        }
+    }
+    async requestModelListWithRetry(cursor, maxAttempts = 3) {
+        let attempt = 0;
+        let lastError;
+        while (attempt < maxAttempts) {
+            attempt += 1;
+            try {
+                const raw = await this.codex.request('model/list', cursor ? { cursor } : {});
+                return modelListResponseSchema.parse(raw);
+            }
+            catch (error) {
+                lastError = error;
+                if (!(error instanceof CodexRequestError) ||
+                    error.code !== -32_001 ||
+                    attempt >= maxAttempts) {
+                    throw error;
+                }
+                const delayMs = Math.round(2 ** attempt * 100 + Math.random() * 120);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+        throw lastError;
+    }
+    async replayThreadHistory(sessionId, threadId) {
+        const session = this.requireSession(sessionId);
+        const threadReadRaw = await this.codex.request('thread/read', {
+            threadId,
+            includeTurns: true,
+        });
+        const threadRead = threadReadResponseSchema.parse(threadReadRaw);
+        for (const turn of threadRead.thread.turns) {
+            for (const item of turn.items) {
+                await this.replayThreadHistoryItem(session, sessionId, turn.id, item);
+            }
+        }
+    }
+    async replayThreadHistoryItem(session, sessionId, turnId, item) {
+        if (item.type === 'userMessage') {
+            await this.replayUserMessageHistoryItem(sessionId, item);
+            return;
+        }
+        if (item.type === 'agentMessage') {
+            await this.replayAgentMessageHistoryItem(sessionId, item);
+            return;
+        }
+        await this.replayToolLikeHistoryItem(session, sessionId, turnId, item);
+    }
+    async replayUserMessageHistoryItem(sessionId, item) {
+        const contentBlocks = Array.isArray(item.content) ? item.content : [];
+        for (const content of contentBlocks) {
+            if (!isRecord(content) || content.type !== 'text' || typeof content.text !== 'string') {
+                continue;
+            }
+            await this.emitSessionUpdate(sessionId, {
+                sessionUpdate: 'user_message_chunk',
+                content: { type: 'text', text: content.text },
+            });
+        }
+    }
+    async replayAgentMessageHistoryItem(sessionId, item) {
+        const text = asString(item.text);
+        if (!text) {
+            return;
+        }
+        await this.emitSessionUpdate(sessionId, {
+            sessionUpdate: 'agent_message_chunk',
+            content: { type: 'text', text },
+        });
+    }
+    async replayToolLikeHistoryItem(session, sessionId, turnId, item) {
+        const toolInfo = this.buildToolCallState(session, item, turnId);
+        if (!toolInfo) {
+            return;
+        }
+        await this.emitSessionUpdate(sessionId, {
+            sessionUpdate: 'tool_call',
+            toolCallId: toolInfo.toolCallId,
+            title: toolInfo.title,
+            kind: toolInfo.kind,
+            status: 'completed',
+            rawInput: item,
+            rawOutput: item,
+        });
+    }
+    async handleCodexNotification(method, params) {
+        const parsed = knownCodexNotificationSchema.safeParse({ method, params });
+        if (!parsed.success) {
+            process.stderr.write(`[codex-app-server-acp] dropped malformed notification: ${method}\n`);
+            return;
+        }
+        const notification = parsed.data;
+        if (notification.method === 'error' || notification.method === 'turn/started') {
+            return;
+        }
+        const sessionId = this.sessionIdByThreadId.get(notification.params.threadId);
+        if (!sessionId) {
+            return;
+        }
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        if (notification.method === 'item/agentMessage/delta') {
+            await this.emitSessionUpdate(sessionId, {
+                sessionUpdate: 'agent_message_chunk',
+                content: {
+                    type: 'text',
+                    text: notification.params.delta,
+                },
+            });
+            return;
+        }
+        if (notification.method === 'item/plan/delta') {
+            await this.handlePlanDelta(sessionId, session, notification.params.itemId, notification.params.delta);
+            return;
+        }
+        if (notification.method === 'item/commandExecution/outputDelta') {
+            await this.emitToolCallProgress(sessionId, session, notification.params.itemId, notification.params.delta);
+            return;
+        }
+        if (notification.method === 'item/fileChange/outputDelta') {
+            await this.emitToolCallProgress(sessionId, session, notification.params.itemId, notification.params.delta);
+            return;
+        }
+        if (notification.method === 'item/mcpToolCall/progress') {
+            await this.emitToolCallProgress(sessionId, session, notification.params.itemId, notification.params.message);
+            return;
+        }
+        if (notification.method === 'item/started') {
+            await this.handleItemStarted(session, notification.params.item, notification.params.turnId);
+            return;
+        }
+        if (notification.method === 'item/completed') {
+            await this.handleItemCompleted(session, notification.params.item, notification.params.turnId);
+            return;
+        }
+        if (notification.method === 'turn/completed') {
+            await this.handleTurnCompletedNotification(session, notification.params.turn.id, notification.params.turn.status, notification.params.turn.error?.message);
+        }
+    }
+    async handlePlanDelta(sessionId, session, itemId, delta) {
+        const previous = session.planTextByItemId.get(itemId) ?? '';
+        const next = `${previous}${delta}`;
+        session.planTextByItemId.set(itemId, next);
+        await this.emitSessionUpdate(sessionId, {
+            sessionUpdate: 'plan',
+            entries: [
+                {
+                    content: next,
+                    priority: 'medium',
+                    status: 'in_progress',
+                },
+            ],
+        });
+    }
+    async emitToolCallProgress(sessionId, session, itemId, output) {
+        const toolCall = session.toolCallsByItemId.get(itemId);
+        if (!toolCall) {
+            return;
+        }
+        await this.emitSessionUpdate(sessionId, {
+            sessionUpdate: 'tool_call_update',
+            toolCallId: toolCall.toolCallId,
+            status: 'in_progress',
+            rawOutput: output,
+        });
+    }
+    async handleTurnCompletedNotification(session, turnId, status, errorMessage) {
+        if (status === 'inProgress') {
+            return;
+        }
+        const completionStatus = status;
+        if (this.shouldDeferTurnCompletion(session, turnId, completionStatus)) {
+            session.pendingTurnCompletionsByTurnId.set(turnId, this.buildPendingTurnCompletion(completionStatus, errorMessage));
+            return;
+        }
+        await this.finalizeTurnCompletion(session, completionStatus, errorMessage);
+    }
+    shouldDeferTurnCompletion(session, turnId, status) {
+        if (!session.activeTurn || session.activeTurn.turnId !== turnId) {
+            return true;
+        }
+        return status !== 'interrupted' && this.hasPendingPlanApprovals(session, turnId);
+    }
+    buildPendingTurnCompletion(status, errorMessage) {
+        const stopReason = status === 'interrupted' ? 'cancelled' : 'end_turn';
+        if (status === 'failed' && errorMessage) {
+            return { stopReason, errorMessage };
+        }
+        return { stopReason };
+    }
+    async finalizeTurnCompletion(session, status, errorMessage) {
+        if (status === 'interrupted') {
+            this.settleTurn(session, 'cancelled');
+            return;
+        }
+        if (status === 'failed' && errorMessage) {
+            await this.emitTurnFailureMessage(session.sessionId, errorMessage);
+        }
+        if (status === 'failed') {
+            this.settleTurn(session, 'end_turn');
+            return;
+        }
+        this.settleTurn(session, session.activeTurn?.cancelRequested ? 'cancelled' : 'end_turn');
+    }
+    async handleItemStarted(session, item, turnId) {
+        const toolInfo = this.buildToolCallState(session, item, turnId);
+        if (!toolInfo) {
+            return;
+        }
+        session.toolCallsByItemId.set(item.id, toolInfo);
+        await this.emitSessionUpdate(session.sessionId, {
+            sessionUpdate: 'tool_call',
+            toolCallId: toolInfo.toolCallId,
+            title: toolInfo.title,
+            kind: toolInfo.kind,
+            status: 'pending',
+            rawInput: item,
+        });
+        const itemStatus = toToolStatus(item.status);
+        if (itemStatus === 'in_progress') {
+            await this.emitSessionUpdate(session.sessionId, {
+                sessionUpdate: 'tool_call_update',
+                toolCallId: toolInfo.toolCallId,
+                status: 'in_progress',
+            });
+        }
+    }
+    async handleItemCompleted(session, item, turnId) {
+        const existing = session.toolCallsByItemId.get(item.id);
+        if (!existing) {
+            return;
+        }
+        const shouldHoldTurnForPlanApproval = item.type === 'plan' &&
+            isPlanLikeMode(session.defaults.collaborationMode) &&
+            !session.planApprovalRequestedByTurnId.has(turnId) &&
+            this.extractPlanApprovalText(session, item) !== null;
+        if (shouldHoldTurnForPlanApproval) {
+            this.holdTurnUntilPlanApprovalResolves(session, turnId);
+        }
+        const statusFromItem = toToolStatus(item.status);
+        const status = statusFromItem ?? 'completed';
+        const locations = this.extractLocations(item);
+        await this.emitSessionUpdate(session.sessionId, {
+            sessionUpdate: 'tool_call_update',
+            toolCallId: existing.toolCallId,
+            status,
+            kind: existing.kind,
+            title: existing.title,
+            ...(locations.length > 0 ? { locations } : {}),
+            rawOutput: item,
+        });
+        session.toolCallsByItemId.delete(item.id);
+        await this.maybeRequestPlanApproval(session, item, turnId, existing);
+    }
+    buildPlanApprovalInput(planText, sourceItemId) {
+        return {
+            type: 'ExitPlanMode',
+            plan: { type: 'text', text: planText },
+            reason: 'Plan proposed. Approve to exit plan mode and continue implementation.',
+            source: 'codex_plan_completion',
+            sourceItemId,
+        };
+    }
+    extractPlanApprovalText(session, item) {
+        const bufferedText = session.planTextByItemId.get(item.id);
+        if (bufferedText && bufferedText.trim().length > 0) {
+            return bufferedText;
+        }
+        const fromPlanField = extractPlanTextLocal(item.plan);
+        if (fromPlanField && fromPlanField.trim().length > 0) {
+            return fromPlanField;
+        }
+        const fromTextField = extractPlanTextLocal(item.text);
+        if (fromTextField && fromTextField.trim().length > 0) {
+            return fromTextField;
+        }
+        return null;
+    }
+    isPlanApprovalSelected(optionId) {
+        if (!optionId) {
+            return false;
+        }
+        return optionId.startsWith('allow') || optionId === 'default';
+    }
+    resolvePostPlanApprovalMode(currentMode) {
+        if (!isPlanLikeMode(currentMode)) {
+            return null;
+        }
+        const availableModes = this.getCollaborationModeValues(currentMode);
+        for (const preferred of PLAN_EXIT_MODE_PREFERENCE) {
+            const match = availableModes.find((mode) => mode.toLowerCase() === preferred.toLowerCase());
+            if (match) {
+                return match;
+            }
+        }
+        const firstNonPlan = availableModes.find((mode) => !isPlanLikeMode(mode));
+        if (firstNonPlan) {
+            return firstNonPlan;
+        }
+        return currentMode.toLowerCase() === 'default' ? null : 'default';
+    }
+    holdTurnUntilPlanApprovalResolves(session, turnId) {
+        if (this.hasPendingPlanApprovals(session, turnId)) {
+            return;
+        }
+        session.pendingPlanApprovalsByTurnId.set(turnId, 1);
+    }
+    hasPendingPlanApprovals(session, turnId) {
+        return (session.pendingPlanApprovalsByTurnId.get(turnId) ?? 0) > 0;
+    }
+    async releaseTurnHoldForPlanApproval(session, turnId) {
+        const pendingCount = session.pendingPlanApprovalsByTurnId.get(turnId) ?? 0;
+        if (pendingCount <= 1) {
+            session.pendingPlanApprovalsByTurnId.delete(turnId);
+        }
+        else {
+            session.pendingPlanApprovalsByTurnId.set(turnId, pendingCount - 1);
+        }
+        if (this.hasPendingPlanApprovals(session, turnId)) {
+            return;
+        }
+        if (!session.activeTurn || session.activeTurn.settled || session.activeTurn.turnId !== turnId) {
+            return;
+        }
+        const deferredCompletion = session.pendingTurnCompletionsByTurnId.get(turnId);
+        if (!deferredCompletion) {
+            return;
+        }
+        session.pendingTurnCompletionsByTurnId.delete(turnId);
+        if (deferredCompletion.errorMessage) {
+            await this.emitTurnFailureMessage(session.sessionId, deferredCompletion.errorMessage);
+        }
+        this.settleTurn(session, deferredCompletion.stopReason);
+    }
+    async maybeRequestPlanApproval(session, item, turnId, completedPlanToolCall) {
+        if (item.type !== 'plan') {
+            return;
+        }
+        if (!isPlanLikeMode(session.defaults.collaborationMode)) {
+            return;
+        }
+        if (session.planApprovalRequestedByTurnId.has(turnId)) {
+            return;
+        }
+        const planText = this.extractPlanApprovalText(session, item);
+        if (!planText) {
+            return;
+        }
+        session.planApprovalRequestedByTurnId.add(turnId);
+        this.holdTurnUntilPlanApprovalResolves(session, turnId);
+        const approvalToolCallId = `${completedPlanToolCall.toolCallId}:exit-plan`;
+        const approvalInput = this.buildPlanApprovalInput(planText, item.id);
+        await this.emitSessionUpdate(session.sessionId, {
+            sessionUpdate: 'tool_call',
+            toolCallId: approvalToolCallId,
+            title: 'ExitPlanMode',
+            kind: 'switch_mode',
+            status: 'pending',
+            rawInput: approvalInput,
+        });
+        try {
+            const permissionResult = await this.connection.requestPermission({
+                sessionId: session.sessionId,
+                toolCall: {
+                    toolCallId: approvalToolCallId,
+                    title: 'ExitPlanMode',
+                    kind: 'switch_mode',
+                    status: 'pending',
+                    rawInput: approvalInput,
+                },
+                options: [
+                    {
+                        optionId: 'allow_once',
+                        name: 'Approve plan',
+                        kind: 'allow_once',
+                    },
+                    {
+                        optionId: 'reject_once',
+                        name: 'Request changes',
+                        kind: 'reject_once',
+                    },
+                ],
+            });
+            const selectedOptionId = permissionResult.outcome.outcome === 'selected' ? permissionResult.outcome.optionId : null;
+            const approved = this.isPlanApprovalSelected(selectedOptionId);
+            if (approved) {
+                const postApprovalMode = this.resolvePostPlanApprovalMode(session.defaults.collaborationMode);
+                if (postApprovalMode) {
+                    session.defaults.collaborationMode = postApprovalMode;
+                    await this.emitSessionUpdate(session.sessionId, {
+                        sessionUpdate: 'config_option_update',
+                        configOptions: this.buildConfigOptions(session),
+                    });
+                }
+            }
+            await this.emitSessionUpdate(session.sessionId, {
+                sessionUpdate: 'tool_call_update',
+                toolCallId: approvalToolCallId,
+                kind: 'switch_mode',
+                title: 'ExitPlanMode',
+                status: approved ? 'completed' : 'failed',
+                rawOutput: approved ? 'Plan approved' : 'Plan approval rejected',
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await this.emitSessionUpdate(session.sessionId, {
+                sessionUpdate: 'tool_call_update',
+                toolCallId: approvalToolCallId,
+                kind: 'switch_mode',
+                title: 'ExitPlanMode',
+                status: 'failed',
+                rawOutput: `Plan approval failed: ${message}`,
+            });
+        }
+        finally {
+            await this.releaseTurnHoldForPlanApproval(session, turnId);
+        }
+    }
+    extractLocations(item) {
+        if (!isRecord(item) || item.type !== 'fileChange') {
+            return [];
+        }
+        const changes = item.changes;
+        if (!Array.isArray(changes)) {
+            return [];
+        }
+        const locations = [];
+        for (const change of changes) {
+            if (!isRecord(change)) {
+                continue;
+            }
+            const path = asString(change.path);
+            if (!path) {
+                continue;
+            }
+            locations.push({ path });
+        }
+        return locations;
+    }
+    buildToolCallState(session, item, turnId) {
+        const kindByType = {
+            commandExecution: 'execute',
+            fileChange: 'edit',
+            mcpToolCall: 'fetch',
+            webSearch: 'search',
+            plan: 'think',
+            reasoning: 'think',
+        };
+        const kind = kindByType[item.type];
+        if (!kind) {
+            return null;
+        }
+        let title = item.type;
+        if (item.type === 'commandExecution') {
+            const command = asString(item.command);
+            title = command ?? 'commandExecution';
+        }
+        else if (item.type === 'fileChange') {
+            title = 'fileChange';
+        }
+        else if (item.type === 'mcpToolCall') {
+            const server = asString(item.server) ?? 'mcp';
+            const tool = asString(item.tool) ?? 'tool';
+            title = `mcpToolCall:${server}/${tool}`;
+        }
+        else if (item.type === 'webSearch') {
+            const query = asString(item.query);
+            title = query ? `webSearch:${query}` : 'webSearch';
+        }
+        return {
+            toolCallId: createToolCallId(session.threadId, turnId, item.id),
+            kind,
+            title,
+        };
+    }
+    async handleCodexServerRequest(request) {
+        try {
+            const parsed = knownCodexServerRequestSchema.safeParse(request);
+            if (!parsed.success) {
+                this.codex.respondError(request.id, {
+                    code: -32_602,
+                    message: 'Unsupported codex server request payload',
+                });
+                return;
+            }
+            const typed = parsed.data;
+            const sessionId = this.sessionIdByThreadId.get(typed.params.threadId);
+            if (!sessionId) {
+                this.codex.respondError(typed.id, {
+                    code: -32_603,
+                    message: 'No ACP session mapped for this thread',
+                });
+                return;
+            }
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                this.codex.respondError(typed.id, {
+                    code: -32_603,
+                    message: 'No ACP session mapped for this thread',
+                });
+                return;
+            }
+            const existingTool = session.toolCallsByItemId.get(typed.params.itemId);
+            const toolCall = existingTool ??
+                this.buildApprovalToolCallState(session, typed.method, typed.params.itemId, typed.params.turnId, typed.params);
+            session.toolCallsByItemId.set(typed.params.itemId, toolCall);
+            if (!existingTool) {
+                await this.emitSessionUpdate(sessionId, {
+                    sessionUpdate: 'tool_call',
+                    toolCallId: toolCall.toolCallId,
+                    title: toolCall.title,
+                    kind: toolCall.kind,
+                    status: 'pending',
+                    rawInput: typed.params,
+                });
+            }
+            const questions = typed.method === 'item/tool/requestUserInput' ? typed.params.questions : [];
+            const permissionOptions = typed.method === 'item/tool/requestUserInput'
+                ? buildToolUserInputPermissionOptions(questions)
+                : [
+                    {
+                        optionId: 'allow_once',
+                        name: 'Allow once',
+                        kind: 'allow_once',
+                    },
+                    {
+                        optionId: 'reject_once',
+                        name: 'Reject',
+                        kind: 'reject_once',
+                    },
+                ];
+            const permissionResult = await this.connection.requestPermission({
+                sessionId,
+                toolCall: {
+                    toolCallId: toolCall.toolCallId,
+                    title: toolCall.title,
+                    kind: toolCall.kind,
+                    status: 'pending',
+                    rawInput: typed.params,
+                },
+                options: permissionOptions,
+            });
+            await this.respondToCodexPermissionRequest({
+                request: typed,
+                permission: permissionResult,
+                session,
+                toolCallId: toolCall.toolCallId,
+                questions,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.codex.respondError(request.id, {
+                code: -32_600,
+                message: 'Failed to process codex approval request',
+                data: { error: message },
+            });
+        }
+    }
+    buildApprovalToolCallState(session, method, itemId, turnId, params) {
+        if (method === 'item/commandExecution/requestApproval') {
+            const command = asString(params.command);
+            return {
+                toolCallId: createToolCallId(session.threadId, turnId, itemId),
+                title: command ? command : 'commandExecution',
+                kind: 'execute',
+            };
+        }
+        if (method === 'item/fileChange/requestApproval') {
+            return {
+                toolCallId: createToolCallId(session.threadId, turnId, itemId),
+                title: 'fileChange',
+                kind: 'edit',
+            };
+        }
+        return {
+            toolCallId: createToolCallId(session.threadId, turnId, itemId),
+            title: 'item/tool/requestUserInput',
+            kind: 'other',
+        };
+    }
+    async respondToCodexPermissionRequest(params) {
+        const selected = params.permission.outcome.outcome === 'selected' ? params.permission.outcome.optionId : null;
+        const allow = selected === 'allow_once';
+        if (params.request.method === 'item/tool/requestUserInput') {
+            const rejected = selected === null || selected === 'reject_once';
+            let answers;
+            try {
+                answers = buildToolUserInputAnswers({
+                    questions: params.questions,
+                    permission: params.permission,
+                    selectedOptionId: selected,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.codex.respondError(params.request.id, {
+                    code: -32_602,
+                    message: 'Failed to map requestUserInput answers',
+                    data: { error: message },
+                });
+                await this.emitSessionUpdate(params.session.sessionId, {
+                    sessionUpdate: 'tool_call_update',
+                    toolCallId: params.toolCallId,
+                    status: 'failed',
+                    rawOutput: { error: message },
+                });
+                return;
+            }
+            this.codex.respondSuccess(params.request.id, {
+                answers,
+            });
+            await this.emitSessionUpdate(params.session.sessionId, {
+                sessionUpdate: 'tool_call_update',
+                toolCallId: params.toolCallId,
+                status: rejected ? 'failed' : 'completed',
+                rawOutput: rejected ? { outcome: 'rejected' } : { answers },
+            });
+            return;
+        }
+        this.codex.respondSuccess(params.request.id, {
+            decision: allow ? 'accept' : 'decline',
+        });
+        await this.emitSessionUpdate(params.session.sessionId, {
+            sessionUpdate: 'tool_call_update',
+            toolCallId: params.toolCallId,
+            status: allow ? 'in_progress' : 'failed',
+            rawOutput: { decision: allow ? 'accept' : 'decline' },
+        });
+    }
+    settleTurn(session, stopReason) {
+        if (!session.activeTurn || session.activeTurn.settled) {
+            return;
+        }
+        session.activeTurn.settled = true;
+        session.activeTurn.resolve(stopReason);
+        session.activeTurn = null;
+        session.planTextByItemId.clear();
+        session.planApprovalRequestedByTurnId.clear();
+        session.pendingPlanApprovalsByTurnId.clear();
+        session.toolCallsByItemId.clear();
+        session.pendingTurnCompletionsByTurnId.clear();
+    }
+    async emitSessionUpdate(sessionId, update) {
+        try {
+            await this.connection.sessionUpdate({ sessionId, update });
+        }
+        catch {
+        }
+    }
+}
+export function runCodexAppServerAcpAdapter() {
+    const output = Writable.toWeb(process.stdout);
+    const input = Readable.toWeb(process.stdin);
+    const stream = ndJsonStream(output, input);
+    new AgentSideConnection((connection) => new CodexAppServerAcpAdapter(connection), stream);
+}
+//# sourceMappingURL=codex-app-server-acp-adapter.js.map