chat-flow-ardymalihi 1.0.2 → 3.0.2

package/dist/src/orchestrator/Orchestrator.js

@@ -0,0 +1,697 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orchestrator = void 0;
+const ConversationSession_1 = require("../core/entities/ConversationSession");
+const Message_1 = require("../core/entities/Message");
+const LanguageDetector_1 = require("../core/utils/LanguageDetector");
+const interfaces_1 = require("../interfaces");
+const errors_1 = require("../core/errors");
+const config_1 = require("../config");
+class Orchestrator {
+    constructor(repo, llm, intent, workflow, webhookService, voiceAdapter, audioStorage, config) {
+        this.repo = repo;
+        this.llm = llm;
+        this.intent = intent;
+        this.workflow = workflow;
+        this.webhookService = webhookService;
+        this.voiceAdapter = voiceAdapter;
+        this.audioStorage = audioStorage;
+        this.config = config ? { ...config_1.DEFAULT_CONFIG, ...config } : config_1.DEFAULT_CONFIG;
+        this.languageDetector = new LanguageDetector_1.LanguageDetector(llm);
+    }
+    async createSession(sessionId, mode, agentPrompt, userId, configId) {
+        // Business Rule: If userId and configId are provided, validate ownership and resolve prompt
+        let resolvedPrompt = agentPrompt;
+        let webhookConfig;
+        if (userId && configId) {
+            console.log(`[Orchestrator] Validating config '${configId}' for user '${userId}'`);
+            const config = await this.repo.findConversationConfig(userId, configId);
+            if (!config) {
+                console.error(`[Orchestrator] Security Alert: Config '${configId}' not found for user '${userId}'`);
+                throw new Error('Invalid Configuration: Config does not belong to User');
+            }
+            // Use the config's system prompt if available, otherwise fall back to passed prompt
+            if (config.systemPrompt) {
+                resolvedPrompt = config.systemPrompt;
+            }
+            webhookConfig = config.webhook;
+        }
+        // Enforce safe voice behavior: Single-turn responses, no narration of actions
+        let finalPrompt = resolvedPrompt;
+        if (mode === 'VOICE') {
+            finalPrompt += `
+
+[VOICE INTERFACE INSTRUCTIONS]
+- Provide the full, final answer in a single response.
+- Do NOT narrate your actions (e.g., "Let me check", "One moment") unless you include the result in the same response.
+- If you cannot perform a task, state it clearly immediately.
+- Keep responses concise and suitable for text-to-speech.
+- Do NOT ask "Is there anything else?" or generic follow-up questions. Only ask questions if you need specific information to complete the CURRENT task.
+- If the user says "Thanks" or "Goodbye", just reply with a short closing (e.g., "You're welcome" or "Goodbye") and stop.`;
+        }
+        const session = new ConversationSession_1.ConversationSession({
+            sessionId,
+            userId,
+            configId,
+            mode,
+            agentPrompt: finalPrompt,
+            conversationMode: 'collaborative' // Default to collaborative mode
+        });
+        if (webhookConfig) {
+            session.setMetadata('webhookConfig', webhookConfig);
+        }
+        await this.repo.saveSession(session);
+        // Initialize Storage (Only for VOICE mode)
+        if (this.audioStorage && mode === 'VOICE') {
+            await this.audioStorage.initializeSession(sessionId, { userId, configId });
+        }
+        // Trigger session.started webhook
+        await this.webhookService.triggerSessionStarted(session);
+        return session;
+    }
+    async processMessage(sessionId, content, onIntermediateResponse) {
+        // 1. Load Session
+        const session = await this.repo.findSessionById(sessionId);
+        if (!session) {
+            throw new errors_1.SessionNotFoundError(sessionId);
+        }
+        try {
+            // 2. Append User Message
+            const userMessage = Message_1.Message.user(content);
+            session.addMessage(userMessage);
+            // 3. Safety Check: Enforce maximum conversation length (system-level protection)
+            const MAX_TOTAL_MSG_COUNT = parseInt(process.env.MAX_TOTAL_MSG_COUNT || '60', 10);
+            const totalMessages = session.messages.length;
+            if (totalMessages > MAX_TOTAL_MSG_COUNT) {
+                console.warn(`[Safety] Conversation limit exceeded for session ${sessionId}(${totalMessages} messages).Terminating.`);
+                throw new Error(`Conversation limit reached(${MAX_TOTAL_MSG_COUNT} messages).Please start a new session.`);
+            }
+            // 4. Content Filtering: Blacklisted words (configured per user/config)
+            const config = session.configId && session.userId
+                ? await this.repo.findConversationConfig(session.userId, session.configId)
+                : null;
+            const blacklistedWords = config?.blacklistedWords || [];
+            if (blacklistedWords.length > 0) {
+                const cleanContent = content.trim().toLowerCase();
+                const isBlacklisted = blacklistedWords.some(word => cleanContent.includes(word.toLowerCase()));
+                if (isBlacklisted) {
+                    console.log(`[Orchestrator] Ignored blacklisted content: "${content}"`);
+                    throw new Error('Message contains prohibited content.');
+                }
+            }
+            // Trigger message.user webhook (only for validated messages) - Fire-and-forget
+            this.webhookService.triggerUserMessage(session, userMessage).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+            // 5. Exit Phrase Detection (universal session termination)
+            // Default common exit phrases (English)
+            const DEFAULT_EXIT_PHRASES = ['goodbye', 'bye', 'stop session', 'end session', 'quit', 'exit'];
+            // Use config-specific exit phrases if available, otherwise use defaults
+            // If config provides phrases, merge with defaults to ensure common phrases always work
+            const configExitPhrases = config?.exitPhrases || [];
+            const EXIT_PHRASES = configExitPhrases.length > 0
+                ? [...DEFAULT_EXIT_PHRASES, ...configExitPhrases]
+                : DEFAULT_EXIT_PHRASES;
+            const lowerContent = content.toLowerCase();
+            const shouldEndSession = EXIT_PHRASES.some(phrase => lowerContent.includes(phrase));
+            if (shouldEndSession) {
+                console.log(`[Orchestrator] Exit phrase detected: "${content}"`);
+            }
+            const newMessages = [];
+            // 6. Language Detection (Smart & Optimized) - Will run in PARALLEL with Intent Detection
+            let detectedLanguage;
+            let languageName;
+            let languageChanged = false;
+            // Check if multi-lingual mode is enabled
+            const multiLingualEnabled = config?.multiLingualMode !== false; // Default true if not specified
+            const defaultLanguage = config?.defaultLanguage || 'en';
+            const previousLanguage = session.currentLanguage;
+            // 7. Check if we're in the middle of parameter collection
+            if (session.isCollectingParameters()) {
+                return await this.handleParameterCollection(session, content, newMessages);
+            }
+            // 6 & 8. PARALLEL EXECUTION: Run Language Detection and Intent Detection concurrently
+            // Both are independent LLM API calls - running in parallel saves 100-300ms
+            console.log(`[Orchestrator] Starting parallel language detection and intent classification...`);
+            const [languageResult, intentResult] = await Promise.all([
+                // Language Detection Promise
+                (async () => {
+                    if (multiLingualEnabled) {
+                        const shouldDetect = !previousLanguage ||
+                            this.languageDetector.hasCharacterSetChanged(content, previousLanguage);
+                        if (shouldDetect) {
+                            const languageHints = config?.supportedLanguages;
+                            const detected = await this.languageDetector.detectLanguage(content, languageHints);
+                            const name = this.languageDetector.getLanguageName(detected);
+                            const changed = previousLanguage && previousLanguage !== detected;
+                            if (changed) {
+                                console.log(`[Orchestrator] Language switched: ${previousLanguage} → ${detected} (${name})`);
+                            }
+                            else if (!previousLanguage) {
+                                console.log(`[Orchestrator] Language detected: ${detected} (${name})`);
+                            }
+                            session.setLanguage(detected);
+                            if (session.mode === 'VOICE' && this.voiceAdapter && 'setLanguage' in this.voiceAdapter) {
+                                this.voiceAdapter.setLanguage(detected);
+                            }
+                            return { detectedLanguage: detected, languageName: name, languageChanged: !!changed };
+                        }
+                        else {
+                            const detected = previousLanguage;
+                            const name = this.languageDetector.getLanguageName(detected);
+                            console.log(`[Orchestrator] Using cached language: ${detected} (${name})`);
+                            return { detectedLanguage: detected, languageName: name, languageChanged: false };
+                        }
+                    }
+                    else {
+                        const detected = defaultLanguage;
+                        const name = this.languageDetector.getLanguageName(detected);
+                        if (!session.currentLanguage) {
+                            console.log(`[Orchestrator] Multi - lingual mode disabled.Using default: ${detected} (${name})`);
+                            session.setLanguage(detected);
+                        }
+                        return { detectedLanguage: detected, languageName: name, languageChanged: false };
+                    }
+                })(),
+                // Intent Detection Promise (runs in parallel)
+                this.intent.detectIntent(session.getHistory(), session.agentPrompt, session.userId)
+            ]);
+            // Extract results from parallel execution
+            detectedLanguage = languageResult.detectedLanguage;
+            languageName = languageResult.languageName;
+            languageChanged = languageResult.languageChanged;
+            // 9. Collaborative mode: handle partial intents
+            if (session.conversationMode === 'collaborative' &&
+                intentResult.intentName &&
+                intentResult.missingRequiredParameters &&
+                intentResult.missingRequiredParameters.length > 0 &&
+                intentResult.confidence >= this.config.intent.confidenceThreshold) {
+                console.log(`[Orchestrator] COLLABORATIVE: Intent '${intentResult.intentName}' detected with missing parameters: ${intentResult.missingRequiredParameters.join(', ')} `);
+                return await this.startParameterCollection(session, intentResult, newMessages);
+            }
+            // 10. Execute workflow if intent is complete and confident
+            if (intentResult.intentName && intentResult.confidence >= this.config.intent.confidenceThreshold) {
+                console.log(`[Orchestrator] DECISION: Execute Workflow '${intentResult.intentName}'(Confidence ${intentResult.confidence} >= ${this.config.intent.confidenceThreshold})`);
+                // VERBAL ACKNOWLEDGMENT (Filler Phrase)
+                // Fetch full intent to check for processing messages
+                const fullIntent = await this.repo.findIntentByName(intentResult.intentName, session.userId);
+                if (fullIntent?.processingMessages && fullIntent.processingMessages.length > 0 && onIntermediateResponse) {
+                    const randomPhrase = fullIntent.processingMessages[Math.floor(Math.random() * fullIntent.processingMessages.length)];
+                    console.log(`[Orchestrator] Sending filler phrase: "${randomPhrase}"`);
+                    // Fire and forget? No, we should wait for it to start ensuring order?
+                    // Actually, TTS generation takes time. We want to start it concurrently with workflow if possible,
+                    // BUT if workflow is fast, we might get double audio overlap.
+                    // Given the goal is "filling silence", we should probably fire it.
+                    // However, `onIntermediateResponse` will likely queue audio.
+                    await onIntermediateResponse(randomPhrase);
+                }
+                // Update User Message Metadata with Detected Intent
+                userMessage.metadata = {
+                    ...userMessage.metadata,
+                    intent: {
+                        name: intentResult.intentName,
+                        confidence: intentResult.confidence,
+                        parameters: intentResult.payload
+                    }
+                };
+                // Trigger intent.detected webhook - Fire-and-forget
+                this.webhookService.triggerIntentDetected(session, intentResult).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+                if (fullIntent?.skipWorkflow) {
+                    console.log(`[Orchestrator] Intent '${intentResult.intentName}' marked as skipWorkflow. Skipping execution.`);
+                    // Inject Intent Context for LLM
+                    const contextMessage = new Message_1.Message({
+                        role: interfaces_1.Role.SYSTEM,
+                        content: `[System Info: User intent '${intentResult.intentName}' detected. This intent is informational/metadata-only (No Workflow). Answer the user naturally based on this intent.]`,
+                        timestamp: new Date()
+                    });
+                    // Transient history
+                    const transientHistory = [...session.getHistory(), contextMessage];
+                    const llmResponse = await this.llm.generateResponse(session.agentPrompt, transientHistory);
+                    const assistantMsg = Message_1.Message.assistant(llmResponse.content);
+                    session.addMessage(assistantMsg);
+                    newMessages.push(assistantMsg);
+                    // Trigger message.bot webhook
+                    if (this.webhookService) {
+                        this.webhookService.triggerBotMessage(session, assistantMsg).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+                    }
+                }
+                else {
+                    // Inject userId into payload for correct workflow lookup
+                    const workflowPayload = {
+                        ...intentResult.payload,
+                        userId: session.userId
+                    };
+                    const workflowResult = await this.workflow.executeWorkflow(intentResult.intentName, workflowPayload);
+                    let assistantContent;
+                    // CHECK: Did the workflow return an explicit final message?
+                    if (workflowResult.success && workflowResult.data && workflowResult.data.message) {
+                        console.log(`[Orchestrator] Workflow '${intentResult.intentName}' returned explicit final message. Skipping LLM generation.`);
+                        assistantContent = workflowResult.data.message;
+                    }
+                    else {
+                        // Fallback: Use LLM to generate response based on workflow result
+                        console.log(`[Orchestrator] Workflow '${intentResult.intentName}' executed without explicit final message. Using LLM to generate response.`);
+                        // Inject Workflow Result
+                        const workflowContextMessage = new Message_1.Message({
+                            role: interfaces_1.Role.SYSTEM,
+                            content: `[System Info: Workflow detected '${intentResult.intentName}'.Execution Result: ${JSON.stringify(workflowResult.data)}. Use this to answer the user.]`,
+                            timestamp: new Date()
+                        });
+                        // Transient history
+                        const transientHistory = [...session.getHistory(), workflowContextMessage];
+                        const llmResponse = await this.llm.generateResponse(session.agentPrompt, transientHistory);
+                        assistantContent = llmResponse.content;
+                    }
+                    const assistantMsg = Message_1.Message.assistant(assistantContent);
+                    session.addMessage(assistantMsg);
+                    newMessages.push(assistantMsg);
+                    // Trigger workflow webhook based on success/failure
+                    if (workflowResult.success) {
+                        // Update User Message Metadata with Workflow Execution
+                        userMessage.metadata = {
+                            ...userMessage.metadata,
+                            workflow: {
+                                id: intentResult.intentName,
+                                result: workflowResult.data
+                            }
+                        };
+                        // Fire-and-forget
+                        this.webhookService.triggerWorkflowExecuted(session, {
+                            workflowName: intentResult.intentName,
+                            parameters: intentResult.payload,
+                            result: workflowResult
+                        }).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+                    }
+                    else if (workflowResult.error === 'NO_WORKFLOW_MATCHED') {
+                        // Smart Workflow handling:
+                        // If no workflow matches, we treat it as "Intent detected but no specific logic".
+                        // We do NOT fire a failure webhook, but instead let the LLM handle it naturally.
+                        console.log(`[Orchestrator] Smart Workflow: No workflow found for '${intentResult.intentName}'. Falling back to LLM.`);
+                        // Inject Context for LLM so it knows intent was detected but handled generically
+                        const workflowContextMessage = new Message_1.Message({
+                            role: interfaces_1.Role.SYSTEM,
+                            content: `[System Info: User intent '${intentResult.intentName}' detected, but no specific workflow is configured. Answer the user naturally based on this intent.]`,
+                            timestamp: new Date()
+                        });
+                        // Transient history
+                        const transientHistory = [...session.getHistory(), workflowContextMessage];
+                        const llmResponse = await this.llm.generateResponse(session.agentPrompt, transientHistory);
+                        assistantContent = llmResponse.content;
+                        // Note: We intentionally DO NOT update userMessage metadata with 'workflow'
+                        // and DO NOT trigger workflow.failed or workflow.executed webhooks.
+                        // This makes the lack of workflow invisible to the outside world (except for the intent detection).
+                    }
+                    else {
+                        // Update User Message Metadata with Workflow Failure
+                        userMessage.metadata = {
+                            ...userMessage.metadata,
+                            workflow: {
+                                id: intentResult.intentName,
+                                error: workflowResult.error
+                            }
+                        };
+                        // Fire-and-forget
+                        this.webhookService.triggerWorkflowFailed(session, {
+                            workflowName: intentResult.intentName,
+                            parameters: intentResult.payload,
+                            error: workflowResult.error
+                        }).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+                    }
+                    // Trigger message.bot webhook - Fire-and-forget
+                    if (this.webhookService) {
+                        this.webhookService.triggerBotMessage(session, assistantMsg).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+                    }
+                }
+            }
+            else {
+                // 11. Fallback to standard LLM with language-specific prompt
+                if (intentResult.intentName) {
+                    console.log(`[Orchestrator] DECISION: Skip Workflow '${intentResult.intentName}'(Confidence ${intentResult.confidence} < ${this.config.intent.confidenceThreshold}).Proceeding with Standard LLM.`);
+                    // Trigger intent.failed webhook - Fire-and-forget
+                    this.webhookService.triggerIntentFailed(session, intentResult).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+                }
+                else {
+                    console.log(`[Orchestrator] DECISION: No Intent Detected.Proceeding with Standard LLM.`);
+                }
+                // Inject language instruction into system prompt
+                const languagePrompt = `${session.agentPrompt} \n\n[LANGUAGE INSTRUCTION]\n - The user is speaking in ${languageName} (${detectedLanguage}).\n - You MUST respond in ${languageName}.\n - Match the user's language exactly.`;
+                const llmResponse = await this.llm.generateResponse(languagePrompt, session.getHistory());
+                const assistantMsg = Message_1.Message.assistant(llmResponse.content, { detectedLanguage });
+                session.addMessage(assistantMsg);
+                newMessages.push(assistantMsg);
+                // Trigger message.bot webhook - Fire-and-forget
+                this.webhookService.triggerBotMessage(session, assistantMsg).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+            }
+            // 12. Save
+            await this.repo.saveSession(session);
+            return {
+                messages: newMessages,
+                metadata: {
+                    intent: intentResult.intentName,
+                    confidence: intentResult.confidence,
+                    workflowExecuted: (intentResult.intentName && intentResult.confidence >= this.config.intent.confidenceThreshold) ? intentResult.intentName : null,
+                    shouldEndSession: shouldEndSession,
+                    detectedLanguage: detectedLanguage,
+                    languageName: languageName,
+                    languageChanged: languageChanged
+                }
+            };
+        }
+        catch (error) {
+            // Fire-and-forget error webhook
+            this.webhookService.triggerErrorOccurred(session, error).catch(e => console.error('[Orchestrator] Webhook failed:', e));
+            throw error;
+        }
+    }
+    /**
+     * Start parameter collection for a detected intent with missing parameters
+     */
+    async startParameterCollection(session, intentResult, newMessages) {
+        // Initialize parameter collection state
+        session.startParameterCollection({
+            intentName: intentResult.intentName,
+            detectedParameters: intentResult.payload || {},
+            missingParameters: intentResult.missingRequiredParameters,
+            attemptCount: 0,
+            initialConfidence: intentResult.confidence
+        });
+        // Generate clarifying question
+        const question = await this.generateClarificationQuestion(session, intentResult.intentName, intentResult.missingRequiredParameters);
+        const assistantMsg = Message_1.Message.assistant(question);
+        session.addMessage(assistantMsg);
+        newMessages.push(assistantMsg);
+        await this.repo.saveSession(session);
+        return {
+            messages: newMessages,
+            metadata: {
+                intent: intentResult.intentName,
+                confidence: intentResult.confidence,
+                collectingParameters: true,
+                missingParameters: intentResult.missingRequiredParameters
+            }
+        };
+    }
+    /**
+     * Handle parameter collection from user response
+     */
+    async handleParameterCollection(session, userResponse, newMessages) {
+        const collectionState = session.getParameterCollectionState();
+        const MAX_ATTEMPTS = 3;
+        // Check if max attempts reached
+        if (collectionState.attemptCount >= MAX_ATTEMPTS) {
+            console.log('[Orchestrator] Max clarification attempts reached. Falling back to LLM.');
+            session.clearParameterCollection();
+            const llmResponse = await this.llm.generateResponse(session.agentPrompt, session.getHistory());
+            const assistantMsg = Message_1.Message.assistant(llmResponse.content);
+            session.addMessage(assistantMsg);
+            newMessages.push(assistantMsg);
+            await this.repo.saveSession(session);
+            return {
+                messages: newMessages,
+                metadata: { maxAttemptsReached: true }
+            };
+        }
+        // Get the intent definition
+        const allIntents = await this.intent.matchIntents(collectionState.intentName, 100);
+        const matchedIntent = allIntents.find((m) => m.intent.name === collectionState.intentName);
+        if (!matchedIntent) {
+            session.clearParameterCollection();
+            throw new Error(`Intent ${collectionState.intentName} not found`);
+        }
+        const intent = matchedIntent.intent;
+        // Extract parameters from user response using IntentMatcher
+        // We need to access the matcher through the intent service
+        // For now, we'll use a simpler approach with the LLM directly
+        const extractedParams = await this.extractParametersFromResponse(userResponse, intent, collectionState.missingParameters);
+        // Merge with existing parameters
+        const allParameters = {
+            ...collectionState.detectedParameters,
+            ...extractedParams
+        };
+        // Check what's still missing
+        const stillMissing = collectionState.missingParameters.filter(paramName => {
+            const value = allParameters[paramName];
+            return value === null || value === undefined || value === '' ||
+                (Array.isArray(value) && value.length === 0);
+        });
+        if (stillMissing.length === 0) {
+            // All parameters collected! Execute workflow
+            console.log('[Orchestrator] All parameters collected. Executing workflow.');
+            session.clearParameterCollection();
+            const workflowPayload = {
+                ...allParameters,
+                userId: session.userId
+            };
+            const workflowResult = await this.workflow.executeWorkflow(collectionState.intentName, workflowPayload);
+            const workflowContextMessage = new Message_1.Message({
+                role: interfaces_1.Role.SYSTEM,
+                content: `[System Info: Workflow detected '${collectionState.intentName}'. Execution Result: ${JSON.stringify(workflowResult.data)}. Use this to answer the user.]`,
+                timestamp: new Date()
+            });
+            // Update the last user message with intent and workflow metadata
+            const lastUserMessage = session.messages.slice().reverse().find(m => m.role === interfaces_1.Role.USER);
+            if (lastUserMessage) {
+                lastUserMessage.metadata = {
+                    ...lastUserMessage.metadata,
+                    intent: {
+                        name: collectionState.intentName,
+                        confidence: collectionState.initialConfidence, // Use original detection confidence
+                        originalConfidence: collectionState.initialConfidence,
+                        parameters: allParameters
+                    },
+                    workflow: {
+                        id: collectionState.intentName,
+                        result: workflowResult.data
+                    }
+                };
+            }
+            const transientHistory = [...session.getHistory(), workflowContextMessage];
+            const llmResponse = await this.llm.generateResponse(session.agentPrompt, transientHistory);
+            const assistantMsg = Message_1.Message.assistant(llmResponse.content);
+            session.addMessage(assistantMsg);
+            newMessages.push(assistantMsg);
+            await this.repo.saveSession(session);
+            return {
+                messages: newMessages,
+                metadata: {
+                    intent: collectionState.intentName,
+                    confidence: 1.0, // High confidence after collection
+                    workflowExecuted: collectionState.intentName,
+                    parametersCollected: true
+                }
+            };
+        }
+        else {
+            // Still missing parameters, ask again
+            session.updateParameterCollection(extractedParams, stillMissing);
+            const question = await this.generateClarificationQuestion(session, collectionState.intentName, stillMissing);
+            const assistantMsg = Message_1.Message.assistant(question);
+            session.addMessage(assistantMsg);
+            newMessages.push(assistantMsg);
+            await this.repo.saveSession(session);
+            return {
+                messages: newMessages,
+                metadata: {
+                    intent: collectionState.intentName,
+                    collectingParameters: true,
+                    missingParameters: stillMissing,
+                    attemptCount: collectionState.attemptCount
+                }
+            };
+        }
+    }
+    /**
+     * Generate a clarification question for missing parameters
+     */
+    async generateClarificationQuestion(session, intentName, missingParameters) {
+        // Get intent details for better question generation
+        const allIntents = await this.intent.matchIntents(intentName, 100);
+        const matchedIntent = allIntents.find((m) => m.intent.name === intentName);
+        let fieldInfo = '';
+        if (matchedIntent) {
+            const fields = [...matchedIntent.intent.required_fields, ...(matchedIntent.intent.optional_fields || [])];
+            fieldInfo = missingParameters.map(paramName => {
+                const field = fields.find(f => f.name === paramName);
+                if (!field)
+                    return paramName;
+                const displayName = field.displayName || paramName;
+                const description = field.description || '';
+                return `${displayName}${description ? ' (' + description + ')' : ''}`;
+            }).join(', ');
+        }
+        else {
+            fieldInfo = missingParameters.join(', ');
+        }
+        const prompt = `
+You are a helpful assistant collecting information from the user.
+The user wants to perform: ${intentName}
+You need to ask for the following missing information: ${fieldInfo}
+
+Generate a natural, friendly question to ask the user for this information.
+Be concise and conversational. Ask for the most important missing parameter first.
+If there are multiple missing parameters, focus on one at a time.
+
+Question:`;
+        const response = await this.llm.generateContent(prompt);
+        return response.trim();
+    }
+    /**
+     * Extract parameters from user response
+     */
+    async extractParametersFromResponse(userResponse, intent, missingParameters) {
+        const extractionPrompt = `
+You are a parameter extraction assistant. Extract the following parameters from the user's response.
+
+Intent: ${intent.name}
+Missing Parameters: ${missingParameters.join(', ')}
+
+User Response: "${userResponse}"
+
+For each missing parameter, try to extract its value from the user's response.
+Return ONLY a valid JSON object with the extracted parameters.
+If a parameter is not found, omit it from the response.
+
+Example:
+{
+  "date": "2024-01-15",
+  "time": "14:00"
+}
+`;
+        try {
+            const response = await this.llm.generateResponse(extractionPrompt, []);
+            const content = response.content.trim();
+            // Try to parse JSON from the response
+            const jsonMatch = content.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[0]);
+            }
+            console.warn('[Orchestrator] Could not extract JSON from LLM response:', content);
+            return {};
+        }
+        catch (error) {
+            console.error('[Orchestrator] Error extracting parameters:', error);
+            return {};
+        }
+    }
+    /**
+     * Handle incoming voice message (audio input)
+     * Converts speech to text, processes the message, and optionally returns audio response
+     * @param sessionId Session identifier
+     * @param audioBase64 Base64-encoded audio data (WAV format recommended)
+     * @returns Transcript, messages, and optional audio response
+     */
+    /**
+     * Get voice response for any text
+     * Useful for converting assistant messages to speech
+     * @param text Text to convert to speech
+     * @returns Audio data as Uint8Array
+     */
+    async getVoiceResponse(text) {
+        if (!this.voiceAdapter) {
+            throw new Error('Voice adapter not configured. Please provide an IVoiceAdapter when creating the Orchestrator.');
+        }
+        console.log(`[Orchestrator] Generating voice response for text: "${text.substring(0, 50)}..."`);
+        return await this.voiceAdapter.textToSpeech(text);
+    }
+    /**
+     * Transcribe audio and record it to storage
+     */
+    async transcribeAudio(sessionId, audioBase64) {
+        if (!this.voiceAdapter)
+            throw new Error('Voice adapter missing');
+        const transcript = await this.voiceAdapter.speechToText(audioBase64);
+        if (this.audioStorage) {
+            const buffer = Buffer.from(audioBase64, 'base64');
+            // Get format metadata from voice adapter (defaults to WAV if not provided)
+            const formatMetadata = this.voiceAdapter.getSTTInputFormat ? this.voiceAdapter.getSTTInputFormat() : { format: 'wav' };
+            this.audioStorage.appendAudio(sessionId, buffer, formatMetadata).catch(e => console.error('[Orchestrator] Failed to record user audio', e));
+        }
+        return transcript;
+    }
+    /**
+     * Synthesize audio and record it to storage
+     */
+    async synthesizeResponse(sessionId, text) {
+        if (!this.voiceAdapter)
+            throw new Error('Voice adapter missing');
+        const audio = await this.voiceAdapter.textToSpeech(text);
+        if (this.audioStorage) {
+            const buffer = Buffer.from(audio);
+            // Get format metadata from voice adapter
+            const formatMetadata = this.voiceAdapter.getTTSOutputFormat();
+            this.audioStorage.appendAudio(sessionId, buffer, formatMetadata).catch(e => console.error('[Orchestrator] Failed to record bot audio', e));
+        }
+        return audio;
+    }
+    async completeSession(sessionId, recordingUrl) {
+        const session = await this.repo.findSessionById(sessionId);
+        if (!session) {
+            throw new errors_1.SessionNotFoundError(sessionId);
+        }
+        // Generate Summary
+        const messages = session.getHistory();
+        if (messages.length > 0) {
+            // Get config to use defaultLanguage for summary
+            const config = session.configId && session.userId
+                ? await this.repo.findConversationConfig(session.userId, session.configId)
+                : null;
+            const defaultLanguage = config?.defaultLanguage || 'en';
+            const languageName = this.languageDetector.getLanguageName(defaultLanguage);
+            const transcript = messages.map(m => `${m.role}: ${m.content}`).join('\n');
+            const summaryPrompt = `
+Please summarize the following conversation in a concise paragraph in ${languageName}. 
+Highlight the main user intent, key actions taken, and the final outcome.
+Respond in ${languageName} language.
+
+Conversation:
+${transcript}
+
+Summary:`;
+            try {
+                // If generateContent is available (some adapters might not implement it), use it.
+                // Otherwise fallback to generateResponse.
+                let summaryText = '';
+                if (this.llm.generateContent) {
+                    summaryText = await this.llm.generateContent(summaryPrompt);
+                }
+                else {
+                    const response = await this.llm.generateResponse(summaryPrompt, []);
+                    summaryText = response.content;
+                }
+                session.summary = summaryText.trim();
+            }
+            catch (error) {
+                console.error('[Orchestrator] Failed to generate summary:', error);
+                session.summary = "Summary generation failed or not supported.";
+            }
+        }
+        else {
+            session.summary = "No conversation history to summarize.";
+        }
+        // Mark as completed
+        session.updateStatus(interfaces_1.SessionStatus.COMPLETED);
+        // Save (Repository should handle permanent persistence for COMPLETED status)
+        await this.repo.saveSession(session);
+        // If recordingUrl was not passed but storage exists, try to finalize it now
+        if (!recordingUrl && this.audioStorage && session.mode === 'VOICE') {
+            try {
+                const url = await this.audioStorage.finalizeSession(sessionId);
+                console.log(`[Orchestrator] Finalized storage for session ${sessionId}. URL: ${url}`);
+                recordingUrl = url; // Update local variable to pass to webhook
+            }
+            catch (e) {
+                console.error('[Orchestrator] Failed to finalize storage', e);
+            }
+        }
+        // Trigger session.ended webhook (includes full transcript and summary)
+        await this.webhookService.triggerSessionEnded(session, recordingUrl);
+        console.log(`[Orchestrator] Session ${sessionId} completed and summarized.`);
+        return session;
+    }
+    async getSessionAudio(sessionId) {
+        if (this.audioStorage) {
+            return await this.audioStorage.getSessionAudio(sessionId);
+        }
+        return null;
+    }
+}
+exports.Orchestrator = Orchestrator;
+//# sourceMappingURL=Orchestrator.js.map