@sumicom/quicksave 0.8.15 → 0.8.17

package/dist/ai/codexAppServer/provider.js

@@ -5,11 +5,13 @@ import { buildSandboxMcpServerConfig, SANDBOX_MCP_NAME } from '../sandboxMcp.js'
 import { normalizePermissionLevelForAgent } from '../provider.js';
 import { makeQueuedUserPrompt, queueStateFor } from '../queuedUserPrompts.js';
 import { getEventStore } from '../../storage/eventStore.js';
-import { consumeAppServerStream } from './cardAdapter.js';
+import { createCodexTurnStreamConsumer, } from './cardAdapter.js';
 import { codexApprovalResponse, codexApprovalToPermissionPrompt, } from './approvalMapping.js';
 import { detectCodexVersion, spawnAppServer } from './processManager.js';
 import { RuntimeOverrideStore } from './overrideStore.js';
 import { TokenAccounting } from './tokenAccounting.js';
+import { codexProtocolPreview } from './protocolLog.js';
+import { codexServerRequestInputId } from './serverRequestIds.js';
 const __ownDir = dirname(fileURLToPath(import.meta.url));
 const __aiDir = dirname(__ownDir);
 /**
@@ -71,10 +73,13 @@ export class CodexAppServerProvider {
             onExitedFire: callbacks.onSessionExited,
         });
         callbacks.onModelDetected(response.model);
+        void session.refreshGoalConfig().catch((err) => {
+            console.warn(`[codex-app] failed to refresh goal session=${response.thread.id.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`);
+        });
         // First-turn overrides from opts (effort etc.) get queued so drain()
         // attaches them to the next turn/start.
         overrideStore.enqueue(perTurnOverridesFromOpts(opts, response));
-        void session.runTurn(opts.prompt, opts.attachments);
+        scheduleInitialTurn(session, opts.prompt, opts.attachments);
         return { sessionId: response.thread.id, session };
     }
     async resumeSession(opts, cardBuilder, callbacks) {
@@ -102,11 +107,24 @@ export class CodexAppServerProvider {
             onExitedFire: callbacks.onSessionExited,
         });
         callbacks.onModelDetected(response.model);
+        void session.refreshGoalConfig().catch((err) => {
+            console.warn(`[codex-app] failed to refresh goal session=${response.thread.id.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`);
+        });
         overrideStore.enqueue(perTurnOverridesFromOpts(opts, response));
-        void session.runTurn(opts.prompt, opts.attachments);
+        scheduleInitialTurn(session, opts.prompt, opts.attachments);
         return { sessionId: response.thread.id, session };
     }
 }
+function scheduleInitialTurn(session, prompt, attachments) {
+    // Give SessionManager and messageHandler one macrotask to register the
+    // session and persist the mcpCorrId-backed registry entry before the model
+    // can call Quicksave's MCP tools. Without this, the first
+    // UpdateSessionStatus call in a fresh Codex turn can see `source: "unknown"`.
+    setTimeout(() => {
+        if (session.alive)
+            void session.runTurn(prompt, attachments);
+    }, 0);
+}
 export class CodexAppServerSession {
     handle;
     tokens;
@@ -117,7 +135,13 @@ export class CodexAppServerSession {
     currentTurnId = null;
     pendingTurns = [];
     running = false;
+    startingRunTurn = false;
+    prestartedRunTurnId = null;
     exited = false;
+    turnConsumers = new Map();
+    settledTurnIds = new Set();
+    unsubscribeSessionNotifications = null;
+    unsubscribeTransportClose = null;
     constructor(args) {
         this.handle = args.handle;
         this.tokens = args.tokens;
@@ -130,6 +154,12 @@ export class CodexAppServerSession {
         this.handle.rpc.setServerRequestHandler(async (req) => {
             return this.handleServerRequest(req);
         });
+        this.unsubscribeSessionNotifications = this.handle.rpc.onNotification((notification) => {
+            this.handleSessionNotification(notification);
+        });
+        this.unsubscribeTransportClose = this.handle.rpc.onClose(() => {
+            this.handleTransportClosed();
+        });
         // If the child exits unexpectedly, mark us dead and notify SessionManager.
         this.handle.child.once('exit', () => {
             if (this.exited)
@@ -142,9 +172,9 @@ export class CodexAppServerSession {
         return !this.exited;
     }
     sendUserMessage(prompt, attachments) {
-        if (this.currentTurnId) {
-            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
-            this.callbacks.onQueueStateChange?.(this.threadId);
+        const activeTurnId = this.currentTurnId;
+        if (activeTurnId) {
+            void this.steerOrQueue(prompt, attachments, activeTurnId);
             return;
         }
         void this.runTurn(prompt, attachments);
@@ -152,12 +182,7 @@ export class CodexAppServerSession {
     interruptThenSendUserMessage(prompt, attachments) {
         if (this.currentTurnId)
             this.interrupt();
-        if (this.running) {
-            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
-            this.callbacks.onQueueStateChange?.(this.threadId);
-            return;
-        }
-        void this.runTurn(prompt, attachments);
+        this.enqueueOrRunTurn(prompt, attachments);
     }
     getQueueState() {
         return queueStateFor(this.pendingTurns, this.currentTurnId !== null);
@@ -168,11 +193,45 @@ export class CodexAppServerSession {
     hasPendingOverride() {
         return this.overrideStore.hasPending();
     }
+    async sendControlRequest(subtype, params) {
+        switch (subtype) {
+            case 'goal.get':
+            case 'thread/goal/get':
+                return this.refreshGoalConfigAndReturn();
+            case 'goal.set':
+            case 'goal.update':
+            case 'thread/goal/set': {
+                const response = await this.handle.rpc.request('thread/goal/set', this.goalSetParams(params));
+                this.emitGoalConfig(response.goal);
+                return response;
+            }
+            case 'goal.pause': {
+                const response = await this.handle.rpc.request('thread/goal/set', { threadId: this.threadId, status: 'paused' });
+                this.emitGoalConfig(response.goal);
+                return response;
+            }
+            case 'goal.resume': {
+                const response = await this.handle.rpc.request('thread/goal/set', { threadId: this.threadId, status: 'active' });
+                this.emitGoalConfig(response.goal);
+                return response;
+            }
+            case 'goal.clear':
+            case 'thread/goal/clear': {
+                const response = await this.handle.rpc.request('thread/goal/clear', { threadId: this.threadId });
+                this.emitGoalClearedConfig();
+                return response;
+            }
+            default:
+                throw new Error(`Unsupported Codex control request subtype: ${subtype}`);
+        }
+    }
+    async refreshGoalConfig() {
+        await this.refreshGoalConfigAndReturn();
+    }
     async listSlashCommands(opts) {
         const response = await this.handle.rpc.request('skills/list', {
             cwds: opts?.cwd ? [opts.cwd] : [],
             forceReload: opts?.forceReload === true,
-            perCwdExtraUserRoots: null,
         });
         return codexSkillsToSlashCommands(response, opts?.cwd);
     }
@@ -190,6 +249,11 @@ export class CodexAppServerSession {
             return;
         this.exited = true;
         this.pendingTurns = [];
+        this.unsubscribeSessionNotifications?.();
+        this.unsubscribeSessionNotifications = null;
+        this.unsubscribeTransportClose?.();
+        this.unsubscribeTransportClose = null;
+        this.closeTurnConsumersAsInterrupted();
         try {
             await this.cardBuilder.persistCards();
         }
@@ -209,8 +273,8 @@ export class CodexAppServerSession {
             // best-effort
         }
     }
-    /** Run a single turn end-to-end: cb.startNewTurn → cb.userMessage →
-     * turn/start → consume notifications → emit stream-end. */
+    /** Run a single explicit turn end-to-end: cb.startNewTurn → cb.userMessage
+     * → turn/start → wait for the session-routed turn consumer to settle. */
     async runTurn(prompt, attachments) {
         if (this.exited)
             return;
@@ -259,6 +323,22 @@ export class CodexAppServerSession {
         this.callbacks.onQueueStateChange?.(this.threadId);
         return true;
     }
+    async steerOrQueue(prompt, attachments, expectedTurnId) {
+        const steered = await this.steerCurrentTurn(prompt, attachments, expectedTurnId);
+        if (steered)
+            return;
+        this.enqueueOrRunTurn(prompt, attachments);
+    }
+    enqueueOrRunTurn(prompt, attachments) {
+        if (this.exited)
+            return;
+        if (this.running || this.currentTurnId) {
+            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
+            this.callbacks.onQueueStateChange?.(this.threadId);
+            return;
+        }
+        void this.runTurn(prompt, attachments);
+    }
     async steerCurrentTurn(prompt, attachments, expectedTurnId, opts) {
         try {
             if (attachments && attachments.length > 0) {
@@ -314,17 +394,24 @@ export class CodexAppServerSession {
                 input: attachmentsToCodexUserInput(prompt, attachments),
                 ...drained,
             };
-            const response = await this.handle.rpc.request('turn/start', params);
+            this.startingRunTurn = true;
+            this.prestartedRunTurnId = null;
+            let response;
+            try {
+                response = await this.handle.rpc.request('turn/start', params);
+            }
+            finally {
+                this.startingRunTurn = false;
+            }
             this.overrideStore.commit();
             turnId = response.turn.id;
             this.currentTurnId = turnId;
             cb.setCurrentTurnId(turnId);
-            const result = await consumeAppServerStream(this.handle.rpc, cb, {
-                sessionId: this.threadId,
-                threadId: this.threadId,
-                turnId,
-                tokens: this.tokens,
-            }, this.callbacks);
+            const prestartedTurnId = this.prestartedRunTurnId;
+            if (prestartedTurnId && prestartedTurnId !== turnId) {
+                console.warn(`[codex-app] turn/start response mismatch session=${this.threadId.slice(0, 8)} response=${turnId.slice(0, 8)} notification=${prestartedTurnId.slice(0, 8)}`);
+            }
+            const result = await this.beginTurnConsumer(turnId, { managedByRunTurn: true }).result;
             void result; // settled; stream-end already emitted by adapter
         }
         catch (err) {
@@ -338,19 +425,191 @@ export class CodexAppServerSession {
             });
         }
         finally {
+            this.startingRunTurn = false;
+            const lifecycleTurnId = turnId ?? this.prestartedRunTurnId;
+            this.prestartedRunTurnId = null;
+            await this.finishTurnLifecycle(lifecycleTurnId);
+        }
+    }
+    async refreshGoalConfigAndReturn() {
+        const response = await this.handle.rpc.request('thread/goal/get', { threadId: this.threadId });
+        if (response.goal) {
+            this.emitGoalConfig(response.goal);
+        }
+        else {
+            this.emitGoalClearedConfig();
+        }
+        return response;
+    }
+    goalSetParams(params) {
+        const out = { threadId: this.threadId };
+        const input = params ?? {};
+        if ('objective' in input) {
+            out.objective = normalizeGoalObjective(input.objective);
+        }
+        if ('status' in input) {
+            out.status = normalizeGoalStatusOrNull(input.status);
+        }
+        if ('tokenBudget' in input) {
+            out.tokenBudget = normalizeGoalTokenBudget(input.tokenBudget);
+        }
+        return out;
+    }
+    beginTurnConsumer(turnId, opts) {
+        const existing = this.turnConsumers.get(turnId);
+        if (existing)
+            return existing;
+        this.settledTurnIds.delete(turnId);
+        const consumer = createCodexTurnStreamConsumer(this.cardBuilder, {
+            sessionId: this.threadId,
+            threadId: this.threadId,
+            turnId,
+            tokens: this.tokens,
+        }, this.callbacks);
+        this.turnConsumers.set(turnId, consumer);
+        void consumer.result.then(() => {
+            void this.handleTurnConsumerSettled(turnId, consumer, opts.managedByRunTurn).catch((err) => {
+                console.warn(`[codex-app] failed to settle turn consumer session=${this.threadId.slice(0, 8)} turn=${turnId.slice(0, 8)} error=${err instanceof Error ? err.message : String(err)}`);
+            });
+        });
+        return consumer;
+    }
+    async handleTurnConsumerSettled(turnId, consumer, managedByRunTurn) {
+        if (this.turnConsumers.get(turnId) === consumer) {
+            this.turnConsumers.delete(turnId);
+        }
+        this.rememberSettledTurn(turnId);
+        consumer.dispose();
+        if (managedByRunTurn)
+            return;
+        await this.finishTurnLifecycle(turnId);
+        this.drainPendingTurnsAfterObservedTurn();
+    }
+    async finishTurnLifecycle(turnId) {
+        const builderTurnId = this.cardBuilder.getCurrentTurnId();
+        const shouldClearCards = !turnId || !builderTurnId || builderTurnId === turnId;
+        if (!turnId || this.currentTurnId === turnId) {
             this.currentTurnId = null;
-            try {
-                await cb.persistCards();
-            }
-            catch {
-                // best-effort
+        }
+        try {
+            await this.cardBuilder.persistCards();
+        }
+        catch {
+            // best-effort
+        }
+        if (shouldClearCards) {
+            this.cardBuilder.clearCards();
+        }
+        this.callbacks.onTurnSettled?.(this.threadId);
+    }
+    drainPendingTurnsAfterObservedTurn() {
+        if (this.exited || this.running || this.currentTurnId || this.pendingTurns.length === 0) {
+            return;
+        }
+        const next = this.pendingTurns.shift();
+        this.callbacks.onQueueStateChange?.(this.threadId);
+        void this.runTurn(next.prompt, next.attachments);
+    }
+    closeTurnConsumersAsInterrupted() {
+        for (const consumer of this.turnConsumers.values()) {
+            consumer.closeAsInterrupted();
+        }
+    }
+    handleTransportClosed() {
+        this.closeTurnConsumersAsInterrupted();
+    }
+    rememberSettledTurn(turnId) {
+        this.settledTurnIds.add(turnId);
+        if (this.settledTurnIds.size <= 100)
+            return;
+        const oldest = this.settledTurnIds.values().next().value;
+        if (oldest)
+            this.settledTurnIds.delete(oldest);
+    }
+    handleSessionNotification(notification) {
+        try {
+            this.observeTokenUsageNotification(notification);
+            const turnId = this.ensureTurnConsumerForNotification(notification);
+            this.dispatchTurnNotification(notification, turnId);
+            switch (notification.method) {
+                case 'thread/goal/updated': {
+                    const params = notification.params;
+                    if (params.threadId !== this.threadId)
+                        return;
+                    this.emitGoalConfig(params.goal);
+                    return;
+                }
+                case 'thread/goal/cleared': {
+                    const params = notification.params;
+                    if (params.threadId !== this.threadId)
+                        return;
+                    this.emitGoalClearedConfig();
+                    return;
+                }
+                default:
+                    return;
             }
-            cb.clearCards();
-            this.callbacks.onTurnSettled?.(this.threadId);
         }
+        catch (err) {
+            console.warn(`[codex-app] failed to handle session notification method=${notification.method} session=${this.threadId.slice(0, 8)} params=${codexProtocolPreview(notification.params)} error=${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    observeTokenUsageNotification(notification) {
+        if (notification.method !== 'thread/tokenUsage/updated')
+            return;
+        if (!notificationBelongsToThread(notification.params, this.threadId))
+            return;
+        this.tokens.observe(notification.params);
+    }
+    ensureTurnConsumerForNotification(notification) {
+        if (!notificationBelongsToThread(notification.params, this.threadId))
+            return null;
+        const turnId = notificationTurnId(notification);
+        if (!turnId)
+            return null;
+        if (this.settledTurnIds.has(turnId))
+            return turnId;
+        const existing = this.turnConsumers.get(turnId);
+        if (existing)
+            return turnId;
+        if (!shouldCreateTurnConsumerForNotification(notification.method))
+            return turnId;
+        const managedByRunTurn = this.startingRunTurn || this.currentTurnId === turnId;
+        if (this.startingRunTurn) {
+            this.prestartedRunTurnId = turnId;
+        }
+        if (managedByRunTurn) {
+            this.currentTurnId = turnId;
+            this.cardBuilder.setCurrentTurnId(turnId);
+        }
+        else {
+            this.cardBuilder.startNewTurn(turnId);
+            this.currentTurnId = turnId;
+            this.callbacks.onQueueStateChange?.(this.threadId);
+        }
+        this.beginTurnConsumer(turnId, { managedByRunTurn });
+        return turnId;
+    }
+    dispatchTurnNotification(notification, turnId) {
+        if (!notificationBelongsToThread(notification.params, this.threadId))
+            return;
+        if (turnId) {
+            this.turnConsumers.get(turnId)?.dispatch(notification);
+            return;
+        }
+        for (const consumer of this.turnConsumers.values()) {
+            consumer.dispatch(notification);
+        }
+    }
+    emitGoalConfig(goal) {
+        this.callbacks.onSessionConfigPatch?.(this.threadId, codexGoalToConfigPatch(goal));
+    }
+    emitGoalClearedConfig() {
+        this.callbacks.onSessionConfigPatch?.(this.threadId, clearedGoalConfigPatch());
     }
     async handleServerRequest(req) {
         const requestIdStr = String(req.id);
+        const pendingRequestId = codexServerRequestInputId(this.threadId, requestIdStr);
         switch (req.method) {
             case 'item/commandExecution/requestApproval':
             case 'item/fileChange/requestApproval':
@@ -359,16 +618,364 @@ export class CodexAppServerSession {
             case 'applyPatchApproval': {
                 const method = req.method;
                 const prompt = codexApprovalToPermissionPrompt(method, requestIdStr, req.params);
-                const decision = await this.callbacks.handlePermissionRequest(this.threadId, prompt);
+                const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+                    ...prompt,
+                    requestId: pendingRequestId,
+                });
                 return codexApprovalResponse(method, req.params, decision);
             }
+            case 'item/tool/requestUserInput':
+                return this.handleToolRequestUserInput(req.params, pendingRequestId);
+            case 'mcpServer/elicitation/request':
+                return this.handleMcpServerElicitation(req.params, pendingRequestId);
+            case 'item/tool/call':
+                return unsupportedDynamicToolCallResponse(req.params);
+            case 'account/chatgptAuthTokens/refresh':
+                return unsupportedChatgptAuthTokensRefresh(req.params);
+            case 'attestation/generate':
+                return unsupportedAttestationGenerate(req.params);
             default:
                 // Unknown server request — refuse.
+                console.warn(`[codex-app] unsupported server request method=${req.method} id=${requestIdStr} params=${codexProtocolPreview(req.params)}`);
                 throw new Error(`unsupported server request method: ${req.method}`);
         }
     }
+    async handleToolRequestUserInput(params, requestId) {
+        const questions = params.questions ?? [];
+        const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+            requestId,
+            inputType: 'question',
+            toolName: 'AskUserQuestion',
+            toolInput: {
+                questions: questions.map(codexToolQuestionToPromptQuestion),
+            },
+            toolUseId: params.itemId,
+            title: questions[0]?.question ?? 'Codex needs input',
+            message: questions.length > 1 ? 'Codex needs answers before it can continue.' : undefined,
+            skipAutoApprove: true,
+        });
+        if (decision.action === 'deny')
+            return { answers: {} };
+        return codexToolAnswersFromResponse(questions, decision.response ?? '');
+    }
+    async handleMcpServerElicitation(params, requestId) {
+        const toolUseId = `mcp-elicitation:${requestId}`;
+        if (params.mode === 'url') {
+            const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+                requestId,
+                inputType: 'permission',
+                toolName: 'McpElicitation',
+                toolInput: {
+                    serverName: params.serverName,
+                    mode: params.mode,
+                    url: params.url,
+                    elicitationId: params.elicitationId,
+                },
+                toolUseId,
+                title: `Open MCP prompt from ${params.serverName}?`,
+                message: `${params.message}\n\n${params.url}`,
+                skipAutoApprove: true,
+            });
+            return {
+                action: decision.action === 'deny' ? 'decline' : 'accept',
+                content: null,
+                _meta: params._meta ?? null,
+            };
+        }
+        const fields = mcpElicitationFields(params.requestedSchema);
+        const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+            requestId,
+            inputType: 'question',
+            toolName: 'AskUserQuestion',
+            toolInput: {
+                serverName: params.serverName,
+                mode: params.mode,
+                message: params.message,
+                questions: fields.map((field) => field.question),
+            },
+            toolUseId,
+            title: params.message || `MCP prompt from ${params.serverName}`,
+            message: `MCP server: ${params.serverName}`,
+            skipAutoApprove: true,
+        });
+        if (decision.action === 'deny') {
+            return { action: 'decline', content: null, _meta: params._meta ?? null };
+        }
+        return {
+            action: 'accept',
+            content: mcpElicitationContentFromResponse(fields, decision.response ?? ''),
+            _meta: params._meta ?? null,
+        };
+    }
 }
 // ── helpers ──
+function notificationBelongsToThread(params, threadId) {
+    if (typeof params !== 'object' || params === null)
+        return true;
+    const candidate = params.threadId;
+    return typeof candidate !== 'string' || candidate === threadId;
+}
+function notificationTurnId(notification) {
+    switch (notification.method) {
+        case 'turn/started': {
+            const params = notification.params;
+            return params.turn?.id ?? null;
+        }
+        case 'turn/completed': {
+            const params = notification.params;
+            return params.turn?.id ?? null;
+        }
+        default: {
+            if (typeof notification.params !== 'object' || notification.params === null)
+                return null;
+            const candidate = notification.params.turnId;
+            return typeof candidate === 'string' && candidate.length > 0 ? candidate : null;
+        }
+    }
+}
+function shouldCreateTurnConsumerForNotification(method) {
+    switch (method) {
+        case 'turn/started':
+        case 'turn/completed':
+        case 'turn/plan/updated':
+        case 'item/started':
+        case 'item/autoApprovalReview/started':
+        case 'item/autoApprovalReview/completed':
+        case 'item/completed':
+        case 'item/agentMessage/delta':
+        case 'item/plan/delta':
+        case 'item/commandExecution/outputDelta':
+        case 'item/fileChange/outputDelta':
+        case 'item/fileChange/patchUpdated':
+        case 'item/mcpToolCall/progress':
+        case 'item/reasoning/summaryTextDelta':
+        case 'item/reasoning/summaryPartAdded':
+        case 'item/reasoning/textDelta':
+        case 'model/rerouted':
+        case 'model/verification':
+        case 'error':
+            return true;
+        default:
+            return false;
+    }
+}
+function codexToolQuestionToPromptQuestion(question) {
+    return {
+        id: question.id,
+        question: question.question,
+        header: question.header || undefined,
+        options: question.options?.map((option) => ({
+            label: option.label,
+            description: option.description || undefined,
+        })),
+        isSecret: question.isSecret || undefined,
+    };
+}
+function codexToolAnswersFromResponse(questions, responseText) {
+    const parts = questions.length > 1 ? responseText.split('\n') : [responseText];
+    const answers = {};
+    for (let i = 0; i < questions.length; i++) {
+        const question = questions[i];
+        if (!question?.id)
+            continue;
+        const answer = (parts[i] ?? '').trim();
+        answers[question.id] = { answers: answer ? [answer] : [] };
+    }
+    return { answers };
+}
+function mcpElicitationFields(schema) {
+    return Object.entries(schema.properties ?? {}).map(([key, prop]) => {
+        const primitive = prop;
+        const options = mcpOptionsForSchema(primitive);
+        const multiSelect = primitiveType(primitive) === 'array';
+        return {
+            key,
+            schema: primitive,
+            options,
+            multiSelect,
+            question: {
+                id: key,
+                question: primitiveTitle(primitive) ?? key,
+                header: key,
+                options: options?.map((option) => ({
+                    label: option.label,
+                    description: typeof option.value === 'string' && option.value !== option.label
+                        ? option.value
+                        : undefined,
+                })),
+                multiSelect,
+            },
+        };
+    });
+}
+function mcpElicitationContentFromResponse(fields, responseText) {
+    const parts = fields.length > 1 ? responseText.split('\n') : [responseText];
+    const content = {};
+    for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        const raw = (parts[i] ?? '').trim();
+        content[field.key] = parseMcpElicitationValue(field, raw);
+    }
+    return content;
+}
+function parseMcpElicitationValue(field, raw) {
+    if (field.multiSelect) {
+        const answers = raw ? raw.split(',').map((part) => part.trim()).filter(Boolean) : [];
+        return answers.map((answer) => mcpOptionValue(field.options, answer));
+    }
+    const mapped = mcpOptionValue(field.options, raw);
+    const type = primitiveType(field.schema);
+    if (type === 'boolean') {
+        if (/^(true|yes|y|1)$/i.test(String(mapped)))
+            return true;
+        if (/^(false|no|n|0)$/i.test(String(mapped)))
+            return false;
+        return Boolean(raw);
+    }
+    if (type === 'number' || type === 'integer') {
+        const n = Number(mapped);
+        return Number.isFinite(n) ? n : raw;
+    }
+    return mapped;
+}
+function mcpOptionValue(options, answer) {
+    const match = options?.find((option) => option.label === answer || option.value === answer);
+    return match ? match.value : answer;
+}
+function mcpOptionsForSchema(schema) {
+    const record = schema;
+    if (Array.isArray(record.oneOf)) {
+        return record.oneOf.map((option) => constOption(option)).filter((option) => !!option);
+    }
+    if (Array.isArray(record.enum)) {
+        const names = Array.isArray(record.enumNames) ? record.enumNames : [];
+        return record.enum.map((value, index) => ({
+            label: typeof names[index] === 'string' ? names[index] : String(value),
+            value: jsonPrimitive(value),
+        }));
+    }
+    const items = record.items;
+    if (items && Array.isArray(items.anyOf)) {
+        return items.anyOf.map((option) => constOption(option)).filter((option) => !!option);
+    }
+    if (items && Array.isArray(items.enum)) {
+        return items.enum.map((value) => ({ label: String(value), value: jsonPrimitive(value) }));
+    }
+    if (record.type === 'boolean') {
+        return [
+            { label: 'Yes', value: true },
+            { label: 'No', value: false },
+        ];
+    }
+    return null;
+}
+function constOption(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const option = value;
+    if (option.const === undefined)
+        return null;
+    return {
+        label: typeof option.title === 'string' ? option.title : String(option.const),
+        value: jsonPrimitive(option.const),
+    };
+}
+function jsonPrimitive(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) {
+        return value;
+    }
+    return String(value);
+}
+function primitiveType(schema) {
+    return schema.type;
+}
+function primitiveTitle(schema) {
+    const title = schema.title;
+    return typeof title === 'string' && title.trim() ? title : undefined;
+}
+function unsupportedDynamicToolCallResponse(params) {
+    const toolName = params.namespace ? `${params.namespace}:${params.tool}` : params.tool;
+    return {
+        success: false,
+        contentItems: [{
+                type: 'inputText',
+                text: `Dynamic tool calls are not supported by Quicksave: ${toolName}`,
+            }],
+    };
+}
+function unsupportedChatgptAuthTokensRefresh(params) {
+    throw new Error(`chatgptAuthTokens refresh is not supported by Quicksave (reason=${params.reason}). ` +
+        'Use Codex managed ChatGPT login or API key auth.');
+}
+function unsupportedAttestationGenerate(params) {
+    console.warn(`[codex-app] unsupported server request method=attestation/generate params=${codexProtocolPreview(params)}`);
+    throw new Error('attestation/generate is not supported by Quicksave');
+}
+function normalizeGoalObjective(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'string') {
+        throw new Error('goal objective must be a string');
+    }
+    const objective = value.trim();
+    if (!objective) {
+        throw new Error('goal objective must not be empty');
+    }
+    if (objective.length > 4000) {
+        throw new Error('goal objective must be 4000 characters or fewer');
+    }
+    return objective;
+}
+function normalizeGoalStatusOrNull(value) {
+    if (value === null)
+        return null;
+    if (typeof value === 'string' && isThreadGoalStatus(value))
+        return value;
+    throw new Error(`goal status must be one of: ${THREAD_GOAL_STATUSES.join(', ')}`);
+}
+function normalizeGoalTokenBudget(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new Error('goal tokenBudget must be a non-negative number');
+    }
+    return value;
+}
+const THREAD_GOAL_STATUSES = [
+    'active',
+    'paused',
+    'blocked',
+    'usageLimited',
+    'budgetLimited',
+    'complete',
+];
+function isThreadGoalStatus(value) {
+    return THREAD_GOAL_STATUSES.includes(value);
+}
+function codexGoalToConfigPatch(goal) {
+    return {
+        codexGoalPresent: true,
+        codexGoalObjective: goal.objective,
+        codexGoalStatus: goal.status,
+        codexGoalTokenBudget: goal.tokenBudget,
+        codexGoalTokensUsed: goal.tokensUsed,
+        codexGoalTimeUsedSeconds: goal.timeUsedSeconds,
+        codexGoalCreatedAt: goal.createdAt,
+        codexGoalUpdatedAt: goal.updatedAt,
+    };
+}
+function clearedGoalConfigPatch() {
+    return {
+        codexGoalPresent: false,
+        codexGoalObjective: null,
+        codexGoalStatus: null,
+        codexGoalTokenBudget: null,
+        codexGoalTokensUsed: null,
+        codexGoalTimeUsedSeconds: null,
+        codexGoalCreatedAt: null,
+        codexGoalUpdatedAt: null,
+    };
+}
 function spawnCodexAppServer(opts) {
     return spawnAppServer({
         clientInfo: {
@@ -376,7 +983,7 @@ function spawnCodexAppServer(opts) {
             title: 'Quicksave Agent',
             version: '0.0.0',
         },
-        capabilities: { experimentalApi: true, optOutNotificationMethods: null },
+        capabilities: { experimentalApi: true, requestAttestation: false, optOutNotificationMethods: null },
     }, {
         extraArgs: buildCodexSandboxMcpConfigArgs({
             cwd: opts.cwd,
@@ -430,7 +1037,6 @@ function seedOverrideStoreFromResponse(store, resp) {
         effort: resp.reasoningEffort ?? null,
         approvalPolicy: resp.approvalPolicy,
         sandboxPolicy: resp.sandbox,
-        permissionProfile: resp.permissionProfile,
         approvalsReviewer: resp.approvalsReviewer,
     });
 }
@@ -485,7 +1091,6 @@ export function buildThreadStartParams(opts) {
         approvalPolicy: perm.approvalPolicy,
         approvalsReviewer: perm.approvalsReviewer,
         sandbox: perm.sandbox,
-        permissionProfile: null,
         config: null,
         serviceName: null,
         baseInstructions: null,
@@ -493,8 +1098,7 @@ export function buildThreadStartParams(opts) {
         personality: null,
         ephemeral: null,
         sessionStartSource: null,
-        experimentalRawEvents: false,
-        persistExtendedHistory: true,
+        threadSource: null,
     };
 }
 export function buildThreadResumeParams(opts) {
@@ -502,8 +1106,6 @@ export function buildThreadResumeParams(opts) {
     const perm = mapCodexPresetToInitialThreadOpts(preset, opts.sandboxed);
     return {
         threadId: opts.sessionId,
-        history: null,
-        path: null,
         model: opts.model ?? null,
         modelProvider: null,
         serviceTier: null,
@@ -511,13 +1113,10 @@ export function buildThreadResumeParams(opts) {
         approvalPolicy: perm.approvalPolicy,
         approvalsReviewer: perm.approvalsReviewer,
         sandbox: perm.sandbox,
-        permissionProfile: null,
         config: null,
         baseInstructions: null,
         developerInstructions: opts.systemPrompt ?? null,
         personality: null,
-        excludeTurns: true,
-        persistExtendedHistory: true,
     };
 }
 function perTurnOverridesFromOpts(opts, resolved) {