factory-factory 0.3.6 → 0.3.8

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

@@ -1,16 +1,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, knownCodexNotificationSchema, knownCodexServerRequestSchema, modelListResponseSchema, threadReadResponseSchema, threadResumeResponseSchema, threadStartResponseSchema, turnStartResponseSchema, } from './codex-zod.js';
+import { collaborationModeListResponseSchema, configRequirementsReadResponseSchema, modelListResponseSchema, threadResumeResponseSchema, threadStartResponseSchema, turnStartResponseSchema, } from './codex-zod.js';
+import { resolveCommandDisplay } from './command-metadata.js';
+import { handleCodexServerPermissionRequest } from './protocol-permission-handler.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;
-const COMMAND_EXECUTION_SESSION_HANDOFF_LINE_PATTERN = /^process running with session id(?:\s*[:#-]?\s*[a-z0-9_-]+)?\.?$/i;
-function toTurnItemKey(turnId, itemId) {
-    return `${turnId}:${itemId}`;
-}
 function toShapeDriftDetails(value) {
     try {
         const text = JSON.stringify(value);
@@ -28,9 +28,6 @@ function toShapeDriftDetails(value) {
 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(/[-_]/)
@@ -126,22 +123,6 @@ function toSessionId(threadId) {
 function toThreadId(sessionId) {
     return sessionId.startsWith('sess_') ? sessionId.slice('sess_'.length) : sessionId;
 }
-function extractToolCallIdFromUnknown(value) {
-    if (!isRecord(value)) {
-        return null;
-    }
-    return asString(value.callId) ?? asString(value.call_id) ?? null;
-}
-function resolveToolCallId(params) {
-    return extractToolCallIdFromUnknown(params.source) ?? params.itemId;
-}
-function isCommandExecutionSessionHandoffOutput(output) {
-    const trimmedOutput = output.trim();
-    if (trimmedOutput.length === 0 || /[\r\n]/.test(trimmedOutput)) {
-        return false;
-    }
-    return COMMAND_EXECUTION_SESSION_HANDOFF_LINE_PATTERN.test(trimmedOutput);
-}
 function isPlanLikeMode(mode) {
     return /plan/i.test(mode);
 }
@@ -280,393 +261,6 @@ function toCodexMcpConfigMap(mcpServers) {
     }
     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 trimOptionalQuotes(token) {
-    if (token.length >= 2 && token.startsWith('"') && token.endsWith('"')) {
-        return { text: token.slice(1, -1), quote: '"' };
-    }
-    if (token.length >= 2 && token.startsWith("'") && token.endsWith("'")) {
-        return { text: token.slice(1, -1), quote: "'" };
-    }
-    return { text: token, quote: null };
-}
-function unescapeCommandToken(token, quote) {
-    if (quote === "'") {
-        return token.replace(/\\'/g, "'").replace(/\\\\/g, '\\');
-    }
-    return token.replace(/\\(["'\\\s|&;])/g, '$1');
-}
-function sanitizeCommandToken(token) {
-    const trimmed = token.trim();
-    const { text, quote } = trimOptionalQuotes(trimmed);
-    return unescapeCommandToken(text, quote).trim();
-}
-function tokenizeCommand(command) {
-    return (command.match(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+/g) ?? [])
-        .map((token) => sanitizeCommandToken(token))
-        .filter((token) => token.length > 0);
-}
-function commandName(token) {
-    const unix = token.split('/').at(-1) ?? token;
-    return (unix.split('\\').at(-1) ?? unix).toLowerCase();
-}
-function isChainSeparatorChar(char) {
-    return char === ';' || char === '\n' || char === '|' || char === '&';
-}
-function readChainSeparatorLength(command, index) {
-    const char = command[index];
-    if (!(char && isChainSeparatorChar(char))) {
-        return 0;
-    }
-    const next = command[index + 1];
-    if ((char === '|' || char === '&') && next === char) {
-        return 2;
-    }
-    return 1;
-}
-function isLikelyPathToken(token) {
-    if (!token || token.startsWith('-')) {
-        return false;
-    }
-    if (token.startsWith('./') ||
-        token.startsWith('../') ||
-        token.startsWith('/') ||
-        token.startsWith('~')) {
-        return true;
-    }
-    return (token.includes('/') ||
-        token.includes('\\') ||
-        token.endsWith('.') ||
-        /\.[a-z0-9]+$/i.test(token));
-}
-function normalizeLocationPath(pathToken, cwd) {
-    if (pathToken.startsWith('/')) {
-        return pathToken;
-    }
-    if (pathToken.startsWith('~')) {
-        return pathToken;
-    }
-    const base = cwd.endsWith('/') ? cwd.slice(0, -1) : cwd;
-    return `${base}/${pathToken}`;
-}
-const READ_COMMANDS = new Set(['cat', 'head', 'tail', 'less', 'more']);
-const LIST_OR_FIND_COMMANDS = new Set(['ls', 'tree', 'find', 'fd']);
-const GREP_LIKE_COMMANDS = new Set(['rg', 'ripgrep', 'grep', 'ag']);
-const SHELL_META_COMMANDS = new Set(['cd', 'export', 'set', 'unset', 'alias', 'unalias', 'source']);
-function pushCommandChainPart(state) {
-    const trimmed = state.current.trim();
-    if (trimmed.length > 0) {
-        state.parts.push(trimmed);
-    }
-    state.current = '';
-}
-function consumeEscapedCommandChar(state, char) {
-    if (!state.escaped) {
-        return false;
-    }
-    state.current += char;
-    state.escaped = false;
-    return true;
-}
-function consumeEscapeInitiator(state, char) {
-    if (!(char === '\\' && state.quote !== "'")) {
-        return false;
-    }
-    state.current += char;
-    state.escaped = true;
-    return true;
-}
-function hasOddTrailingBackslashes(value) {
-    let count = 0;
-    for (let index = value.length - 1; index >= 0; index -= 1) {
-        if (value[index] !== '\\') {
-            break;
-        }
-        count += 1;
-    }
-    return count % 2 === 1;
-}
-function consumeQuotedCommandChar(state, char) {
-    if (!state.quote) {
-        return false;
-    }
-    const escapedSingleQuote = state.quote === "'" && char === "'" && hasOddTrailingBackslashes(state.current);
-    state.current += char;
-    if (char === state.quote && !escapedSingleQuote) {
-        state.quote = null;
-    }
-    return true;
-}
-function consumeQuoteStart(state, char) {
-    if (!(char === '"' || char === "'")) {
-        return false;
-    }
-    state.quote = char;
-    state.current += char;
-    return true;
-}
-function consumeCommandChainSeparator(state, command, index) {
-    const separatorLength = readChainSeparatorLength(command, index);
-    if (separatorLength <= 0) {
-        return 0;
-    }
-    pushCommandChainPart(state);
-    return separatorLength;
-}
-function splitCommandChain(command) {
-    const state = {
-        parts: [],
-        current: '',
-        quote: null,
-        escaped: false,
-    };
-    for (let index = 0; index < command.length; index += 1) {
-        const char = command[index];
-        if (!char) {
-            continue;
-        }
-        if (consumeEscapedCommandChar(state, char)) {
-            continue;
-        }
-        if (consumeEscapeInitiator(state, char)) {
-            continue;
-        }
-        if (consumeQuotedCommandChar(state, char)) {
-            continue;
-        }
-        if (consumeQuoteStart(state, char)) {
-            continue;
-        }
-        const consumedSeparatorLength = consumeCommandChainSeparator(state, command, index);
-        if (consumedSeparatorLength > 0) {
-            index += consumedSeparatorLength - 1;
-            continue;
-        }
-        state.current += char;
-    }
-    pushCommandChainPart(state);
-    return state.parts;
-}
-function buildCommandDisplayContexts(rawCommand, cwd) {
-    const command = rawCommand?.trim();
-    if (!command) {
-        return [];
-    }
-    const contexts = [];
-    const segments = splitCommandChain(command);
-    for (const segment of segments) {
-        const tokens = tokenizeCommand(segment);
-        if (tokens.length === 0) {
-            continue;
-        }
-        const [firstToken] = tokens;
-        if (!firstToken) {
-            continue;
-        }
-        const firstCommand = commandName(firstToken);
-        const nonFlagArgs = tokens.slice(1).filter((token) => !token.startsWith('-'));
-        const pathArg = nonFlagArgs.find(isLikelyPathToken) ?? null;
-        const commandPath = pathArg ? normalizeLocationPath(pathArg, cwd) : null;
-        const locations = commandPath ? [{ path: commandPath }] : [];
-        contexts.push({
-            command: segment,
-            firstCommand,
-            nonFlagArgs,
-            pathArg,
-            cwd,
-            locations,
-            isShellMeta: SHELL_META_COMMANDS.has(firstCommand),
-        });
-    }
-    return contexts;
-}
-function chooseActionableCommandContexts(contexts) {
-    const actionable = contexts.filter((context) => !context.isShellMeta);
-    return actionable.length > 0 ? actionable : contexts;
-}
-function selectCombinedCommandKind(displays) {
-    const firstNonExecute = displays.find((display) => display.kind !== 'execute');
-    return firstNonExecute?.kind ?? 'execute';
-}
-function resolveCommandDisplay(params) {
-    const contexts = chooseActionableCommandContexts(buildCommandDisplayContexts(params.command, params.cwd));
-    if (contexts.length === 0) {
-        return { title: 'commandExecution', kind: 'execute', locations: [] };
-    }
-    const [singleContext] = contexts;
-    if (singleContext && contexts.length === 1) {
-        return resolveCommandDisplayFromContext(singleContext);
-    }
-    const displays = contexts.map((context) => resolveCommandDisplayFromContext(context));
-    const title = dedupeStrings(displays.map((display) => display.title)).join(', ');
-    const kind = selectCombinedCommandKind(displays);
-    const locations = dedupeLocations(displays.flatMap((display) => display.locations)).map((location) => ({ path: location.path }));
-    return { title, kind, locations };
-}
-function resolveCommandDisplayFromContext(context) {
-    if (READ_COMMANDS.has(context.firstCommand)) {
-        const label = context.pathArg ?? context.command;
-        return { title: `Read ${label}`, kind: 'read', locations: context.locations };
-    }
-    if (LIST_OR_FIND_COMMANDS.has(context.firstCommand)) {
-        const target = context.pathArg
-            ? normalizeLocationPath(context.pathArg, context.cwd)
-            : context.cwd;
-        const title = context.firstCommand === 'find' || context.firstCommand === 'fd'
-            ? `Search ${target}`
-            : `List ${target}`;
-        return { title, kind: 'search', locations: context.locations };
-    }
-    if (GREP_LIKE_COMMANDS.has(context.firstCommand)) {
-        const query = context.nonFlagArgs.find((token) => !isLikelyPathToken(token));
-        const target = context.pathArg ? ` in ${context.pathArg}` : '';
-        const title = query ? `Search ${query}${target}` : `Search ${context.command}`;
-        return { title, kind: 'search', locations: context.locations };
-    }
-    return { title: context.command, kind: 'execute', locations: context.locations };
-}
-function normalizeCwdForScope(cwd) {
-    if (cwd.length > 1 && cwd.endsWith('/')) {
-        return cwd.slice(0, -1);
-    }
-    return cwd;
-}
-function normalizeScopeToken(token) {
-    return token.replace(/\s+/g, ' ').trim();
-}
-function buildCommandApprovalScopeKey(params) {
-    const contexts = buildCommandDisplayContexts(params.command, params.cwd);
-    if (contexts.length === 0) {
-        return null;
-    }
-    let scopeCwd = normalizeCwdForScope(params.cwd);
-    const segments = [];
-    for (const context of contexts) {
-        if (context.firstCommand === 'cd') {
-            const rawTarget = context.nonFlagArgs[0];
-            const target = rawTarget ? normalizeScopeToken(rawTarget) : '';
-            if (target.length > 0) {
-                scopeCwd = normalizeCwdForScope(normalizeLocationPath(target, scopeCwd));
-                segments.push(`cd ${target} -> ${scopeCwd}`);
-            }
-            else {
-                segments.push('cd');
-            }
-            continue;
-        }
-        const args = context.nonFlagArgs.map(normalizeScopeToken).filter((arg) => arg.length > 0);
-        const normalized = normalizeScopeToken([context.firstCommand, ...args].join(' '));
-        if (normalized.length === 0) {
-            continue;
-        }
-        segments.push(`[cwd=${scopeCwd}] ${normalized}`);
-    }
-    const normalizedSegments = segments
-        .map(normalizeScopeToken)
-        .filter((segment) => segment.length > 0);
-    if (normalizedSegments.length === 0) {
-        return null;
-    }
-    return `cwd=${normalizeCwdForScope(params.cwd)}|${normalizedSegments.join(' && ')}`;
-}
-function dedupeLocations(locations) {
-    const seen = new Set();
-    const result = [];
-    for (const location of locations) {
-        const key = `${location.path}:${location.line ?? ''}`;
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        result.push(location);
-    }
-    return result;
-}
 function parseTextFromPromptBlock(block) {
     if (block.type === 'text') {
         return block.text;
@@ -690,18 +284,6 @@ function parseTextFromPromptBlock(block) {
     }
     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))
@@ -805,6 +387,7 @@ export class CodexAppServerAcpAdapter {
     mcpServersByThreadId = new Map();
     appliedMcpServerConfigJson = '{}';
     shapeDriftCounts = new Map();
+    streamEventHandler;
     constructor(connection, codexClient) {
         this.connection = connection;
         this.codex =
@@ -832,6 +415,22 @@ export class CodexAppServerAcpAdapter {
                         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() {
@@ -1539,163 +1138,10 @@ export class CodexAppServerAcpAdapter {
         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) {
-        if (item.type === 'reasoning') {
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call',
-                toolCallId: resolveToolCallId({ itemId: item.id, source: item }),
-                title: 'reasoning',
-                kind: 'think',
-                status: 'completed',
-                rawInput: item,
-                rawOutput: item,
-            });
-            await this.emitReasoningThoughtChunkFromItem(sessionId, item);
-            session.replayedTurnItemKeys.add(toTurnItemKey(turnId, item.id));
-            return;
-        }
-        const toolInfo = this.buildToolCallState(session, item, turnId);
-        if (!toolInfo) {
-            this.reportShapeDrift('unhandled_replay_item', {
-                turnId,
-                itemType: item.type,
-                itemId: item.id,
-            });
-            return;
-        }
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'tool_call',
-            toolCallId: toolInfo.toolCallId,
-            title: toolInfo.title,
-            kind: toolInfo.kind,
-            status: 'completed',
-            rawInput: item,
-            rawOutput: item,
-        });
-        session.replayedTurnItemKeys.add(toTurnItemKey(turnId, item.id));
+        await this.streamEventHandler.replayThreadHistory(sessionId, threadId);
     }
     async handleCodexNotification(method, params) {
-        const parsed = knownCodexNotificationSchema.safeParse({ method, params });
-        if (!parsed.success) {
-            this.reportShapeDrift('malformed_notification', {
-                method,
-                issues: parsed.error.issues.slice(0, 3).map((issue) => issue.message),
-            });
-            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/reasoning/summaryTextDelta') {
-            await this.emitReasoningThoughtDelta(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.delta);
-            return;
-        }
-        if (notification.method === 'item/commandExecution/outputDelta') {
-            await this.emitToolCallProgress(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.delta, 'commandExecution');
-            return;
-        }
-        if (notification.method === 'item/fileChange/outputDelta') {
-            await this.emitToolCallProgress(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.delta, 'fileChange');
-            return;
-        }
-        if (notification.method === 'item/mcpToolCall/progress') {
-            await this.emitToolCallProgress(sessionId, session, notification.params.turnId, notification.params.itemId, notification.params.message, 'mcpToolCall');
-            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',
-                },
-            ],
-        });
+        await this.streamEventHandler.handleCodexNotification({ method, params });
     }
     async emitReasoningThoughtChunkFromItem(sessionId, item) {
         const text = extractReasoningTextLocal(item);
@@ -1707,262 +1153,11 @@ export class CodexAppServerAcpAdapter {
             content: { type: 'text', text },
         });
     }
-    isReplayedTurnItem(session, turnId, itemId) {
-        return session.replayedTurnItemKeys.has(toTurnItemKey(turnId, itemId));
-    }
-    async emitReasoningThoughtDelta(sessionId, session, turnId, itemId, delta) {
-        if (this.isReplayedTurnItem(session, turnId, itemId)) {
-            return;
-        }
-        if (delta.length === 0) {
-            return;
-        }
-        const existing = session.toolCallsByItemId.get(itemId);
-        if (!existing) {
-            const toolCallId = resolveToolCallId({
-                itemId,
-            });
-            session.toolCallsByItemId.set(itemId, {
-                toolCallId,
-                title: 'reasoning',
-                kind: 'think',
-                locations: [],
-            });
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call',
-                toolCallId,
-                title: 'reasoning',
-                kind: 'think',
-                status: 'pending',
-                rawInput: {
-                    type: 'reasoning',
-                    id: itemId,
-                },
-            });
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId,
-                title: 'reasoning',
-                kind: 'think',
-                status: 'in_progress',
-            });
-        }
-        session.reasoningDeltaItemIds.add(itemId);
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'agent_thought_chunk',
-            content: { type: 'text', text: delta },
-        });
-    }
-    async emitToolCallProgress(sessionId, session, turnId, itemId, output, source) {
-        if (this.isReplayedTurnItem(session, turnId, itemId)) {
-            return;
-        }
-        const toolCall = session.toolCallsByItemId.get(itemId);
-        if (!toolCall) {
-            this.reportShapeDrift('tool_progress_without_tool_call', { turnId, itemId });
-            return;
-        }
-        if (session.syntheticallyCompletedToolItemIds.has(itemId)) {
-            return;
-        }
-        if (source === 'commandExecution' && isCommandExecutionSessionHandoffOutput(output)) {
-            session.syntheticallyCompletedToolItemIds.add(itemId);
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: toolCall.toolCallId,
-                status: 'completed',
-                kind: toolCall.kind,
-                title: toolCall.title,
-                ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-                rawOutput: output,
-            });
-            return;
-        }
-        await this.emitSessionUpdate(sessionId, {
-            sessionUpdate: 'tool_call_update',
-            toolCallId: toolCall.toolCallId,
-            status: 'in_progress',
-            ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-            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) {
-        if (this.isReplayedTurnItem(session, turnId, item.id)) {
-            return;
-        }
-        if (item.type === 'reasoning') {
-            const existing = session.toolCallsByItemId.get(item.id);
-            const toolInfo = existing ??
-                {
-                    toolCallId: resolveToolCallId({
-                        itemId: item.id,
-                        source: item,
-                    }),
-                    title: 'reasoning',
-                    kind: 'think',
-                    locations: [],
-                };
-            if (!existing) {
-                session.syntheticallyCompletedToolItemIds.delete(item.id);
-                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,
-                });
-            }
-            await this.emitSessionUpdate(session.sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: toolInfo.toolCallId,
-                title: toolInfo.title,
-                kind: toolInfo.kind,
-                status: 'in_progress',
-            });
-            return;
-        }
-        const toolInfo = this.buildToolCallState(session, item, turnId);
-        if (!toolInfo) {
-            this.reportShapeDrift('unhandled_item_started_type', {
-                turnId,
-                itemType: item.type,
-                itemId: item.id,
-            });
-            return;
-        }
-        session.syntheticallyCompletedToolItemIds.delete(item.id);
-        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',
-            ...(toolInfo.locations.length > 0 ? { locations: toolInfo.locations } : {}),
-            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) {
-        if (this.isReplayedTurnItem(session, turnId, item.id)) {
-            return;
-        }
-        if (item.type === 'reasoning') {
-            const existing = session.toolCallsByItemId.get(item.id);
-            const reasoningToolCallId = existing?.toolCallId ??
-                resolveToolCallId({
-                    itemId: item.id,
-                    source: item,
-                });
-            if (existing) {
-                await this.emitSessionUpdate(session.sessionId, {
-                    sessionUpdate: 'tool_call_update',
-                    toolCallId: reasoningToolCallId,
-                    title: existing.title,
-                    kind: existing.kind,
-                    status: toToolStatus(item.status) ?? 'completed',
-                    rawOutput: item,
-                });
-            }
-            else {
-                await this.emitSessionUpdate(session.sessionId, {
-                    sessionUpdate: 'tool_call',
-                    toolCallId: reasoningToolCallId,
-                    title: 'reasoning',
-                    kind: 'think',
-                    status: toToolStatus(item.status) ?? 'completed',
-                    rawInput: item,
-                    rawOutput: item,
-                });
-            }
-            session.toolCallsByItemId.delete(item.id);
-            session.syntheticallyCompletedToolItemIds.delete(item.id);
-            const sawDelta = session.reasoningDeltaItemIds.has(item.id);
-            session.reasoningDeltaItemIds.delete(item.id);
-            if (!sawDelta) {
-                await this.emitReasoningThoughtChunkFromItem(session.sessionId, item);
-            }
-            return;
-        }
-        const existing = session.toolCallsByItemId.get(item.id);
-        if (!existing) {
-            this.reportShapeDrift('item_completed_without_started_state', {
-                turnId,
-                itemType: item.type,
-                itemId: item.id,
-            });
-            return;
-        }
-        const shouldHoldTurnForPlanApproval = item.type === 'plan' &&
+    shouldHoldTurnForPlanApproval(session, item, turnId) {
+        return (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 completionLocations = this.extractLocations(item);
-        const locations = dedupeLocations([...existing.locations, ...completionLocations]);
-        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);
-        session.syntheticallyCompletedToolItemIds.delete(item.id);
-        await this.maybeRequestPlanApproval(session, item, turnId, existing);
+            this.extractPlanApprovalText(session, item) !== null);
     }
     buildPlanApprovalInput(planText, sourceItemId) {
         return {
@@ -2145,27 +1340,6 @@ export class CodexAppServerAcpAdapter {
             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',
@@ -2191,7 +1365,7 @@ export class CodexAppServerAcpAdapter {
         }
         else if (item.type === 'fileChange') {
             title = 'fileChange';
-            locations = this.extractLocations(item);
+            locations = extractLocations(item);
         }
         else if (item.type === 'mcpToolCall') {
             const server = asString(item.server) ?? 'mcp';
@@ -2212,280 +1386,15 @@ export class CodexAppServerAcpAdapter {
             locations,
         };
     }
-    buildPermissionOptions(params) {
-        if (params.method === 'item/tool/requestUserInput') {
-            return buildToolUserInputPermissionOptions(params.questions);
-        }
-        if (params.method === 'item/commandExecution/requestApproval') {
-            return [
-                {
-                    optionId: 'allow_always',
-                    name: 'Allow for session',
-                    kind: 'allow_always',
-                },
-                {
-                    optionId: 'allow_once',
-                    name: 'Allow once',
-                    kind: 'allow_once',
-                },
-                {
-                    optionId: 'reject_once',
-                    name: 'Reject',
-                    kind: 'reject_once',
-                },
-            ];
-        }
-        return [
-            {
-                optionId: 'allow_once',
-                name: 'Allow once',
-                kind: 'allow_once',
-            },
-            {
-                optionId: 'reject_once',
-                name: 'Reject',
-                kind: 'reject_once',
-            },
-        ];
-    }
-    async maybeAutoApproveCommandRequest(params) {
-        if (params.request.method !== 'item/commandExecution/requestApproval') {
-            return false;
-        }
-        const scopeKey = buildCommandApprovalScopeKey({
-            command: asString(params.request.params.command),
-            cwd: asString(params.request.params.cwd) ?? params.session.cwd,
-        });
-        if (!(scopeKey && params.session.commandApprovalScopes.has(scopeKey))) {
-            return false;
-        }
-        await this.respondToCodexPermissionRequest({
-            request: params.request,
-            permission: {
-                outcome: { outcome: 'selected', optionId: 'allow_always' },
-            },
-            session: params.session,
-            toolCallId: params.toolCallId,
-            questions: [],
-        });
-        return true;
-    }
     async handleCodexServerRequest(request) {
-        try {
-            const parsed = knownCodexServerRequestSchema.safeParse(request);
-            if (!parsed.success) {
-                this.reportShapeDrift('malformed_server_request', {
-                    method: request.method,
-                    issues: parsed.error.issues.slice(0, 3).map((issue) => issue.message),
-                });
-                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.reportShapeDrift('request_for_unknown_thread', {
-                    method: typed.method,
-                    threadId: typed.params.threadId,
-                    itemId: typed.params.itemId,
-                });
-                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.reportShapeDrift('request_for_missing_session', {
-                    method: typed.method,
-                    sessionId,
-                    itemId: typed.params.itemId,
-                });
-                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',
-                    ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-                    rawInput: typed.params,
-                });
-            }
-            if (await this.maybeAutoApproveCommandRequest({
-                request: typed,
-                session,
-                toolCallId: toolCall.toolCallId,
-            })) {
-                return;
-            }
-            const questions = typed.method === 'item/tool/requestUserInput' ? typed.params.questions : [];
-            const permissionOptions = this.buildPermissionOptions({
-                method: typed.method,
-                questions,
-            });
-            await this.emitSessionUpdate(sessionId, {
-                sessionUpdate: 'tool_call_update',
-                toolCallId: toolCall.toolCallId,
-                title: toolCall.title,
-                kind: toolCall.kind,
-                status: 'pending',
-                ...(toolCall.locations.length > 0 ? { locations: toolCall.locations } : {}),
-            });
-            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);
-            const cwd = asString(params.cwd) ?? session.cwd;
-            const parsed = resolveCommandDisplay({ command, cwd });
-            return {
-                toolCallId: resolveToolCallId({
-                    itemId,
-                    source: params,
-                }),
-                title: parsed.title,
-                kind: parsed.kind,
-                locations: parsed.locations,
-            };
-        }
-        if (method === 'item/fileChange/requestApproval') {
-            const grantRoot = asString(params.grantRoot);
-            return {
-                toolCallId: resolveToolCallId({
-                    itemId,
-                    source: params,
-                }),
-                title: 'fileChange',
-                kind: 'edit',
-                locations: grantRoot ? [{ path: grantRoot }] : [],
-            };
-        }
-        return {
-            toolCallId: resolveToolCallId({
-                itemId,
-                source: params,
-            }),
-            title: 'item/tool/requestUserInput',
-            kind: 'other',
-            locations: [],
-        };
-    }
-    isAllowedPermissionSelection(selectedOptionId) {
-        return selectedOptionId === 'allow_once' || selectedOptionId === 'allow_always';
-    }
-    async handleToolUserInputPermissionResponse(params) {
-        if (params.request.method !== 'item/tool/requestUserInput') {
-            return false;
-        }
-        const rejected = params.selectedOptionId === null || params.selectedOptionId === 'reject_once';
-        let answers;
-        try {
-            answers = buildToolUserInputAnswers({
-                questions: params.questions,
-                permission: params.permission,
-                selectedOptionId: params.selectedOptionId,
-            });
-        }
-        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 true;
-        }
-        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 true;
-    }
-    async respondToCodexPermissionRequest(params) {
-        const selected = params.permission.outcome.outcome === 'selected' ? params.permission.outcome.optionId : null;
-        if (await this.handleToolUserInputPermissionResponse({
-            ...params,
-            selectedOptionId: selected,
-        })) {
-            return;
-        }
-        if (params.request.method === 'item/commandExecution/requestApproval' &&
-            selected === 'allow_always') {
-            const scopeKey = buildCommandApprovalScopeKey({
-                command: asString(params.request.params.command),
-                cwd: asString(params.request.params.cwd) ?? params.session.cwd,
-            });
-            if (scopeKey) {
-                params.session.commandApprovalScopes.add(scopeKey);
-            }
-            else {
-                this.reportShapeDrift('allow_always_without_scope_key', {
-                    itemId: params.request.params.itemId,
-                    command: params.request.params.command,
-                });
-            }
-        }
-        const allow = this.isAllowedPermissionSelection(selected);
-        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' },
+        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) {