factory-factory 0.3.3 → 0.3.4

package/dist/src/backend/domains/session/lifecycle/session.service.js

@@ -6,6 +6,7 @@ import { createLogger } from '../../../../backend/services/logger.service.js';
 import { extractPlanText } from '../../../../shared/acp-protocol/plan-content.js';
 import { EMPTY_CHAT_BAR_CAPABILITIES } from '../../../../shared/chat-capabilities.js';
 import { SessionStatus } from '../../../../shared/core/index.js';
+import { isUserQuestionRequest } from '../../../../shared/pending-request-types.js';
 import { createInitialSessionRuntimeState, } from '../../../../shared/session-runtime.js';
 import { sessionPromptBuilder } from './session.prompt-builder.js';
 import { sessionRepository } from './session.repository.js';
@@ -22,9 +23,13 @@ class SessionService {
     suppressAcpReplayForSession = new Set();
     workspaceBridge = null;
     sessionToWorkspace = new Map();
+    promptTurnCompleteHandler = null;
     configure(bridges) {
         this.workspaceBridge = bridges.workspace;
     }
+    setPromptTurnCompleteHandler(handler) {
+        this.promptTurnCompleteHandler = handler;
+    }
     isStaleLoadingRuntime(runtime) {
         if (runtime.phase !== 'loading' || runtime.processState === 'alive') {
             return false;
@@ -359,11 +364,12 @@ class SessionService {
             kind: o.kind,
         }));
         const planContent = this.extractPlanContent(toolName, toolInput);
-        if (toolName === 'AskUserQuestion') {
+        if (isUserQuestionRequest({ toolName, input: toolInput })) {
             const questions = this.extractAskUserQuestions(toolInput);
             sessionDomainService.emitDelta(sid, {
                 type: 'user_question',
                 requestId,
+                toolName,
                 questions,
                 acpOptions,
             });
@@ -489,15 +495,110 @@ class SessionService {
         if (existingClient) {
             throw new Error('Session is already running');
         }
-        await this.getOrCreateAcpSessionClient(sessionId, { permissionMode: 'bypassPermissions' }, session);
+        const startupModePreset = options?.startupModePreset;
+        const startupPermissionMode = startupModePreset === 'plan' ? 'plan' : 'bypassPermissions';
+        const handle = await this.getOrCreateAcpSessionClient(sessionId, { permissionMode: startupPermissionMode }, session);
+        await this.applyStartupModePreset(sessionId, handle, startupModePreset);
         const initialPrompt = options?.initialPrompt ?? 'Continue with the task.';
         if (initialPrompt) {
             await this.sendSessionMessage(sessionId, initialPrompt);
         }
         logger.info('Session started', { sessionId, provider: session.provider });
     }
+    async applyStartupModePreset(sessionId, handle, startupModePreset) {
+        if (!startupModePreset) {
+            return;
+        }
+        const modeOption = handle.configOptions.find((option) => option.category === 'mode');
+        if (!modeOption) {
+            return;
+        }
+        const availableModeValues = this.getConfigOptionValues(modeOption);
+        const targetMode = this.resolveStartupModeTarget(handle.provider, startupModePreset, availableModeValues);
+        if (!targetMode) {
+            logger.debug('Startup mode preset not available in ACP mode options', {
+                sessionId,
+                provider: handle.provider,
+                startupModePreset,
+                availableModeValues,
+            });
+            return;
+        }
+        const currentMode = modeOption.currentValue ? String(modeOption.currentValue) : null;
+        if (currentMode === targetMode) {
+            return;
+        }
+        try {
+            const configOptions = await acpRuntimeManager.setSessionMode(sessionId, targetMode);
+            handle.configOptions = configOptions;
+            await this.persistAcpConfigSnapshot(sessionId, {
+                provider: handle.provider,
+                providerSessionId: handle.providerSessionId,
+                configOptions,
+            });
+            sessionDomainService.emitDelta(sessionId, {
+                type: 'config_options_update',
+                configOptions,
+            });
+            sessionDomainService.emitDelta(sessionId, {
+                type: 'chat_capabilities',
+                capabilities: this.buildAcpChatBarCapabilities(handle),
+            });
+        }
+        catch (error) {
+            logger.warn('Failed applying startup mode preset', {
+                sessionId,
+                provider: handle.provider,
+                startupModePreset,
+                targetMode,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    resolveStartupModeTarget(provider, startupModePreset, availableModeValues) {
+        if (availableModeValues.length === 0) {
+            return null;
+        }
+        if (startupModePreset === 'plan') {
+            return this.findModeValue(availableModeValues, ['plan']);
+        }
+        if (provider === 'CLAUDE') {
+            return this.findModeValue(availableModeValues, [
+                'bypassPermissions',
+                'dangerouslySkipPermissions',
+                'dangerousSkipPermissions',
+                'acceptEdits',
+            ]);
+        }
+        return this.findModeValue(availableModeValues, [
+            'fullAccess',
+            'full_access',
+            'full-access',
+            'code',
+        ]);
+    }
+    findModeValue(availableModeValues, preferredModeValues) {
+        if (availableModeValues.length === 0 || preferredModeValues.length === 0) {
+            return null;
+        }
+        const availableByNormalized = new Map();
+        for (const value of availableModeValues) {
+            availableByNormalized.set(this.normalizeModeValue(value), value);
+        }
+        for (const preferredValue of preferredModeValues) {
+            const match = availableByNormalized.get(this.normalizeModeValue(preferredValue));
+            if (match) {
+                return match;
+            }
+        }
+        return null;
+    }
+    normalizeModeValue(value) {
+        return value.replace(/[^a-z0-9]/gi, '').toLowerCase();
+    }
     async stopSession(sessionId, options) {
         const session = await this.loadSessionForStop(sessionId);
+        const workspaceId = session?.workspaceId ?? this.sessionToWorkspace.get(sessionId);
         if (acpRuntimeManager.isStopInProgress(sessionId)) {
             logger.debug('Session stop already in progress', { sessionId });
             return;
@@ -510,7 +611,6 @@ class SessionService {
             updatedAt: new Date().toISOString(),
         });
         this.acpStreamState.delete(sessionId);
-        this.pendingAcpToolCalls.delete(sessionId);
         this.suppressAcpReplayForSession.delete(sessionId);
         const acpBridge = this.acpPermissionBridges.get(sessionId);
         if (acpBridge) {
@@ -531,14 +631,17 @@ class SessionService {
             });
         }
         finally {
+            this.finalizeOrphanedToolCallsOnStop(sessionId);
             await this.updateStoppedSessionState(sessionId);
-            sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: false });
+            sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: true });
             sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'stopped',
                 activity: 'IDLE',
                 updatedAt: new Date().toISOString(),
             });
+            this.markWorkspaceSessionIdleOnStop(workspaceId, sessionId);
+            this.sessionToWorkspace.delete(sessionId);
             if (!stopClientFailed) {
                 const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
                 await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
@@ -550,6 +653,33 @@ class SessionService {
             acpTraceLogger.closeSession(sessionId);
         }
     }
+    finalizeOrphanedToolCallsOnStop(sessionId) {
+        try {
+            this.finalizeOrphanedToolCalls(sessionId, 'session_stop');
+        }
+        catch (error) {
+            logger.warn('Failed finalizing orphaned ACP tool calls during stop', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.pendingAcpToolCalls.delete(sessionId);
+        }
+    }
+    markWorkspaceSessionIdleOnStop(workspaceId, sessionId) {
+        if (!(workspaceId && this.workspaceBridge)) {
+            return;
+        }
+        try {
+            this.workspaceBridge.markSessionIdle(workspaceId, sessionId);
+        }
+        catch (error) {
+            logger.warn('Failed to mark workspace session idle during stop', {
+                sessionId,
+                workspaceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     async loadSessionForStop(sessionId) {
         try {
             return await this.repository.getSessionById(sessionId);
@@ -691,7 +821,15 @@ class SessionService {
     }
     async setSessionConfigOption(sessionId, configId, value) {
         const acpHandle = acpRuntimeManager.getClient(sessionId);
-        const selectedOption = acpHandle?.configOptions.find((option) => option.id === configId);
+        if (!acpHandle) {
+            const configOptions = await this.setCachedSessionConfigOption(sessionId, configId, value);
+            sessionDomainService.emitDelta(sessionId, {
+                type: 'config_options_update',
+                configOptions,
+            });
+            return;
+        }
+        const selectedOption = acpHandle.configOptions.find((option) => option.id === configId);
         const isModeOption = configId === 'mode' || selectedOption?.category === 'mode';
         const isModelOption = configId === 'model' || selectedOption?.category === 'model';
         const configOptions = isModeOption
@@ -712,6 +850,46 @@ class SessionService {
             });
         }
     }
+    async setCachedSessionConfigOption(sessionId, configId, value) {
+        const session = await this.repository.getSessionById(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const snapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
+        if (!snapshot || snapshot.provider !== session.provider) {
+            throw new Error(`Cannot set config option for inactive session ${sessionId}: no cached ACP config available`);
+        }
+        const configOptions = this.updateCachedConfigOptions(snapshot.configOptions, configId, value);
+        await this.persistAcpConfigSnapshot(sessionId, {
+            provider: snapshot.provider,
+            providerSessionId: snapshot.providerSessionId,
+            configOptions,
+            existingMetadata: session.providerMetadata,
+        });
+        return configOptions;
+    }
+    updateCachedConfigOptions(configOptions, configId, value) {
+        let didUpdate = false;
+        const nextConfigOptions = configOptions.map((option) => {
+            if (option.id !== configId) {
+                return option;
+            }
+            const allowedValues = this.getConfigOptionValues(option);
+            if (allowedValues.length > 0 && !allowedValues.includes(value)) {
+                throw new Error(`Unsupported value "${value}" for config option "${configId}"` +
+                    ` (allowed: ${allowedValues.join(', ')})`);
+            }
+            didUpdate = true;
+            return {
+                ...option,
+                currentValue: value,
+            };
+        });
+        if (!didUpdate) {
+            throw new Error(`Unknown config option: ${configId}`);
+        }
+        return nextConfigOptions;
+    }
     sendSessionMessage(sessionId, content) {
         const acpClient = acpRuntimeManager.getClient(sessionId);
         if (acpClient) {
@@ -795,6 +973,29 @@ class SessionService {
             if (workspaceId && this.workspaceBridge) {
                 this.workspaceBridge.markSessionIdle(workspaceId, sessionId);
             }
+            this.schedulePromptTurnComplete(sessionId);
+        }
+    }
+    schedulePromptTurnComplete(sessionId) {
+        if (!this.promptTurnCompleteHandler) {
+            return;
+        }
+        setTimeout(() => {
+            void this.notifyPromptTurnComplete(sessionId);
+        }, 0);
+    }
+    async notifyPromptTurnComplete(sessionId) {
+        if (!this.promptTurnCompleteHandler) {
+            return;
+        }
+        try {
+            await this.promptTurnCompleteHandler(sessionId);
+        }
+        catch (error) {
+            logger.warn('Prompt turn completion handler failed', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
     }
     async cancelAcpPrompt(sessionId) {
@@ -846,12 +1047,12 @@ class SessionService {
             .join('\n')
             .trim();
     }
-    respondToAcpPermission(sessionId, requestId, optionId) {
+    respondToAcpPermission(sessionId, requestId, optionId, answers) {
         const bridge = this.acpPermissionBridges.get(sessionId);
         if (!bridge) {
             return false;
         }
-        return bridge.resolvePermission(requestId, optionId);
+        return bridge.resolvePermission(requestId, optionId, answers);
     }
     getRuntimeSnapshot(sessionId) {
         const fallback = createInitialSessionRuntimeState();
@@ -961,12 +1162,36 @@ class SessionService {
     }
     buildCapabilitiesFromConfigOptions(provider, configOptions, fallbackModel) {
         const modelOption = configOptions.find((o) => o.category === 'model');
-        const thoughtOption = configOptions.find((o) => o.category === 'thought_level');
+        const modeOption = configOptions.find((o) => o.category === 'mode');
+        const thoughtOption = configOptions.find((o) => o.category === 'thought_level' || o.id === 'reasoning_effort' || o.category === 'reasoning');
         const selectedModel = modelOption?.currentValue
             ? String(modelOption.currentValue)
             : (fallbackModel ?? undefined);
         const modelOptions = this.buildModelOptions(modelOption, selectedModel);
         const isCodexProvider = provider === 'CODEX';
+        const reasoningOptions = isCodexProvider && thoughtOption
+            ? this.getSelectOptions(thoughtOption).map((option) => ({
+                value: option.value,
+                label: option.name ?? option.value,
+                ...(option.description ? { description: option.description } : {}),
+            }))
+            : [];
+        const reasoningValues = new Set(reasoningOptions.map((option) => option.value));
+        const selectedReasoning = isCodexProvider &&
+            thoughtOption?.currentValue &&
+            typeof thoughtOption.currentValue === 'string' &&
+            reasoningValues.has(thoughtOption.currentValue)
+            ? thoughtOption.currentValue
+            : undefined;
+        const modeDescriptors = modeOption
+            ? [
+                ...this.getConfigOptionValues(modeOption),
+                ...this.getSelectOptions(modeOption)
+                    .map((entry) => entry.name ?? '')
+                    .filter((value) => value.trim().length > 0),
+            ]
+            : [];
+        const planModeEnabled = modeDescriptors.some((entry) => /plan/i.test(entry));
         return {
             provider,
             model: {
@@ -975,13 +1200,14 @@ class SessionService {
                 ...(selectedModel ? { selected: selectedModel } : {}),
             },
             reasoning: {
-                enabled: false,
-                options: [],
+                enabled: reasoningOptions.length > 0,
+                options: reasoningOptions,
+                ...(selectedReasoning ? { selected: selectedReasoning } : {}),
             },
             thinking: {
-                enabled: !!thoughtOption,
+                enabled: !isCodexProvider && !!thoughtOption,
             },
-            planMode: { enabled: true },
+            planMode: { enabled: planModeEnabled },
             attachments: isCodexProvider
                 ? { enabled: false, kinds: [] }
                 : { enabled: true, kinds: ['image', 'text'] },
@@ -994,28 +1220,34 @@ class SessionService {
         if (!modelOption) {
             return selectedModel ? [{ value: selectedModel, label: selectedModel }] : [];
         }
-        const uniqueValues = new Set(this.getConfigOptionValues(modelOption));
-        if (selectedModel) {
-            uniqueValues.add(selectedModel);
+        const byValue = new Map();
+        for (const option of this.getSelectOptions(modelOption)) {
+            if (!byValue.has(option.value)) {
+                byValue.set(option.value, option.name ?? option.value);
+            }
+        }
+        if (selectedModel && !byValue.has(selectedModel)) {
+            byValue.set(selectedModel, selectedModel);
         }
-        return Array.from(uniqueValues).map((value) => ({ value, label: value }));
+        return Array.from(byValue.entries()).map(([value, label]) => ({ value, label }));
     }
-    getConfigOptionValues(option) {
+    getSelectOptions(option) {
         return option.options.flatMap((entry) => {
             if (typeof entry !== 'object' || entry === null) {
                 return [];
             }
             if ('value' in entry && typeof entry.value === 'string') {
-                return [entry.value];
+                return [entry];
             }
             if ('options' in entry && Array.isArray(entry.options)) {
-                return entry.options
-                    .map((grouped) => grouped?.value)
-                    .filter((value) => typeof value === 'string');
+                return entry.options.filter((grouped) => typeof grouped === 'object' && grouped !== null && typeof grouped.value === 'string');
             }
             return [];
         });
     }
+    getConfigOptionValues(option) {
+        return this.getSelectOptions(option).map((entry) => entry.value);
+    }
     async stopAllClients(_timeoutMs = 5000) {
         try {
             await acpRuntimeManager.stopAllClients();
@@ -1036,7 +1268,6 @@ class SessionService {
         const metadataSource = params.existingMetadata ??
             (await this.repository.getSessionById(sessionId))?.providerMetadata ??
             null;
-        const metadataRecord = this.toMetadataRecord(metadataSource);
         const snapshot = {
             provider: params.provider,
             providerSessionId: params.providerSessionId,
@@ -1044,44 +1275,42 @@ class SessionService {
             configOptions: configOptionsForStorage,
             ...(observedModelId ? { observedModelId } : {}),
         };
+        const persistedUpdate = this.buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId);
+        try {
+            await this.repository.updateSession(sessionId, persistedUpdate);
+        }
+        catch (error) {
+            logger.warn('Failed persisting ACP config snapshot to session metadata; retrying once', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            await this.retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId);
+        }
+    }
+    buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId) {
         const nextMetadata = {
-            ...metadataRecord,
+            ...this.toMetadataRecord(metadataSource),
             acpConfigSnapshot: snapshot,
         };
         if (observedModelId) {
             nextMetadata.observedModelId = observedModelId;
         }
+        return {
+            providerMetadata: nextMetadata,
+            ...(observedModelId ? { model: observedModelId } : {}),
+        };
+    }
+    async retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId) {
         try {
-            await this.repository.updateSession(sessionId, {
-                providerMetadata: nextMetadata,
-            });
+            const latestMetadataSource = (await this.repository.getSessionById(sessionId))
+                ?.providerMetadata;
+            await this.repository.updateSession(sessionId, this.buildSnapshotPersistUpdate(latestMetadataSource, snapshot, observedModelId));
         }
-        catch (error) {
-            logger.warn('Failed persisting ACP config snapshot to session metadata; retrying once', {
+        catch (retryError) {
+            logger.warn('Retry failed persisting ACP config snapshot to session metadata', {
                 sessionId,
-                error: error instanceof Error ? error.message : String(error),
+                error: retryError instanceof Error ? retryError.message : String(retryError),
             });
-            try {
-                const latestMetadataSource = (await this.repository.getSessionById(sessionId))
-                    ?.providerMetadata;
-                const latestMetadata = this.toMetadataRecord(latestMetadataSource);
-                const retryMetadata = {
-                    ...latestMetadata,
-                    acpConfigSnapshot: snapshot,
-                };
-                if (observedModelId) {
-                    retryMetadata.observedModelId = observedModelId;
-                }
-                await this.repository.updateSession(sessionId, {
-                    providerMetadata: retryMetadata,
-                });
-            }
-            catch (retryError) {
-                logger.warn('Retry failed persisting ACP config snapshot to session metadata', {
-                    sessionId,
-                    error: retryError instanceof Error ? retryError.message : String(retryError),
-                });
-            }
         }
     }
     cloneConfigOptionsForStorage(configOptions) {