factory-factory 0.3.8 → 0.3.9

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

@@ -2,127 +2,16 @@ 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 { collaborationModeListResponseSchema, configRequirementsReadResponseSchema, modelListResponseSchema, threadResumeResponseSchema, threadStartResponseSchema, turnStartResponseSchema, } from './codex-zod.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__';
-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'];
-const SHAPE_DRIFT_DETAILS_LIMIT = 700;
-function toShapeDriftDetails(value) {
-    try {
-        const text = JSON.stringify(value);
-        if (typeof text !== 'string') {
-            return '[unserializable]';
-        }
-        return text.length > SHAPE_DRIFT_DETAILS_LIMIT
-            ? `${text.slice(0, SHAPE_DRIFT_DETAILS_LIMIT)}...`
-            : text;
-    }
-    catch {
-        return '[unserializable]';
-    }
-}
-function isNonEmptyString(value) {
-    return typeof value === 'string' && value.trim().length > 0;
-}
-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 isPlanLikeMode(mode) {
     return /plan/i.test(mode);
 }
@@ -284,112 +173,34 @@ function parseTextFromPromptBlock(block) {
     }
     return JSON.stringify(block);
 }
-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();
+    stateContainer = new CodexAdapterSessionStateContainer();
     modelCatalog = [];
     allowedApprovalPolicies = [];
     allowedSandboxModes = [];
     collaborationModes = [];
-    mcpServersByThreadId = new Map();
-    appliedMcpServerConfigJson = '{}';
-    shapeDriftCounts = new Map();
+    shapeDriftReporter;
     streamEventHandler;
