factory-factory 0.3.8 → 0.3.10

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

@@ -0,0 +1,942 @@
+import { Readable, Writable } from 'node:stream';
+import { AgentSideConnection, ndJsonStream, PROTOCOL_VERSION, RequestError, } from '@agentclientprotocol/sdk';
+import { asString, dedupeStrings, extractLocations, isRecord, resolveToolCallId, } from './acp-adapter-utils.js';
+import { CodexRequestError, CodexRpcClient } from './codex-rpc-client.js';
+import { turnStartResponseSchema } from './codex-zod.js';
+import { resolveCommandDisplay } from './command-metadata.js';
+import { handleCodexServerPermissionRequest } from './protocol-permission-handler.js';
+import { attachCloseWatcherWithRetry } from './retry-logic.js';
+import { buildConfigOptions, createSandboxPolicyFromMode, getCollaborationModeValues, getExecutionPresets, isKnownModel, isReasoningEffortSupportedForModel, resolveCollaborationModeLabel, resolveDefaultCollaborationMode, resolveDefaultModel, resolveReasoningEffortForModel, resolveSandboxPolicy, resolveSessionModel, resolveTurnCollaborationMode, } from './session-config-resolver.js';
+import { loadCollaborationModes, loadConfigRequirements, loadModelCatalog, negotiateNewSession, negotiateSessionResume, } from './session-negotiation.js';
+import { CodexAdapterSessionStateContainer } from './session-state-container.js';
+import { ShapeDriftReporter } from './shape-drift-reporter.js';
+import { CodexStreamEventHandler } from './stream-event-handler.js';
+const PENDING_TURN_ID = '__pending_turn__';
+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',
+];
+const REASONING_TEXT_MAX_DEPTH = 8;
+const REASONING_TEXT_PREFERRED_KEYS = [
+    'summary',
+    'summaryText',
+    'text',
+    'delta',
+    'message',
+    'content',
+    'reasoning',
+];
+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 collectReasoningText(values, value, depth = 0) {
+    if (depth > REASONING_TEXT_MAX_DEPTH) {
+        return;
+    }
+    if (typeof value === 'string') {
+        if (value.trim().length > 0) {
+            values.push(value);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectReasoningText(values, entry, depth + 1);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const key of REASONING_TEXT_PREFERRED_KEYS) {
+        collectReasoningText(values, value[key], depth + 1);
+    }
+}
+function extractReasoningTextLocal(value) {
+    const collected = [];
+    collectReasoningText(collected, value);
+    if (collected.length === 0) {
+        return null;
+    }
+    return dedupeStrings(collected).join('\n\n');
+}
+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 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);
+}
+export class CodexAppServerAcpAdapter {
+    connection;
+    codex;
+    stateContainer = new CodexAdapterSessionStateContainer();
+    modelCatalog = [];
+    allowedApprovalPolicies = [];
+    allowedSandboxModes = [];
+    collaborationModes = [];
+    shapeDriftReporter;
+    streamEventHandler;
+    get sessions() {
+        return this.stateContainer.sessions;
+    }
+    get sessionIdByThreadId() {
+        return this.stateContainer.sessionIdByThreadId;
+    }
+    get mcpServersByThreadId() {
+        return this.stateContainer.mcpServersByThreadId;
+    }
+    get appliedMcpServerConfigJson() {
+        return this.stateContainer.appliedMcpServerConfigJson;
+    }
+    set appliedMcpServerConfigJson(value) {
+        this.stateContainer.appliedMcpServerConfigJson = value;
+    }
+    constructor(connection, codexClient, options) {
+        this.connection = connection;
+        this.shapeDriftReporter = new ShapeDriftReporter(options?.shapeDriftWarn);
+        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.streamEventHandler = new CodexStreamEventHandler({
+            codex: this.codex,
+            sessionIdByThreadId: this.sessionIdByThreadId,
+            sessions: this.sessions,
+            requireSession: (sessionId) => this.requireSession(sessionId),
+            emitSessionUpdate: (sessionId, update) => this.emitSessionUpdate(sessionId, update),
+            reportShapeDrift: (event, details) => this.reportShapeDrift(event, details),
+            buildToolCallState: (session, item, turnId) => this.buildToolCallState(session, item, turnId),
+            emitReasoningThoughtChunkFromItem: (sessionId, item) => this.emitReasoningThoughtChunkFromItem(sessionId, item),
+            shouldHoldTurnForPlanApproval: (session, item, turnId) => this.shouldHoldTurnForPlanApproval(session, item, turnId),
+            holdTurnUntilPlanApprovalResolves: (session, turnId) => this.holdTurnUntilPlanApprovalResolves(session, turnId),
+            maybeRequestPlanApproval: (session, item, turnId, completedPlanToolCall) => this.maybeRequestPlanApproval(session, item, turnId, completedPlanToolCall),
+            hasPendingPlanApprovals: (session, turnId) => this.hasPendingPlanApprovals(session, turnId),
+            settleTurn: (session, stopReason) => this.settleTurn(session, stopReason),
+            emitTurnFailureMessage: (sessionId, errorMessage) => this.emitTurnFailureMessage(sessionId, errorMessage),
+        });
+        this.monitorConnectionClose();
+    }
+    monitorConnectionClose() {
+        attachCloseWatcherWithRetry({
+            getClosed: () => this.connection.closed,
+            onClose: async () => this.codex.stop(),
+            onAttachRetryLimitReached: (maxAttempts) => {
+                process.stderr.write(`[codex-app-server-acp] failed to attach close watcher after ${maxAttempts} attempts\n`);
+                void this.codex.stop();
+            },
+        });
+    }
+    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 loadConfigRequirements({ codex: this.codex });
+        this.allowedApprovalPolicies = configRequirements.allowedApprovalPolicies;
+        this.allowedSandboxModes = configRequirements.allowedSandboxModes;
+        this.collaborationModes = await loadCollaborationModes({ codex: this.codex });
+        this.modelCatalog = await loadModelCatalog({ codex: this.codex });
+        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 negotiatedSession = await negotiateNewSession({
+            codex: this.codex,
+            cwd: params.cwd,
+            resolveDefaultModel: () => this.resolveDefaultModel(),
+            resolveSessionModel: (model, fallbackModel) => this.resolveSessionModel(model, fallbackModel),
+            resolveSandboxPolicy: (sandbox, cwd) => this.resolveSandboxPolicy(sandbox, cwd),
+            resolveReasoningEffortForModel: (modelId, candidateReasoningEffort) => this.resolveReasoningEffortForModel(modelId, candidateReasoningEffort),
+            resolveDefaultCollaborationMode: () => this.resolveDefaultCollaborationMode(),
+        });
+        const session = this.stateContainer.createSession(negotiatedSession);
+        this.stateContainer.registerSession(session);
+        try {
+            await this.applyMcpServers(session.threadId, params.mcpServers);
+        }
+        catch (error) {
+            this.stateContainer.deleteSession(negotiatedSession.sessionId);
+            throw error;
+        }
+        return {
+            sessionId: negotiatedSession.sessionId,
+            configOptions: this.buildConfigOptions(session),
+        };
+    }
+    async loadSession(params) {
+        const negotiatedSession = await negotiateSessionResume({
+            codex: this.codex,
+            sessionId: params.sessionId,
+            cwd: params.cwd,
+            resolveDefaultModel: () => this.resolveDefaultModel(),
+            resolveSessionModel: (model, fallbackModel) => this.resolveSessionModel(model, fallbackModel),
+            resolveSandboxPolicy: (sandbox, cwd) => this.resolveSandboxPolicy(sandbox, cwd),
+            resolveReasoningEffortForModel: (modelId, candidateReasoningEffort) => this.resolveReasoningEffortForModel(modelId, candidateReasoningEffort),
+            resolveDefaultCollaborationMode: () => this.resolveDefaultCollaborationMode(),
+        });
+        const session = this.stateContainer.createSession(negotiatedSession);
+        this.stateContainer.registerSession(session);
+        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.stateContainer.deleteSession(session.sessionId);
+            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 (!isKnownModel(this.modelCatalog, 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': {
+                if (!isReasoningEffortSupportedForModel(this.modelCatalog, session.defaults.model, 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() {
+        return resolveDefaultModel(this.modelCatalog);
+    }
+    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) {
+        return buildConfigOptions(session, this.modelCatalog, this.collaborationModes, this.allowedApprovalPolicies, this.allowedSandboxModes);
+    }
+    resolveSessionModel(model, fallbackModel) {
+        return resolveSessionModel(model, fallbackModel);
+    }
+    resolveSandboxPolicy(sandbox, cwd) {
+        return resolveSandboxPolicy(sandbox, cwd);
+    }
+    resolveDefaultCollaborationMode() {
+        return resolveDefaultCollaborationMode(this.collaborationModes);
+    }
+    resolveTurnCollaborationMode(session) {
+        return resolveTurnCollaborationMode(this.collaborationModes, session);
+    }
+    resolveReasoningEffortForModel(modelId, candidateReasoningEffort) {
+        return resolveReasoningEffortForModel(this.modelCatalog, modelId, candidateReasoningEffort);
+    }
+    getCollaborationModeValues(currentMode) {
+        return getCollaborationModeValues(this.collaborationModes, currentMode);
+    }
+    getExecutionPresets(session) {
+        return getExecutionPresets(session, this.allowedApprovalPolicies, this.allowedSandboxModes);
+    }
+    requireSession(sessionId) {
+        const session = this.stateContainer.getSession(sessionId);
+        if (!session) {
+            throw RequestError.invalidParams({ sessionId });
+        }
+        return session;
+    }
+    async replayThreadHistory(sessionId, threadId) {
+        await this.streamEventHandler.replayThreadHistory(sessionId, threadId);
+    }
+    async handleCodexNotification(method, params) {
+        await this.streamEventHandler.handleCodexNotification({ method, params });
+    }
+    async emitReasoningThoughtChunkFromItem(sessionId, item) {
+        const text = extractReasoningTextLocal(item);
+        if (!text) {
+            return;
+        }
+        await this.emitSessionUpdate(sessionId, {
+            sessionUpdate: 'agent_thought_chunk',
+            content: { type: 'text', text },
+        });
+    }
+    shouldHoldTurnForPlanApproval(session, item, turnId) {
+        return (item.type === 'plan' &&
+            isPlanLikeMode(session.defaults.collaborationMode) &&
+            !session.planApprovalRequestedByTurnId.has(turnId) &&
+            this.extractPlanApprovalText(session, item) !== null);
+    }
+    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;
+    }
+    getPlanExitModePriority(modeId) {
+        const normalized = modeId.toLowerCase();
+        const index = PLAN_EXIT_MODE_PREFERENCE.findIndex((preferred) => preferred.toLowerCase() === normalized);
+        return index >= 0 ? index : PLAN_EXIT_MODE_PREFERENCE.length;
+    }
+    comparePlanExitModePreference(left, right) {
+        const priorityDiff = this.getPlanExitModePriority(left) - this.getPlanExitModePriority(right);
+        if (priorityDiff !== 0) {
+            return priorityDiff;
+        }
+        return left.localeCompare(right);
+    }
+    resolveCollaborationModeLabel(modeId) {
+        return resolveCollaborationModeLabel(this.collaborationModes, modeId);
+    }
+    buildPlanApprovalOptions(session) {
+        const currentMode = session.defaults.collaborationMode;
+        const availableModes = this.getCollaborationModeValues(currentMode);
+        const nonPlanModes = availableModes
+            .filter((modeId) => !isPlanLikeMode(modeId))
+            .sort((left, right) => this.comparePlanExitModePreference(left, right));
+        const approvableModeIds = new Set(nonPlanModes);
+        const options = nonPlanModes.map((modeId) => ({
+            optionId: modeId,
+            name: `Approve and switch to ${this.resolveCollaborationModeLabel(modeId)}`,
+            kind: 'allow_once',
+        }));
+        options.push({
+            optionId: currentMode,
+            name: 'Keep planning',
+            kind: 'reject_once',
+        });
+        return { options, approvableModeIds };
+    }
+    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 { options: planApprovalOptions, approvableModeIds } = this.buildPlanApprovalOptions(session);
+            if (approvableModeIds.size === 0) {
+                await this.emitSessionUpdate(session.sessionId, {
+                    sessionUpdate: 'tool_call_update',
+                    toolCallId: approvalToolCallId,
+                    kind: 'switch_mode',
+                    title: 'ExitPlanMode',
+                    status: 'failed',
+                    rawOutput: 'Plan proposed, but no non-plan collaboration mode is available.',
+                });
+                return;
+            }
+            const permissionResult = await this.connection.requestPermission({
+                sessionId: session.sessionId,
+                toolCall: {
+                    toolCallId: approvalToolCallId,
+                    title: 'ExitPlanMode',
+                    kind: 'switch_mode',
+                    status: 'pending',
+                    rawInput: approvalInput,
+                },
+                options: planApprovalOptions,
+            });
+            const selectedMode = permissionResult.outcome.outcome === 'selected' &&
+                approvableModeIds.has(permissionResult.outcome.optionId)
+                ? permissionResult.outcome.optionId
+                : null;
+            const approved = selectedMode !== null;
+            if (selectedMode && session.defaults.collaborationMode !== selectedMode) {
+                session.defaults.collaborationMode = selectedMode;
+                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);
+        }
+    }
+    buildToolCallState(session, item, _turnId) {
+        const kindByType = {
+            commandExecution: 'execute',
+            fileChange: 'edit',
+            mcpToolCall: 'fetch',
+            webSearch: 'search',
+            plan: 'think',
+        };
+        const kind = kindByType[item.type];
+        if (!kind) {
+            return null;
+        }
+        let title = item.type;
+        let kindToEmit = kind;
+        let locations = [];
+        if (item.type === 'commandExecution') {
+            const command = asString(item.command);
+            const cwd = asString(item.cwd) ?? session.cwd;
+            const parsed = resolveCommandDisplay({ command, cwd });
+            title = parsed.title;
+            kindToEmit = parsed.kind;
+            locations = parsed.locations;
+        }
+        else if (item.type === 'fileChange') {
+            title = 'fileChange';
+            locations = extractLocations(item);
+        }
+        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: resolveToolCallId({
+                itemId: item.id,
+                source: item,
+            }),
+            kind: kindToEmit,
+            title,
+            locations,
+        };
+    }
+    async handleCodexServerRequest(request) {
+        await handleCodexServerPermissionRequest({
+            request,
+            sessionIdByThreadId: this.sessionIdByThreadId,
+            sessions: this.sessions,
+            connection: this.connection,
+            codex: this.codex,
+            emitSessionUpdate: (sessionId, update) => this.emitSessionUpdate(sessionId, update),
+            reportShapeDrift: (event, details) => this.reportShapeDrift(event, details),
+        });
+    }
+    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.syntheticallyCompletedToolItemIds.clear();
+        session.reasoningDeltaItemIds.clear();
+        session.pendingTurnCompletionsByTurnId.clear();
+    }
+    reportShapeDrift(event, details) {
+        this.shapeDriftReporter.report(event, details);
+    }
+    async emitSessionUpdate(sessionId, update) {
+        try {
+            await this.connection.sessionUpdate({ sessionId, update });
+        }
+        catch {
+        }
+    }
+}
+export function runCodexAppServerAcpAdapter(options) {
+    const output = Writable.toWeb(process.stdout);
+    const input = Readable.toWeb(process.stdin);
+    const stream = ndJsonStream(output, input);
+    new AgentSideConnection((connection) => new CodexAppServerAcpAdapter(connection, undefined, options), stream);
+}
+//# sourceMappingURL=codex-app-server-acp-adapter.js.map