@memberjunction/ng-conversations 2.104.0

package/dist/lib/components/message/message-input.component.js

@@ -0,0 +1,1159 @@
+import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
+import { Metadata, RunView } from '@memberjunction/core';
+import { GraphQLAIClient } from '@memberjunction/graphql-dataprovider';
+import { AIEngineBase } from '@memberjunction/ai-engine-base';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/dialog.service";
+import * as i2 from "../../services/toast.service";
+import * as i3 from "../../services/conversation-agent.service";
+import * as i4 from "../../services/conversation-state.service";
+import * as i5 from "../../services/active-tasks.service";
+import * as i6 from "../../services/mention-autocomplete.service";
+import * as i7 from "../../services/mention-parser.service";
+import * as i8 from "@angular/common";
+import * as i9 from "@angular/forms";
+import * as i10 from "../mention/mention-dropdown.component";
+const _c0 = ["messageTextarea"];
+function MessageInputComponent_div_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 10);
+    i0.ɵɵelement(1, "i", 11);
+    i0.ɵɵelementStart(2, "span");
+    i0.ɵɵtext(3, "AI is responding...");
+    i0.ɵɵelementEnd()();
+} }
+export class MessageInputComponent {
+    dialogService;
+    toastService;
+    agentService;
+    conversationState;
+    activeTasks;
+    mentionAutocomplete;
+    mentionParser;
+    conversationId;
+    currentUser;
+    disabled = false;
+    placeholder = 'Type a message... (Ctrl+Enter to send)';
+    parentMessageId; // Optional: for replying in threads
+    conversationHistory = []; // For agent context
+    messageSent = new EventEmitter();
+    agentResponse = new EventEmitter();
+    agentRunDetected = new EventEmitter();
+    artifactCreated = new EventEmitter();
+    conversationRenamed = new EventEmitter();
+    messageTextarea;
+    messageText = '';
+    isSending = false;
+    isProcessing = false; // True when waiting for agent/naming response
+    converationManagerAgent = null;
+    // Mention autocomplete state
+    showMentionDropdown = false;
+    mentionSuggestions = [];
+    mentionDropdownPosition = { top: 0, left: 0 };
+    mentionDropdownShowAbove = false; // Controls transform direction
+    mentionStartIndex = -1;
+    mentionQuery = '';
+    constructor(dialogService, toastService, agentService, conversationState, activeTasks, mentionAutocomplete, mentionParser) {
+        this.dialogService = dialogService;
+        this.toastService = toastService;
+        this.agentService = agentService;
+        this.conversationState = conversationState;
+        this.activeTasks = activeTasks;
+        this.mentionAutocomplete = mentionAutocomplete;
+        this.mentionParser = mentionParser;
+    }
+    async ngOnInit() {
+        this.converationManagerAgent = await this.agentService.getConversationManagerAgent();
+        // Initialize mention autocomplete
+        await this.mentionAutocomplete.initialize(this.currentUser);
+    }
+    get canSend() {
+        return !this.disabled && !this.isSending && this.messageText.trim().length > 0;
+    }
+    /**
+     * Handle input events to detect @ mentions
+     */
+    onInput(event) {
+        const textarea = event.target;
+        const cursorPos = textarea.selectionStart;
+        const text = textarea.value;
+        // Check if we're typing after an @ symbol
+        const textBeforeCursor = text.substring(0, cursorPos);
+        const mentionMatch = textBeforeCursor.match(/@(\S*)$/);
+        if (mentionMatch) {
+            // We found an @ mention being typed
+            this.mentionStartIndex = cursorPos - mentionMatch[0].length;
+            this.mentionQuery = mentionMatch[1] || '';
+            console.log('[MentionInput] Detected @mention:', this.mentionQuery);
+            // Get suggestions
+            this.mentionSuggestions = this.mentionAutocomplete.getSuggestions(this.mentionQuery);
+            console.log('[MentionInput] Got suggestions:', this.mentionSuggestions.length, this.mentionSuggestions);
+            // Calculate dropdown position
+            this.calculateDropdownPosition(textarea);
+            // Show dropdown if we have suggestions OR to show empty state
+            this.showMentionDropdown = true;
+            console.log('[MentionInput] Showing dropdown:', this.showMentionDropdown);
+        }
+        else {
+            // No @ mention, close dropdown
+            this.closeMentionDropdown();
+        }
+    }
+    /**
+     * Handle keydown events in the textarea
+     * - Enter alone: Send message (unless dropdown is open)
+     * - Shift+Enter: Add new line
+     * - Arrow keys, Tab, Escape: Handle mention dropdown if open
+     */
+    onKeyDown(event) {
+        // If mention dropdown is open, let it handle certain keys
+        if (this.showMentionDropdown) {
+            if (['ArrowDown', 'ArrowUp', 'Enter', 'Tab', 'Escape'].includes(event.key)) {
+                // These keys are handled by the dropdown component
+                return;
+            }
+        }
+        // Regular key handling
+        if (event.key === 'Enter' && !event.shiftKey) {
+            // Prevent default behavior (adding newline)
+            event.preventDefault();
+            // Send the message
+            this.onSend();
+        }
+        // If Shift+Enter, allow default behavior (add newline)
+    }
+    /**
+     * Calculate position for mention dropdown
+     * Keeps dropdown anchored to textarea edge regardless of content size
+     */
+    calculateDropdownPosition(textarea) {
+        const rect = textarea.getBoundingClientRect();
+        const container = textarea.closest('.message-input-container');
+        const containerRect = container?.getBoundingClientRect();
+        if (!containerRect) {
+            // Fallback to absolute positioning
+            this.mentionDropdownPosition = {
+                top: rect.bottom + window.scrollY + 4,
+                left: rect.left + window.scrollX
+            };
+            return;
+        }
+        // Check if there's enough space below the textarea
+        const spaceBelow = window.innerHeight - rect.bottom;
+        const spaceAbove = rect.top;
+        this.mentionDropdownShowAbove = spaceBelow < 200 && spaceAbove > spaceBelow;
+        // Position relative to the container
+        // Always anchor to the textarea edge so dropdown stays in place as content changes
+        if (this.mentionDropdownShowAbove) {
+            // Show above the textarea - anchor to the TOP of the textarea
+            // CSS transform will make it grow upward from this anchor point
+            this.mentionDropdownPosition = {
+                top: rect.top - containerRect.top - 4, // Anchor just above textarea
+                left: rect.left - containerRect.left
+            };
+        }
+        else {
+            // Show below the textarea (default) - anchor to the BOTTOM of the textarea
+            this.mentionDropdownPosition = {
+                top: rect.bottom - containerRect.top + 4,
+                left: rect.left - containerRect.left
+            };
+        }
+    }
+    /**
+     * Handle mention suggestion selection
+     */
+    onMentionSelected(suggestion) {
+        if (this.mentionStartIndex === -1)
+            return;
+        const textarea = this.messageTextarea.nativeElement;
+        const cursorPos = textarea.selectionStart;
+        // Replace the @mention text with the selected name
+        const beforeMention = this.messageText.substring(0, this.mentionStartIndex);
+        const afterMention = this.messageText.substring(cursorPos);
+        // If name has spaces, wrap in quotes
+        const mentionText = suggestion.displayName.includes(' ')
+            ? `@"${suggestion.displayName}" `
+            : `@${suggestion.displayName} `;
+        this.messageText = beforeMention + mentionText + afterMention;
+        // Close dropdown
+        this.closeMentionDropdown();
+        // Set cursor position after the mention
+        const newCursorPos = beforeMention.length + mentionText.length;
+        setTimeout(() => {
+            textarea.selectionStart = newCursorPos;
+            textarea.selectionEnd = newCursorPos;
+            textarea.focus();
+        }, 0);
+    }
+    /**
+     * Close mention dropdown
+     */
+    closeMentionDropdown() {
+        this.showMentionDropdown = false;
+        this.mentionSuggestions = [];
+        this.mentionStartIndex = -1;
+        this.mentionQuery = '';
+    }
+    async onSend() {
+        if (!this.canSend)
+            return;
+        this.isSending = true;
+        try {
+            const md = new Metadata();
+            const detail = await md.GetEntityObject('Conversation Details', this.currentUser);
+            detail.ConversationID = this.conversationId;
+            detail.Message = this.messageText.trim();
+            detail.Role = 'User';
+            // Parse mentions from message (not stored, used for routing only)
+            const mentionResult = this.mentionParser.parseMentions(detail.Message, this.mentionAutocomplete.getAvailableAgents(), this.mentionAutocomplete.getAvailableUsers());
+            console.log('[MentionInput] Parsing message for routing:', detail.Message);
+            console.log('[MentionInput] Found mentions:', mentionResult);
+            console.log('[MentionInput] Agent mention:', mentionResult.agentMention);
+            // Set ParentID if this is a thread reply
+            if (this.parentMessageId) {
+                detail.ParentID = this.parentMessageId;
+            }
+            const saved = await detail.Save();
+            if (saved) {
+                this.messageSent.emit(detail);
+                this.messageText = '';
+                // Check if this is the first message in the conversation
+                const isFirstMessage = this.conversationHistory.length === 0;
+                // Determine routing: @mention > last agent context > Conversation Manager
+                if (mentionResult.agentMention) {
+                    // Direct @mention - skip Conversation Manager, invoke agent directly
+                    console.log('🎯 Direct @mention detected, bypassing Conversation Manager');
+                    if (isFirstMessage) {
+                        Promise.all([
+                            this.invokeAgentDirectly(detail, mentionResult.agentMention, this.conversationId),
+                            this.nameConversation(detail.Message)
+                        ]);
+                    }
+                    else {
+                        this.invokeAgentDirectly(detail, mentionResult.agentMention, this.conversationId);
+                    }
+                }
+                else {
+                    // Check if user is replying to an agent (implicit continuation)
+                    const lastAIMessage = this.conversationHistory
+                        .slice()
+                        .reverse()
+                        .find(msg => msg.Role === 'AI' &&
+                        msg.AgentID &&
+                        msg.AgentID !== this.converationManagerAgent?.ID);
+                    if (lastAIMessage && lastAIMessage.AgentID) {
+                        // Continue with same agent - skip Conversation Manager
+                        console.log('🔄 Implicit continuation detected, continuing with last agent');
+                        if (isFirstMessage) {
+                            Promise.all([
+                                this.continueWithAgent(detail, lastAIMessage.AgentID, this.conversationId),
+                                this.nameConversation(detail.Message)
+                            ]);
+                        }
+                        else {
+                            this.continueWithAgent(detail, lastAIMessage.AgentID, this.conversationId);
+                        }
+                    }
+                    else {
+                        // No context - use Conversation Manager
+                        console.log('🤖 No agent context, using Conversation Manager');
+                        if (isFirstMessage) {
+                            Promise.all([
+                                this.processMessageThroughAgent(detail, mentionResult),
+                                this.nameConversation(detail.Message)
+                            ]);
+                        }
+                        else {
+                            this.processMessageThroughAgent(detail, mentionResult);
+                        }
+                    }
+                }
+                // Focus back on textarea
+                setTimeout(() => {
+                    if (this.messageTextarea && this.messageTextarea.nativeElement) {
+                        this.messageTextarea.nativeElement.focus();
+                    }
+                }, 100);
+            }
+            else {
+                console.error('Failed to send message:', detail.LatestResult?.Message);
+                this.toastService.error('Failed to send message. Please try again.');
+            }
+        }
+        catch (error) {
+            console.error('Error sending message:', error);
+            this.toastService.error('Error sending message. Please try again.');
+        }
+        finally {
+            this.isSending = false;
+        }
+    }
+    /**
+     * Create a progress callback for agent execution
+     * This callback updates both the active task and the ConversationDetail message
+     * IMPORTANT: Filters by agentRunId to prevent cross-contamination when multiple agents run in parallel
+     */
+    createProgressCallback(conversationDetailId, agentName) {
+        return async (progress) => {
+            // Extract agentRunId from progress metadata
+            const progressAgentRunId = progress.metadata?.agentRunId;
+            // Format progress message with visual indicator
+            const progressText = progress.message;
+            // Update the active task with progress details (if it exists)
+            this.activeTasks.updateStatusByConversationDetailId(conversationDetailId, progressText);
+            // Update the ConversationDetail message in real-time
+            try {
+                const md = new Metadata();
+                const conversationDetail = await md.GetEntityObject('Conversation Details', this.currentUser);
+                if (await conversationDetail.Load(conversationDetailId)) {
+                    // Skip progress updates if message is already complete
+                    if (conversationDetail.Status === 'Complete') {
+                        console.log(`[${agentName}] Skipping progress update - message already complete`);
+                        return;
+                    }
+                    // CRITICAL: Only update if agentRunIds match (prevents cross-contamination)
+                    const storedAgentRunId = conversationDetail.AgentRunID;
+                    // If AgentRunID not yet set, set it from the first progress update
+                    if (!storedAgentRunId && progressAgentRunId) {
+                        conversationDetail.AgentRunID = progressAgentRunId;
+                        console.log(`[${agentName}] Setting AgentRunID from progress update:`, progressAgentRunId);
+                        // Emit event to parent so it can load the agent run into the map immediately
+                        this.agentRunDetected.emit({
+                            conversationDetailId,
+                            agentRunId: progressAgentRunId
+                        });
+                    }
+                    // If we have both IDs, verify they match before updating
+                    else if (progressAgentRunId && storedAgentRunId) {
+                        if (progressAgentRunId !== storedAgentRunId) {
+                            console.log(`[${agentName}] Skipping progress update - agentRunId mismatch:`, {
+                                progressAgentRunId,
+                                storedAgentRunId,
+                                conversationDetailId
+                            });
+                            return; // Skip this update - it's for a different agent run
+                        }
+                    }
+                    conversationDetail.Message = progressText;
+                    await conversationDetail.Save();
+                    // Emit update to trigger UI refresh
+                    this.messageSent.emit(conversationDetail);
+                }
+            }
+            catch (error) {
+                console.warn('Failed to save progress update to ConversationDetail:', error);
+            }
+            console.log(`[${agentName}] Progress: ${progress.step} - ${progress.message} (${progress.percentage}%)`, {
+                agentRunId: progressAgentRunId,
+                conversationDetailId
+            });
+        };
+    }
+    /**
+     * Process the message through agents (multi-stage: Conversation Manager -> possible sub-agent)
+     * Only called when there's no @mention and no implicit agent context
+     */
+    async processMessageThroughAgent(userMessage, mentionResult) {
+        let taskId = null;
+        let conversationManagerMessage = null;
+        // CRITICAL: Capture conversationId from user message at start
+        // This prevents race condition when user switches conversations during async processing
+        const conversationId = userMessage.ConversationID;
+        try {
+            // Create AI message for Conversation Manager BEFORE invoking
+            const md = new Metadata();
+            conversationManagerMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            conversationManagerMessage.ConversationID = conversationId;
+            conversationManagerMessage.Role = 'AI';
+            conversationManagerMessage.Message = '⏳ Starting...';
+            conversationManagerMessage.ParentID = userMessage.ID;
+            conversationManagerMessage.Status = 'In-Progress';
+            conversationManagerMessage.HiddenToUser = false;
+            // Use the preloaded Conversation Manager agent instead of looking it up
+            if (this.converationManagerAgent?.ID) {
+                conversationManagerMessage.AgentID = this.converationManagerAgent.ID;
+            }
+            await conversationManagerMessage.Save();
+            this.messageSent.emit(conversationManagerMessage);
+            // Use Conversation Manager to evaluate and route
+            // Stage 1: Conversation Manager evaluates the message
+            taskId = this.activeTasks.add({
+                agentName: 'Conversation Manager',
+                status: 'Evaluating message...',
+                relatedMessageId: userMessage.ID,
+                conversationDetailId: conversationManagerMessage.ID
+            });
+            const result = await this.agentService.processMessage(conversationId, userMessage, this.conversationHistory, conversationManagerMessage.ID, this.createProgressCallback(conversationManagerMessage.ID, 'Conversation Manager'));
+            // Remove Conversation Manager from active tasks
+            if (taskId) {
+                this.activeTasks.remove(taskId);
+                taskId = null;
+            }
+            if (!result || !result.success) {
+                // Evaluation failed
+                conversationManagerMessage.Status = 'Error';
+                conversationManagerMessage.Message = `❌ Evaluation failed`;
+                conversationManagerMessage.Error = result?.agentRun?.ErrorMessage || 'Agent evaluation failed';
+                await conversationManagerMessage.Save();
+                this.messageSent.emit(conversationManagerMessage);
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+                console.warn('⚠️ Conversation Manager failed:', result?.agentRun?.ErrorMessage);
+                return;
+            }
+            console.log('🤖 Conversation Manager Response:', {
+                finalStep: result.agentRun.FinalStep,
+                hasPayload: !!result.payload,
+                hasMessage: !!result.agentRun.Message
+            });
+            // Stage 2: Check for sub-agent invocation
+            if (result.agentRun.FinalStep === 'Success' && result.payload?.invokeAgent) {
+                // Reuse the existing conversationManagerMessage instead of creating new ones
+                await this.handleSubAgentInvocation(userMessage, result, this.conversationId, conversationManagerMessage);
+            }
+            // Stage 3: Direct chat response from Conversation Manager
+            else if (result.agentRun.FinalStep === 'Chat' && result.agentRun.Message) {
+                // Update the existing message with the response
+                conversationManagerMessage.Message = result.agentRun.Message;
+                conversationManagerMessage.Status = 'Complete';
+                if (result.agentRun.ID) {
+                    conversationManagerMessage.AgentRunID = result.agentRun.ID;
+                }
+                await conversationManagerMessage.Save();
+                this.messageSent.emit(conversationManagerMessage);
+                // Handle artifacts if any
+                if (result.payload && Object.keys(result.payload).length > 0) {
+                    await this.createArtifactFromPayload(result.payload, conversationManagerMessage, result.agentRun.AgentID);
+                    console.log('🎨 Artifact created and linked to Conversation Manager message');
+                    this.messageSent.emit(conversationManagerMessage);
+                }
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+            // Stage 4: Silent observation - check for agent continuity
+            else {
+                console.log('🔇 Conversation Manager chose to observe silently');
+                // Hide the Conversation Manager message
+                conversationManagerMessage.HiddenToUser = true;
+                conversationManagerMessage.Status = 'Complete';
+                await conversationManagerMessage.Save();
+                this.messageSent.emit(conversationManagerMessage);
+                await this.handleSilentObservation(userMessage, this.conversationId);
+            }
+        }
+        catch (error) {
+            console.error('❌ Error processing message through agents:', error);
+            // Update conversationManagerMessage status to Error
+            if (conversationManagerMessage && conversationManagerMessage.ID) {
+                conversationManagerMessage.Status = 'Error';
+                conversationManagerMessage.Message = `❌ Error: ${String(error)}`;
+                conversationManagerMessage.Error = String(error);
+                await conversationManagerMessage.Save();
+                this.messageSent.emit(conversationManagerMessage);
+            }
+            // Mark user message as complete
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+            // Clean up active task
+            if (taskId) {
+                this.activeTasks.remove(taskId);
+            }
+        }
+    }
+    /**
+     * Handle sub-agent invocation based on Conversation Manager's payload
+     * Reuses the existing conversationManagerMessage to avoid creating multiple records
+     */
+    async handleSubAgentInvocation(userMessage, managerResult, conversationId, conversationManagerMessage) {
+        const payload = managerResult.payload;
+        const agentName = payload.invokeAgent;
+        const reasoning = payload.reasoning || 'Delegating to specialist agent';
+        console.log(`👉 Sub-agent invocation requested: ${agentName}`, { reasoning });
+        // Update the existing Conversation Manager message to show delegation
+        conversationManagerMessage.Message = `👉 **${agentName}** will handle this request...`;
+        conversationManagerMessage.Status = 'Complete';
+        // Keep AgentID as Conversation Manager (already set)
+        if (managerResult.agentRun.ID) {
+            conversationManagerMessage.AgentRunID = managerResult.agentRun.ID;
+        }
+        await conversationManagerMessage.Save();
+        this.messageSent.emit(conversationManagerMessage);
+        // Now create a NEW message for the sub-agent execution
+        try {
+            // Look up the agent to get its ID
+            const agent = AIEngineBase.Instance.Agents.find(a => a.Name === agentName);
+            // Create AI response message BEFORE invoking agent (for duration tracking)
+            const md = new Metadata();
+            const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            agentResponseMessage.ConversationID = conversationId;
+            agentResponseMessage.Role = 'AI';
+            agentResponseMessage.Message = '⏳ Starting...'; // Initial message
+            agentResponseMessage.ParentID = conversationManagerMessage.ID; // Thread under delegation message
+            agentResponseMessage.Status = 'In-Progress';
+            agentResponseMessage.HiddenToUser = false;
+            // Set AgentID immediately for proper attribution
+            if (agent?.ID) {
+                agentResponseMessage.AgentID = agent.ID;
+            }
+            // Save the record to establish __mj_CreatedAt timestamp
+            await agentResponseMessage.Save();
+            this.messageSent.emit(agentResponseMessage);
+            // Add sub-agent to active tasks
+            const newTaskId = this.activeTasks.add({
+                agentName: agentName,
+                status: 'Starting...',
+                relatedMessageId: userMessage.ID,
+                conversationDetailId: agentResponseMessage.ID
+            });
+            // Invoke the sub-agent with progress callback
+            const subResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, reasoning, agentResponseMessage.ID, undefined, // no payload for initial invocation
+            this.createProgressCallback(agentResponseMessage.ID, agentName));
+            // Remove from active tasks
+            this.activeTasks.remove(newTaskId);
+            if (subResult && subResult.success) {
+                // Update the response message with agent result
+                agentResponseMessage.Message = subResult.agentRun?.Message || `✅ **${agentName}** completed`;
+                agentResponseMessage.Status = 'Complete';
+                // Store the agent ID and AgentRunID for display and tracking
+                if (subResult.agentRun.AgentID) {
+                    agentResponseMessage.AgentID = subResult.agentRun.AgentID;
+                }
+                if (subResult.agentRun.ID) {
+                    agentResponseMessage.AgentRunID = subResult.agentRun.ID;
+                }
+                // Save updates - this sets __mj_UpdatedAt for duration calculation
+                await agentResponseMessage.Save();
+                this.messageSent.emit(agentResponseMessage);
+                // Handle artifacts from sub-agent if any
+                if (subResult.payload && Object.keys(subResult.payload).length > 0) {
+                    await this.createArtifactFromPayload(subResult.payload, agentResponseMessage, subResult.agentRun.AgentID);
+                    console.log('🎨 Artifact created and linked to sub-agent message:', agentResponseMessage.ID);
+                    // Re-emit to trigger artifact display
+                    this.messageSent.emit(agentResponseMessage);
+                }
+                // Mark user message as complete
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+            else {
+                // Sub-agent failed - attempt auto-retry once
+                console.log(`⚠️ ${agentName} failed, attempting auto-retry...`);
+                // Update delegation message to show retry
+                conversationManagerMessage.Message = `👉 **${agentName}** will handle this request...\n\n⚠️ First attempt failed, retrying...`;
+                await conversationManagerMessage.Save();
+                this.messageSent.emit(conversationManagerMessage);
+                // Update the existing agentResponseMessage to show retry status
+                agentResponseMessage.Message = 'Retrying...';
+                await agentResponseMessage.Save();
+                this.messageSent.emit(agentResponseMessage);
+                // Retry the sub-agent
+                const retryResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, reasoning, agentResponseMessage.ID, undefined, // no payload for retry
+                this.createProgressCallback(agentResponseMessage.ID, `${agentName} (retry)`));
+                if (retryResult && retryResult.success) {
+                    // Retry succeeded - update the same message
+                    agentResponseMessage.Message = retryResult.agentRun?.Message || `✅ **${agentName}** completed`;
+                    agentResponseMessage.Status = 'Complete';
+                    if (retryResult.agentRun.AgentID) {
+                        agentResponseMessage.AgentID = retryResult.agentRun.AgentID;
+                    }
+                    if (retryResult.agentRun.ID) {
+                        agentResponseMessage.AgentRunID = retryResult.agentRun.ID;
+                    }
+                    // Save updates - maintains original CreatedAt for accurate duration
+                    await agentResponseMessage.Save();
+                    this.messageSent.emit(agentResponseMessage);
+                    // Handle artifacts
+                    if (retryResult.payload && Object.keys(retryResult.payload).length > 0) {
+                        await this.createArtifactFromPayload(retryResult.payload, agentResponseMessage, retryResult.agentRun.AgentID);
+                        this.messageSent.emit(agentResponseMessage);
+                    }
+                    userMessage.Status = 'Complete';
+                    await userMessage.Save();
+                    this.messageSent.emit(userMessage);
+                }
+                else {
+                    // Retry also failed - show error with manual retry option
+                    conversationManagerMessage.Status = 'Error';
+                    conversationManagerMessage.Message = `❌ **${agentName}** failed after retry\n\n${retryResult?.agentRun?.ErrorMessage || 'Unknown error'}`;
+                    conversationManagerMessage.Error = retryResult?.agentRun?.ErrorMessage || null;
+                    await conversationManagerMessage.Save();
+                    this.messageSent.emit(conversationManagerMessage);
+                    userMessage.Status = 'Complete'; // Don't mark user message as error
+                    await userMessage.Save();
+                    this.messageSent.emit(userMessage);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error invoking sub-agent ${agentName}:`, error);
+            conversationManagerMessage.Status = 'Error';
+            conversationManagerMessage.Message = `❌ **${agentName}** encountered an error\n\n${String(error)}`;
+            conversationManagerMessage.Error = String(error);
+            await conversationManagerMessage.Save();
+            this.messageSent.emit(conversationManagerMessage);
+            userMessage.Status = 'Complete'; // Don't mark user message as error
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+    }
+    /**
+     * Handle silent observation - when Conversation Manager stays silent,
+     * check if we should continue with the last agent for iterative refinement
+     */
+    async handleSilentObservation(userMessage, conversationId) {
+        // Find the last AI message (excluding Conversation Manager) in the conversation history
+        const lastAIMessage = this.conversationHistory
+            .slice()
+            .reverse()
+            .find(msg => msg.Role === 'AI' &&
+            msg.AgentID &&
+            msg.AgentID !== this.converationManagerAgent?.ID);
+        if (!lastAIMessage || !lastAIMessage.AgentID) {
+            // No previous specialist agent - just mark user message as complete
+            console.log('🔇 No previous specialist agent found - marking complete');
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+            return;
+        }
+        // Load the agent entity to get its name
+        const md = new Metadata();
+        const rv = new RunView();
+        const agentResult = await rv.RunView({
+            EntityName: 'AI Agents',
+            ExtraFilter: `ID='${lastAIMessage.AgentID}'`,
+            ResultType: 'entity_object'
+        }, this.currentUser);
+        if (!agentResult.Success || !agentResult.Results || agentResult.Results.length === 0) {
+            console.warn('⚠️ Could not load previous agent - marking complete');
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+            return;
+        }
+        const previousAgent = agentResult.Results[0];
+        const agentName = previousAgent.Name || 'Agent';
+        console.log(`🔄 Agent continuity: Continuing with ${agentName} (AgentID: ${lastAIMessage.AgentID})`);
+        // Load the OUTPUT artifact from the last agent message
+        const artifactResult = await rv.RunView({
+            EntityName: 'MJ: Conversation Detail Artifacts',
+            ExtraFilter: `ConversationDetailID='${lastAIMessage.ID}' AND Direction='Output'`,
+            ResultType: 'entity_object'
+        }, this.currentUser);
+        let previousPayload = null;
+        if (artifactResult.Success && artifactResult.Results && artifactResult.Results.length > 0) {
+            // Load the artifact version content
+            const junctionRecord = artifactResult.Results[0];
+            const versionResult = await rv.RunView({
+                EntityName: 'MJ: Artifact Versions',
+                ExtraFilter: `ID='${junctionRecord.ArtifactVersionID}'`,
+                ResultType: 'entity_object'
+            }, this.currentUser);
+            if (versionResult.Success && versionResult.Results && versionResult.Results.length > 0) {
+                const version = versionResult.Results[0];
+                if (version.Content) {
+                    try {
+                        previousPayload = JSON.parse(version.Content);
+                        console.log('📦 Loaded previous OUTPUT artifact as payload for continuity');
+                    }
+                    catch (error) {
+                        console.warn('⚠️ Could not parse previous artifact content:', error);
+                    }
+                }
+            }
+        }
+        // Create status message showing agent continuity
+        const statusMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+        statusMessage.ConversationID = conversationId;
+        statusMessage.Role = 'AI';
+        statusMessage.Message = `Continuing with **${agentName}** for refinement...`;
+        statusMessage.ParentID = userMessage.ID;
+        statusMessage.Status = 'Complete';
+        statusMessage.HiddenToUser = false;
+        statusMessage.AgentID = this.converationManagerAgent?.ID || null;
+        await statusMessage.Save();
+        this.messageSent.emit(statusMessage);
+        // Add agent to active tasks
+        const taskId = this.activeTasks.add({
+            agentName: agentName,
+            status: 'Processing refinement...',
+            relatedMessageId: userMessage.ID,
+            conversationDetailId: statusMessage.ID
+        });
+        try {
+            // Invoke the agent with the previous payload
+            const continuityResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, 'Continuing previous work based on user feedback', statusMessage.ID, previousPayload, this.createProgressCallback(statusMessage.ID, agentName));
+            // Remove from active tasks
+            this.activeTasks.remove(taskId);
+            if (continuityResult && continuityResult.success) {
+                // Create response message
+                const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+                agentResponseMessage.ConversationID = conversationId;
+                agentResponseMessage.Role = 'AI';
+                agentResponseMessage.Message = continuityResult.agentRun?.Message || `✅ **${agentName}** completed refinement`;
+                agentResponseMessage.ParentID = statusMessage.ID;
+                agentResponseMessage.Status = 'Complete';
+                agentResponseMessage.HiddenToUser = false;
+                agentResponseMessage.AgentID = lastAIMessage.AgentID;
+                await agentResponseMessage.Save();
+                this.messageSent.emit(agentResponseMessage);
+                // Handle artifacts from agent if any
+                if (continuityResult.payload && Object.keys(continuityResult.payload).length > 0) {
+                    await this.createArtifactFromPayload(continuityResult.payload, agentResponseMessage, lastAIMessage.AgentID);
+                    console.log('🎨 Artifact created from agent continuity');
+                    this.messageSent.emit(agentResponseMessage);
+                }
+                // Mark user message as complete
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+            else {
+                // Agent failed
+                statusMessage.Status = 'Error';
+                statusMessage.Message = `❌ **${agentName}** failed during refinement\n\n${continuityResult?.agentRun?.ErrorMessage || 'Unknown error'}`;
+                statusMessage.Error = continuityResult?.agentRun?.ErrorMessage || null;
+                await statusMessage.Save();
+                this.messageSent.emit(statusMessage);
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error in agent continuity with ${agentName}:`, error);
+            this.activeTasks.remove(taskId);
+            statusMessage.Status = 'Error';
+            statusMessage.Message = `❌ **${agentName}** encountered an error\n\n${String(error)}`;
+            statusMessage.Error = String(error);
+            await statusMessage.Save();
+            this.messageSent.emit(statusMessage);
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+    }
+    /**
+     * Handle agent response - create AI message from agent result
+     */
+    async handleAgentResponse(userMessage, result, conversationId) {
+        if (!result.agentRun.Message)
+            return;
+        const md = new Metadata();
+        const agentMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+        agentMessage.ConversationID = conversationId;
+        agentMessage.Message = result.agentRun.Message;
+        agentMessage.Role = 'AI';
+        agentMessage.Status = 'Complete';
+        agentMessage.AgentID = this.converationManagerAgent?.ID || null; // Default to Conversation Manager
+        // Populate denormalized AgentID for fast lookup
+        if (result.agentRun.AgentID) {
+            agentMessage.AgentID = result.agentRun.AgentID;
+            console.log(`✅ Set AgentID=${result.agentRun.AgentID} for message from agent`);
+        }
+        else {
+            console.warn('⚠️ AgentID not found in agentRun result');
+        }
+        const saved = await agentMessage.Save();
+        if (saved) {
+            console.log('💾 Agent response saved');
+            // If agent returned a payload, create an artifact version linked to this message
+            if (result.payload && Object.keys(result.payload).length > 0) {
+                await this.createArtifactFromPayload(result.payload, agentMessage, result.agentRun.AgentID);
+                console.log('🎨 Artifact created and linked to conversation detail:', agentMessage.ID);
+            }
+            this.agentResponse.emit({
+                message: agentMessage,
+                agentResult: result
+            });
+            // Mark user message as complete
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+    }
+    /**
+     * Invoke an agent directly when mentioned with @ symbol
+     * Bypasses Conversation Manager completely - no status messages
+     */
+    async invokeAgentDirectly(userMessage, agentMention, conversationId) {
+        const agentName = agentMention.name;
+        // Add agent to active tasks
+        const taskId = this.activeTasks.add({
+            agentName: agentName,
+            status: 'Processing...',
+            relatedMessageId: userMessage.ID,
+            conversationDetailId: userMessage.ID
+        });
+        try {
+            // Update user message status to In-Progress
+            userMessage.Status = 'In-Progress';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+            // Look up the agent to get its ID
+            const agent = AIEngineBase.Instance.Agents.find(a => a.Name === agentName);
+            // Create AI response message BEFORE invoking agent (for duration tracking)
+            const md = new Metadata();
+            const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            agentResponseMessage.ConversationID = conversationId;
+            agentResponseMessage.Role = 'AI';
+            agentResponseMessage.Message = '⏳ Starting...'; // Initial message
+            agentResponseMessage.ParentID = userMessage.ID;
+            agentResponseMessage.Status = 'In-Progress';
+            agentResponseMessage.HiddenToUser = false;
+            // Set AgentID immediately for proper attribution
+            if (agent?.ID) {
+                agentResponseMessage.AgentID = agent.ID;
+            }
+            // Save the record to establish __mj_CreatedAt timestamp
+            await agentResponseMessage.Save();
+            this.messageSent.emit(agentResponseMessage);
+            // Invoke the agent directly
+            const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, `User mentioned agent directly with @${agentName}`, agentResponseMessage.ID, undefined, // no payload for direct mention
+            this.createProgressCallback(agentResponseMessage.ID, agentName));
+            // Remove from active tasks
+            this.activeTasks.remove(taskId);
+            if (result && result.success) {
+                // Update the response message with agent result
+                agentResponseMessage.Message = result.agentRun?.Message || `✅ **${agentName}** completed`;
+                agentResponseMessage.Status = 'Complete';
+                if (result.agentRun.AgentID) {
+                    agentResponseMessage.AgentID = result.agentRun.AgentID;
+                }
+                if (result.agentRun.ID) {
+                    agentResponseMessage.AgentRunID = result.agentRun.ID;
+                }
+                // Save updates - this sets __mj_UpdatedAt for duration calculation
+                await agentResponseMessage.Save();
+                this.messageSent.emit(agentResponseMessage);
+                // Handle artifacts
+                if (result.payload && Object.keys(result.payload).length > 0) {
+                    await this.createArtifactFromPayload(result.payload, agentResponseMessage, result.agentRun.AgentID);
+                    this.messageSent.emit(agentResponseMessage);
+                }
+                // Mark user message as complete
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+            else {
+                // Agent failed - create error message
+                const md = new Metadata();
+                const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+                errorMessage.ConversationID = conversationId;
+                errorMessage.Role = 'AI';
+                errorMessage.Message = `❌ **@${agentName}** failed\n\n${result?.agentRun?.ErrorMessage || 'Unknown error'}`;
+                errorMessage.ParentID = userMessage.ID;
+                errorMessage.Status = 'Error';
+                errorMessage.Error = result?.agentRun?.ErrorMessage || null;
+                errorMessage.HiddenToUser = false;
+                await errorMessage.Save();
+                this.messageSent.emit(errorMessage);
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error invoking mentioned agent ${agentName}:`, error);
+            this.activeTasks.remove(taskId);
+            const md = new Metadata();
+            const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            errorMessage.ConversationID = conversationId;
+            errorMessage.Role = 'AI';
+            errorMessage.Message = `❌ **@${agentName}** encountered an error\n\n${String(error)}`;
+            errorMessage.ParentID = userMessage.ID;
+            errorMessage.Status = 'Error';
+            errorMessage.Error = String(error);
+            errorMessage.HiddenToUser = false;
+            await errorMessage.Save();
+            this.messageSent.emit(errorMessage);
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+    }
+    /**
+     * Continue with the same agent from previous message (implicit continuation)
+     * Bypasses Conversation Manager - no status messages
+     */
+    async continueWithAgent(userMessage, agentId, conversationId) {
+        // Load the agent entity to get its name
+        const md = new Metadata();
+        const rv = new RunView();
+        const agentResult = await rv.RunView({
+            EntityName: 'AI Agents',
+            ExtraFilter: `ID='${agentId}'`,
+            ResultType: 'entity_object'
+        }, this.currentUser);
+        if (!agentResult.Success || !agentResult.Results || agentResult.Results.length === 0) {
+            console.warn('⚠️ Could not load agent for continuation - falling back to Conversation Manager');
+            await this.processMessageThroughAgent(userMessage, { mentions: [], agentMention: null, userMentions: [] });
+            return;
+        }
+        const agent = agentResult.Results[0];
+        const agentName = agent.Name || 'Agent';
+        // Add agent to active tasks
+        const taskId = this.activeTasks.add({
+            agentName: agentName,
+            status: 'Processing...',
+            relatedMessageId: userMessage.ID,
+            conversationDetailId: userMessage.ID
+        });
+        try {
+            // Update user message status to In-Progress
+            userMessage.Status = 'In-Progress';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+            // Create AI response message BEFORE invoking agent (for duration tracking)
+            const agentResponseMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            agentResponseMessage.ConversationID = conversationId;
+            agentResponseMessage.Role = 'AI';
+            agentResponseMessage.Message = '⏳ Starting...'; // Initial message
+            agentResponseMessage.ParentID = userMessage.ID;
+            agentResponseMessage.Status = 'In-Progress';
+            agentResponseMessage.HiddenToUser = false;
+            agentResponseMessage.AgentID = agentId;
+            // Save the record to establish __mj_CreatedAt timestamp
+            await agentResponseMessage.Save();
+            this.messageSent.emit(agentResponseMessage);
+            // Invoke the agent directly (continuation)
+            const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, 'Continuing previous conversation with user', agentResponseMessage.ID, undefined, // no payload for continuation
+            this.createProgressCallback(agentResponseMessage.ID, agentName));
+            // Remove from active tasks
+            this.activeTasks.remove(taskId);
+            if (result && result.success) {
+                // Update the response message with agent result
+                agentResponseMessage.Message = result.agentRun?.Message || `✅ **${agentName}** completed`;
+                agentResponseMessage.Status = 'Complete';
+                if (result.agentRun.ID) {
+                    agentResponseMessage.AgentRunID = result.agentRun.ID;
+                }
+                // Save updates - this sets __mj_UpdatedAt for duration calculation
+                await agentResponseMessage.Save();
+                this.messageSent.emit(agentResponseMessage);
+                // Handle artifacts
+                if (result.payload && Object.keys(result.payload).length > 0) {
+                    await this.createArtifactFromPayload(result.payload, agentResponseMessage, agentId);
+                    this.messageSent.emit(agentResponseMessage);
+                }
+                // Mark user message as complete
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+            else {
+                // Agent failed - create error message
+                const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+                errorMessage.ConversationID = conversationId;
+                errorMessage.Role = 'AI';
+                errorMessage.Message = `❌ **${agentName}** failed\n\n${result?.agentRun?.ErrorMessage || 'Unknown error'}`;
+                errorMessage.ParentID = userMessage.ID;
+                errorMessage.Status = 'Error';
+                errorMessage.Error = result?.agentRun?.ErrorMessage || null;
+                errorMessage.HiddenToUser = false;
+                await errorMessage.Save();
+                this.messageSent.emit(errorMessage);
+                userMessage.Status = 'Complete';
+                await userMessage.Save();
+                this.messageSent.emit(userMessage);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error continuing with agent ${agentName}:`, error);
+            this.activeTasks.remove(taskId);
+            const errorMessage = await md.GetEntityObject('Conversation Details', this.currentUser);
+            errorMessage.ConversationID = conversationId;
+            errorMessage.Role = 'AI';
+            errorMessage.Message = `❌ **${agentName}** encountered an error\n\n${String(error)}`;
+            errorMessage.ParentID = userMessage.ID;
+            errorMessage.Status = 'Error';
+            errorMessage.Error = String(error);
+            errorMessage.HiddenToUser = false;
+            await errorMessage.Save();
+            this.messageSent.emit(errorMessage);
+            userMessage.Status = 'Complete';
+            await userMessage.Save();
+            this.messageSent.emit(userMessage);
+        }
+    }
+    /**
+     * Creates an artifact from an agent's payload and links it to the conversation detail
+     * @param payload The agent's payload object
+     * @param message The conversation detail message to link to
+     * @param agentId The ID of the agent that produced the payload
+     */
+    async createArtifactFromPayload(payload, message, agentId) {
+        try {
+            const md = new Metadata();
+            // Create Artifact header
+            const artifact = await md.GetEntityObject('MJ: Artifacts', this.currentUser);
+            // Generate artifact name based on agent name and timestamp
+            const agentName = agentId
+                ? AIEngineBase.Instance?.Agents?.find(a => a.ID === agentId)?.Name || 'Agent'
+                : 'Agent';
+            artifact.Name = `${agentName} Payload - ${new Date().toLocaleString()}`;
+            artifact.Description = `Payload returned by ${agentName}`;
+            // Use JSON artifact type (hardcoded ID from migration)
+            artifact.TypeID = 'ae674c7e-ea0d-49ea-89e4-0649f5eb20d4'; // JSON type
+            artifact.UserID = this.currentUser.ID;
+            artifact.EnvironmentID = this.currentUser.EnvironmentID || 'F51358F3-9447-4176-B313-BF8025FD8D09';
+            const artifactSaved = await artifact.Save();
+            if (!artifactSaved) {
+                console.error('Failed to save artifact');
+                return;
+            }
+            // Create Artifact Version with content
+            const version = await md.GetEntityObject('MJ: Artifact Versions', this.currentUser);
+            version.ArtifactID = artifact.ID;
+            version.VersionNumber = 1;
+            version.Content = JSON.stringify(payload, null, 2);
+            version.UserID = this.currentUser.ID;
+            const versionSaved = await version.Save();
+            if (!versionSaved) {
+                console.error('Failed to save artifact version');
+                return;
+            }
+            // Create M2M relationship using ConversationDetailArtifact junction table
+            const junction = await md.GetEntityObject('MJ: Conversation Detail Artifacts', this.currentUser);
+            junction.ConversationDetailID = message.ID;
+            junction.ArtifactVersionID = version.ID;
+            junction.Direction = 'Output'; // This artifact was produced as output from the agent
+            const junctionSaved = await junction.Save();
+            if (!junctionSaved) {
+                console.error('Failed to create artifact-message association');
+            }
+            this.artifactCreated.emit({ artifactId: artifact.ID, versionId: version.ID, conversationDetailId: message.ID, name: artifact.Name });
+        }
+        catch (error) {
+            console.error('Error creating artifact from payload:', error);
+        }
+    }
+    /**
+     * Name the conversation based on the first message using GraphQL AI client
+     */
+    async nameConversation(message) {
+        try {
+            console.log('🏷️ Naming conversation based on first message...');
+            // Load the Name Conversation prompt to get its ID
+            await AIEngineBase.Instance.Config(false);
+            const p = AIEngineBase.Instance.Prompts.find(pr => pr.Name === 'Name Conversation');
+            if (!p) {
+                console.warn('⚠️ Name Conversation prompt not found');
+                return;
+            }
+            const promptId = p.ID;
+            // Use GraphQL AI client to run the prompt (same client as agent)
+            const provider = Metadata.Provider;
+            if (!provider) {
+                console.warn('⚠️ GraphQLDataProvider not available');
+                return;
+            }
+            const aiClient = new GraphQLAIClient(provider);
+            const result = await aiClient.RunAIPrompt({
+                promptId: promptId,
+                messages: [{ role: 'user', content: message }],
+            });
+            if (result && result.success && (result.parsedResult || result.output)) {
+                // Use parsedResult if available, otherwise parse output
+                const parsed = result.parsedResult ||
+                    (result.output ? JSON.parse(result.output) : null);
+                if (parsed) {
+                    const { name, description } = parsed;
+                    if (name) {
+                        console.log('✅ Generated conversation name:', { name, description });
+                        // Update the conversation name and description in database AND state immediately
+                        await this.conversationState.saveConversation(this.conversationId, { Name: name, Description: description || '' }, this.currentUser);
+                        console.log('💾 Conversation name updated in database and UI');
+                        // Emit event for animation in conversation list
+                        this.conversationRenamed.emit({
+                            conversationId: this.conversationId,
+                            name: name,
+                            description: description || ''
+                        });
+                    }
+                }
+            }
+            else {
+                console.warn('⚠️ Failed to generate conversation name');
+            }
+        }
+        catch (error) {
+            console.error('❌ Error naming conversation:', error);
+            // Don't show error to user - naming failures should be silent
+        }
+    }
+    static ɵfac = function MessageInputComponent_Factory(t) { return new (t || MessageInputComponent)(i0.ɵɵdirectiveInject(i1.DialogService), i0.ɵɵdirectiveInject(i2.ToastService), i0.ɵɵdirectiveInject(i3.ConversationAgentService), i0.ɵɵdirectiveInject(i4.ConversationStateService), i0.ɵɵdirectiveInject(i5.ActiveTasksService), i0.ɵɵdirectiveInject(i6.MentionAutocompleteService), i0.ɵɵdirectiveInject(i7.MentionParserService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MessageInputComponent, selectors: [["mj-message-input"]], viewQuery: function MessageInputComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.messageTextarea = _t.first);
+        } }, inputs: { conversationId: "conversationId", currentUser: "currentUser", disabled: "disabled", placeholder: "placeholder", parentMessageId: "parentMessageId", conversationHistory: "conversationHistory" }, outputs: { messageSent: "messageSent", agentResponse: "agentResponse", agentRunDetected: "agentRunDetected", artifactCreated: "artifactCreated", conversationRenamed: "conversationRenamed" }, decls: 11, vars: 11, consts: [["messageTextarea", ""], [1, "message-input-container"], ["rows", "3", 1, "message-input", 3, "ngModelChange", "keydown", "input", "ngModel", "placeholder", "disabled"], [3, "suggestionSelected", "closed", "suggestions", "position", "visible", "showAbove"], [1, "input-actions"], ["class", "processing-indicator", 4, "ngIf"], ["title", "Attach file (coming soon)", 1, "btn-attach", 3, "disabled"], [1, "fas", "fa-paperclip"], [1, "btn-send", 3, "click", "disabled", "title"], [1, "fas", "fa-paper-plane"], [1, "processing-indicator"], [1, "fas", "fa-circle-notch", "fa-spin"]], template: function MessageInputComponent_Template(rf, ctx) { if (rf & 1) {
+            const _r1 = i0.ɵɵgetCurrentView();
+            i0.ɵɵelementStart(0, "div", 1)(1, "textarea", 2, 0);
+            i0.ɵɵtwoWayListener("ngModelChange", function MessageInputComponent_Template_textarea_ngModelChange_1_listener($event) { i0.ɵɵrestoreView(_r1); i0.ɵɵtwoWayBindingSet(ctx.messageText, $event) || (ctx.messageText = $event); return i0.ɵɵresetView($event); });
+            i0.ɵɵlistener("keydown", function MessageInputComponent_Template_textarea_keydown_1_listener($event) { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.onKeyDown($event)); })("input", function MessageInputComponent_Template_textarea_input_1_listener($event) { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.onInput($event)); });
+            i0.ɵɵtext(3, "  ");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(4, "mj-mention-dropdown", 3);
+            i0.ɵɵlistener("suggestionSelected", function MessageInputComponent_Template_mj_mention_dropdown_suggestionSelected_4_listener($event) { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.onMentionSelected($event)); })("closed", function MessageInputComponent_Template_mj_mention_dropdown_closed_4_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.closeMentionDropdown()); });
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(5, "div", 4);
+            i0.ɵɵtemplate(6, MessageInputComponent_div_6_Template, 4, 0, "div", 5);
+            i0.ɵɵelementStart(7, "button", 6);
+            i0.ɵɵelement(8, "i", 7);
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(9, "button", 8);
+            i0.ɵɵlistener("click", function MessageInputComponent_Template_button_click_9_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.onSend()); });
+            i0.ɵɵelement(10, "i", 9);
+            i0.ɵɵelementEnd()()();
+        } if (rf & 2) {
+            i0.ɵɵadvance();
+            i0.ɵɵtwoWayProperty("ngModel", ctx.messageText);
+            i0.ɵɵproperty("placeholder", ctx.placeholder)("disabled", ctx.disabled || ctx.isSending);
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("suggestions", ctx.mentionSuggestions)("position", ctx.mentionDropdownPosition)("visible", ctx.showMentionDropdown)("showAbove", ctx.mentionDropdownShowAbove);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", ctx.isProcessing);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("disabled", ctx.disabled);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("disabled", !ctx.canSend)("title", ctx.isSending ? "Sending..." : "Send message");
+        } }, dependencies: [i8.NgIf, i9.DefaultValueAccessor, i9.NgControlStatus, i9.NgModel, i10.MentionDropdownComponent], styles: [".message-input-container[_ngcontent-%COMP%] {\n  position: relative;\n  padding: 16px 24px;\n  border-top: 1px solid #D9D9D9;\n  background: #FFF;\n}\n\n.message-input-wrapper[_ngcontent-%COMP%] {\n  border: 2px solid #D9D9D9;\n  border-radius: 8px;\n  padding: 12px;\n  transition: border-color 0.2s, box-shadow 0.2s;\n  background: #FFF;\n}\n\n.message-input-wrapper[_ngcontent-%COMP%]:focus-within {\n  border-color: #0076B6;\n  box-shadow: 0 0 0 3px rgba(0, 118, 182, 0.1);\n}\n\n.message-input[_ngcontent-%COMP%] {\n  width: 100%;\n  padding: 0;\n  border: none;\n  resize: none;\n  font-family: inherit;\n  font-size: 14px;\n  min-height: 40px;\n  max-height: 200px;\n  line-height: 1.5;\n}\n\n.message-input[_ngcontent-%COMP%]:focus {\n  outline: none;\n}\n\n.message-input[_ngcontent-%COMP%]:disabled {\n  background: #F4F4F4;\n  cursor: not-allowed;\n}\n.input-actions[_ngcontent-%COMP%] {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-top: 12px;\n}\n.btn-attach[_ngcontent-%COMP%] {\n  padding: 8px 16px;\n  background: transparent;\n  border: 1px solid #D9D9D9;\n  border-radius: 6px;\n  cursor: pointer;\n  color: #333;\n  display: flex;\n  align-items: center;\n  gap: 6px;\n}\n.btn-attach[_ngcontent-%COMP%]:hover:not(:disabled) {\n  background: #F4F4F4;\n  border-color: #AAA;\n}\n.btn-attach[_ngcontent-%COMP%]:disabled {\n  opacity: 0.5;\n  cursor: not-allowed;\n}\n.btn-send[_ngcontent-%COMP%] {\n  width: 40px;\n  height: 40px;\n  background: #3B82F6;\n  color: white;\n  border: none;\n  border-radius: 8px;\n  cursor: pointer;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  transition: background 0.2s;\n  flex-shrink: 0;\n}\n.btn-send[_ngcontent-%COMP%]:hover:not(:disabled) {\n  background: #2563EB;\n}\n.btn-send[_ngcontent-%COMP%]:disabled {\n  background: #D9D9D9;\n  color: #AAA;\n  cursor: not-allowed;\n}\n.btn-send[_ngcontent-%COMP%]   i[_ngcontent-%COMP%] {\n  font-size: 16px;\n}\n.processing-indicator[_ngcontent-%COMP%] {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  font-size: 13px;\n  color: #6B7280;\n  margin-right: auto;\n}\n.processing-indicator[_ngcontent-%COMP%]   i[_ngcontent-%COMP%] {\n  color: #0076B6;\n}"] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MessageInputComponent, [{
+        type: Component,
+        args: [{ selector: 'mj-message-input', template: "<div class=\"message-input-container\">\n  <textarea\n    #messageTextarea\n    class=\"message-input\"\n    [(ngModel)]=\"messageText\"\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled || isSending\"\n    (keydown)=\"onKeyDown($event)\"\n    (input)=\"onInput($event)\"\n    rows=\"3\">\n  </textarea>\n\n  <!-- Mention Autocomplete Dropdown -->\n  <mj-mention-dropdown\n    [suggestions]=\"mentionSuggestions\"\n    [position]=\"mentionDropdownPosition\"\n    [visible]=\"showMentionDropdown\"\n    [showAbove]=\"mentionDropdownShowAbove\"\n    (suggestionSelected)=\"onMentionSelected($event)\"\n    (closed)=\"closeMentionDropdown()\">\n  </mj-mention-dropdown>\n\n  <div class=\"input-actions\">\n    <div class=\"processing-indicator\" *ngIf=\"isProcessing\">\n      <i class=\"fas fa-circle-notch fa-spin\"></i>\n      <span>AI is responding...</span>\n    </div>\n    <button\n      class=\"btn-attach\"\n      [disabled]=\"disabled\"\n      title=\"Attach file (coming soon)\">\n      <i class=\"fas fa-paperclip\"></i>\n    </button>\n    <button\n      class=\"btn-send\"\n      [disabled]=\"!canSend\"\n      (click)=\"onSend()\"\n      [title]=\"isSending ? 'Sending...' : 'Send message'\">\n      <i class=\"fas fa-paper-plane\"></i>\n    </button>\n  </div>\n</div>", styles: [".message-input-container {\n  position: relative;\n  padding: 16px 24px;\n  border-top: 1px solid #D9D9D9;\n  background: #FFF;\n}\n\n.message-input-wrapper {\n  border: 2px solid #D9D9D9;\n  border-radius: 8px;\n  padding: 12px;\n  transition: border-color 0.2s, box-shadow 0.2s;\n  background: #FFF;\n}\n\n.message-input-wrapper:focus-within {\n  border-color: #0076B6;\n  box-shadow: 0 0 0 3px rgba(0, 118, 182, 0.1);\n}\n\n.message-input {\n  width: 100%;\n  padding: 0;\n  border: none;\n  resize: none;\n  font-family: inherit;\n  font-size: 14px;\n  min-height: 40px;\n  max-height: 200px;\n  line-height: 1.5;\n}\n\n.message-input:focus {\n  outline: none;\n}\n\n.message-input:disabled {\n  background: #F4F4F4;\n  cursor: not-allowed;\n}\n.input-actions {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  margin-top: 12px;\n}\n.btn-attach {\n  padding: 8px 16px;\n  background: transparent;\n  border: 1px solid #D9D9D9;\n  border-radius: 6px;\n  cursor: pointer;\n  color: #333;\n  display: flex;\n  align-items: center;\n  gap: 6px;\n}\n.btn-attach:hover:not(:disabled) {\n  background: #F4F4F4;\n  border-color: #AAA;\n}\n.btn-attach:disabled {\n  opacity: 0.5;\n  cursor: not-allowed;\n}\n.btn-send {\n  width: 40px;\n  height: 40px;\n  background: #3B82F6;\n  color: white;\n  border: none;\n  border-radius: 8px;\n  cursor: pointer;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  transition: background 0.2s;\n  flex-shrink: 0;\n}\n.btn-send:hover:not(:disabled) {\n  background: #2563EB;\n}\n.btn-send:disabled {\n  background: #D9D9D9;\n  color: #AAA;\n  cursor: not-allowed;\n}\n.btn-send i {\n  font-size: 16px;\n}\n.processing-indicator {\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  font-size: 13px;\n  color: #6B7280;\n  margin-right: auto;\n}\n.processing-indicator i {\n  color: #0076B6;\n}"] }]
+    }], () => [{ type: i1.DialogService }, { type: i2.ToastService }, { type: i3.ConversationAgentService }, { type: i4.ConversationStateService }, { type: i5.ActiveTasksService }, { type: i6.MentionAutocompleteService }, { type: i7.MentionParserService }], { conversationId: [{
+            type: Input
+        }], currentUser: [{
+            type: Input
+        }], disabled: [{
+            type: Input
+        }], placeholder: [{
+            type: Input
+        }], parentMessageId: [{
+            type: Input
+        }], conversationHistory: [{
+            type: Input
+        }], messageSent: [{
+            type: Output
+        }], agentResponse: [{
+            type: Output
+        }], agentRunDetected: [{
+            type: Output
+        }], artifactCreated: [{
+            type: Output
+        }], conversationRenamed: [{
+            type: Output
+        }], messageTextarea: [{
+            type: ViewChild,
+            args: ['messageTextarea']
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 21 }); })();
+//# sourceMappingURL=message-input.component.js.map