-    constructor(connection, codexClient) {
+    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({
@@ -434,28 +245,14 @@ export class CodexAppServerAcpAdapter {
         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);
+        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();
@@ -469,11 +266,11 @@ export class CodexAppServerAcpAdapter {
             },
         });
         this.codex.notify('initialized');
-        const configRequirements = await this.loadConfigRequirements();
+        const configRequirements = await loadConfigRequirements({ codex: this.codex });
         this.allowedApprovalPolicies = configRequirements.allowedApprovalPolicies;
         this.allowedSandboxModes = configRequirements.allowedSandboxModes;
-        this.collaborationModes = await this.loadCollaborationModes();
-        this.modelCatalog = await this.loadModelCatalog();
+        this.collaborationModes = await loadCollaborationModes({ codex: this.codex });
+        this.modelCatalog = await loadModelCatalog({ codex: this.codex });
         return {
             protocolVersion: PROTOCOL_VERSION,
             agentInfo: {
@@ -491,91 +288,42 @@ export class CodexAppServerAcpAdapter {
         };
     }
     async newSession(params) {
-        const defaultModel = this.resolveDefaultModel();
-        const responseRaw = await this.codex.request('thread/start', {
+        const negotiatedSession = await negotiateNewSession({
+            codex: this.codex,
             cwd: params.cwd,
-            model: defaultModel,
+            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 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(),
-            syntheticallyCompletedToolItemIds: new Set(),
-            reasoningDeltaItemIds: new Set(),
-            planTextByItemId: new Map(),
-            planApprovalRequestedByTurnId: new Set(),
-            pendingPlanApprovalsByTurnId: new Map(),
-            pendingTurnCompletionsByTurnId: new Map(),
-            commandApprovalScopes: new Set(),
-            replayedTurnItemKeys: new Set(),
-        };
-        this.sessions.set(sessionId, session);
-        this.sessionIdByThreadId.set(session.threadId, sessionId);
+        const session = this.stateContainer.createSession(negotiatedSession);
+        this.stateContainer.registerSession(session);
         try {
             await this.applyMcpServers(session.threadId, params.mcpServers);
         }
         catch (error) {
-            this.sessions.delete(sessionId);
-            this.sessionIdByThreadId.delete(session.threadId);
+            this.stateContainer.deleteSession(negotiatedSession.sessionId);
             throw error;
         }
         return {
-            sessionId,
+            sessionId: negotiatedSession.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 = {
+        const negotiatedSession = await negotiateSessionResume({
+            codex: this.codex,
             sessionId: params.sessionId,
-            threadId: response.thread.id,
             cwd: params.cwd,
-            defaults: {
-                model,
-                approvalPolicy,
-                sandboxPolicy,
-                reasoningEffort,
-                collaborationMode,
-            },
-            activeTurn: null,
-            toolCallsByItemId: new Map(),
-            syntheticallyCompletedToolItemIds: new Set(),
-            reasoningDeltaItemIds: new Set(),
-            planTextByItemId: new Map(),
-            planApprovalRequestedByTurnId: new Set(),
-            pendingPlanApprovalsByTurnId: new Map(),
-            pendingTurnCompletionsByTurnId: new Map(),
-            commandApprovalScopes: new Set(),
-            replayedTurnItemKeys: new Set(),
-        };
-        this.sessions.set(session.sessionId, session);
-        this.sessionIdByThreadId.set(session.threadId, session.sessionId);
+            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);
@@ -586,8 +334,7 @@ export class CodexAppServerAcpAdapter {
             }
             catch {
             }
-            this.sessions.delete(session.sessionId);
-            this.sessionIdByThreadId.delete(session.threadId);
+            this.stateContainer.deleteSession(session.sessionId);
             throw error;
         }
         return {
@@ -639,7 +386,7 @@ export class CodexAppServerAcpAdapter {
                 break;
             }
             case 'model': {
-                if (!this.modelCatalog.some((model) => model.id === params.value)) {
+                if (!isKnownModel(this.modelCatalog, params.value)) {
                     throw RequestError.invalidParams({
                         configId: params.configId,
                         value: params.value,
@@ -651,12 +398,7 @@ export class CodexAppServerAcpAdapter {
             }
             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)) {
+                if (!isReasoningEffortSupportedForModel(this.modelCatalog, session.defaults.model, params.value)) {
                     throw RequestError.invalidParams({
                         configId: params.configId,
                         value: params.value,
@@ -806,15 +548,7 @@ export class CodexAppServerAcpAdapter {
         }
     }
     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');
+        return resolveDefaultModel(this.modelCatalog);
     }
     buildMergedMcpServersConfig() {
         const merged = {};
@@ -887,256 +621,36 @@ export class CodexAppServerAcpAdapter {
         }
     }
     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;
+        return buildConfigOptions(session, this.modelCatalog, this.collaborationModes, this.allowedApprovalPolicies, this.allowedSandboxModes);
     }
     resolveSessionModel(model, fallbackModel) {
-        return isNonEmptyString(model) ? model : fallbackModel;
+        return resolveSessionModel(model, fallbackModel);
     }
     resolveSandboxPolicy(sandbox, cwd) {
-        return isRecord(sandbox) ? sandbox : createWorkspaceWriteSandboxPolicy(cwd);
+        return resolveSandboxPolicy(sandbox, 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;
+        return resolveDefaultCollaborationMode(this.collaborationModes);
     }
     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,
-            },
-        };
+        return resolveTurnCollaborationMode(this.collaborationModes, session);
     }
     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;
+        return resolveReasoningEffortForModel(this.modelCatalog, modelId, candidateReasoningEffort);
     }
     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');
+        return getCollaborationModeValues(this.collaborationModes, currentMode);
     }
     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;
+        return getExecutionPresets(session, this.allowedApprovalPolicies, this.allowedSandboxModes);
     }
     requireSession(sessionId) {
-        const session = this.sessions.get(sessionId);
+        const session = this.stateContainer.getSession(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) {
         await this.streamEventHandler.replayThreadHistory(sessionId, threadId);
     }
@@ -1196,11 +710,7 @@ export class CodexAppServerAcpAdapter {
         return left.localeCompare(right);
     }
     resolveCollaborationModeLabel(modeId) {
-        const entry = this.collaborationModes.find((candidate) => candidate.mode === modeId);
-        if (entry?.name) {
-            return entry.name;
-        }
-        return sanitizeModeName(modeId);
+        return resolveCollaborationModeLabel(this.collaborationModes, modeId);
     }
     buildPlanApprovalOptions(session) {
         const currentMode = session.defaults.collaborationMode;
@@ -1413,11 +923,7 @@ export class CodexAppServerAcpAdapter {
         session.pendingTurnCompletionsByTurnId.clear();
     }
     reportShapeDrift(event, details) {
-        const count = (this.shapeDriftCounts.get(event) ?? 0) + 1;
-        this.shapeDriftCounts.set(event, count);
-        const includeDetails = details !== undefined && (count <= 5 || count % 50 === 0);
-        const detailsSuffix = includeDetails ? ` details=${toShapeDriftDetails(details)}` : '';
-        process.stderr.write(`[codex-app-server-acp] shape-drift event=${event} count=${count}${detailsSuffix}\n`);
+        this.shapeDriftReporter.report(event, details);
     }
     async emitSessionUpdate(sessionId, update) {
         try {
@@ -1427,10 +933,10 @@ export class CodexAppServerAcpAdapter {
         }
     }
 }
-export function runCodexAppServerAcpAdapter() {
+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), stream);
+    new AgentSideConnection((connection) => new CodexAppServerAcpAdapter(connection, undefined, options), stream);
 }
 //# sourceMappingURL=codex-app-server-acp-adapter.js.map