@memberjunction/ng-conversations 2.111.1 → 2.113.0

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

@@ -1,7 +1,8 @@
 import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
-import { Metadata, RunView } from '@memberjunction/core';
+import { Metadata } from '@memberjunction/core';
 import { GraphQLDataProvider, GraphQLAIClient } from '@memberjunction/graphql-dataprovider';
 import { AIEngineBase } from '@memberjunction/ai-engine-base';
+import { MJNotificationService } from '@memberjunction/ng-notifications';
 import * as i0 from "@angular/core";
 import * as i1 from "../../services/dialog.service";
 import * as i2 from "../../services/toast.service";
@@ -37,12 +38,16 @@ export class MessageInputComponent {
     // Default artifact type ID for JSON (when agent doesn't specify DefaultArtifactTypeID)
     JSON_ARTIFACT_TYPE_ID = 'ae674c7e-ea0d-49ea-89e4-0649f5eb20d4';
     conversationId;
+    conversationName; // For task tracking display
     currentUser;
     disabled = false;
     placeholder = 'Type a message... (Ctrl+Enter to send)';
     parentMessageId; // Optional: for replying in threads
     conversationHistory = []; // For agent context
     initialMessage = null; // Message to send automatically when component initializes
+    artifactsByDetailId; // Pre-loaded artifact data for performance
+    agentRunsByDetailId; // Pre-loaded agent run data for performance
+    inProgressMessageIds; // Message IDs that are in-progress and need streaming reconnection
     messageSent = new EventEmitter();
     agentResponse = new EventEmitter();
     agentRunDetected = new EventEmitter();
@@ -80,12 +85,18 @@ export class MessageInputComponent {
         await this.mentionAutocomplete.initialize(this.currentUser);
         // Subscribe to PubSub for task progress updates
         this.subscribeToPushStatus();
+        // Reconnect to any in-progress messages for streaming updates
+        this.reconnectInProgressMessages();
     }
     ngOnChanges(changes) {
         // When conversation changes, focus the input
         if (changes['conversationId'] && !changes['conversationId'].firstChange) {
             this.focusInput();
         }
+        // When in-progress message IDs change (switching conversations), reconnect
+        if (changes['inProgressMessageIds']) {
+            this.reconnectInProgressMessages();
+        }
     }
     ngAfterViewInit() {
         // Focus input on initial load
@@ -115,6 +126,24 @@ export class MessageInputComponent {
             }
         }, 100);
     }
+    /**
+     * Reconnect to in-progress messages for streaming updates
+     * This is called when:
+     * 1. Component initializes (ngOnInit)
+     * 2. Conversation changes (ngOnChanges)
+     * 3. User returns to a conversation with in-progress messages
+     */
+    reconnectInProgressMessages() {
+        if (!this.inProgressMessageIds || this.inProgressMessageIds.length === 0) {
+            return;
+        }
+        console.log(`🔌 Reconnecting to ${this.inProgressMessageIds.length} in-progress messages for streaming updates`);
+        // Register all in-progress message IDs to receive PubSub updates
+        for (const messageId of this.inProgressMessageIds) {
+            this.activeTaskExecutionMessageIds.add(messageId);
+        }
+        console.log(`✅ Registered ${this.activeTaskExecutionMessageIds.size} messages for streaming updates`);
+    }
     /**
      * Subscribe to PubSub for real-time task orchestration progress updates
      */
@@ -366,13 +395,18 @@ export class MessageInputComponent {
      */
     async handleAgentContinuity(messageDetail, lastAgentId, mentionResult, isFirstMessage) {
         console.log('🔍 Previous agent found, checking continuity intent...');
-        const intent = await this.checkContinuityIntent(lastAgentId, messageDetail.Message);
-        if (intent === 'YES') {
-            console.log('✅ Intent check: YES - continuing with previous agent');
-            await this.executeRouteWithNaming(() => this.continueWithAgent(messageDetail, lastAgentId, this.conversationId), messageDetail.Message, isFirstMessage);
+        const intentResult = await this.checkContinuityIntent(lastAgentId, messageDetail.Message);
+        if (intentResult.decision === 'YES') {
+            console.log('✅ Intent check: YES - continuing with previous agent', {
+                reasoning: intentResult.reasoning,
+                targetArtifactVersionId: intentResult.targetArtifactVersionId
+            });
+            await this.executeRouteWithNaming(() => this.continueWithAgent(messageDetail, lastAgentId, this.conversationId, intentResult.targetArtifactVersionId), messageDetail.Message, isFirstMessage);
         }
         else {
-            console.log(`🤖 Intent check: ${intent} - routing through Sage for evaluation`);
+            console.log(`🤖 Intent check: ${intentResult.decision} - routing through Sage for evaluation`, {
+                reasoning: intentResult.reasoning
+            });
             await this.executeRouteWithNaming(() => this.processMessageThroughAgent(messageDetail, mentionResult), messageDetail.Message, isFirstMessage);
         }
     }
@@ -403,12 +437,20 @@ export class MessageInputComponent {
         // Emit event to show temporary "Analyzing intent..." message in conversation
         this.intentCheckStarted.emit();
         try {
-            const intent = await this.agentService.checkAgentContinuityIntent(agentId, message, this.conversationHistory);
+            // Build context from pre-loaded maps (if available)
+            if (!this.artifactsByDetailId || !this.agentRunsByDetailId) {
+                console.warn('⚠️ Artifact/agent run context not available for intent check');
+                return { decision: 'UNSURE', reasoning: 'Context not available' };
+            }
+            const intent = await this.agentService.checkAgentContinuityIntent(agentId, message, this.conversationHistory, {
+                artifactsByDetailId: this.artifactsByDetailId,
+                agentRunsByDetailId: this.agentRunsByDetailId
+            });
             return intent;
         }
         catch (error) {
             console.error('❌ Intent check failed, defaulting to UNSURE:', error);
-            return 'UNSURE';
+            return { decision: 'UNSURE', reasoning: 'Intent check failed with error' };
         }
         finally {
             // Emit event to remove temporary intent checking message
@@ -481,12 +523,6 @@ export class MessageInputComponent {
         return async (progress) => {
             let progressAgentRun = progress.metadata?.agentRun;
             const progressAgentRunId = progressAgentRun?.ID || progress.metadata?.agentRunId;
-            // if (!progressAgentRun && progressAgentRunId) {
-            //   // load the full agent run object from the database if we only have the ID
-            //   const md = new Metadata();
-            //   progressAgentRun = await md.GetEntityObject<AIAgentRunEntity>("MJ: AI Agent Runs");
-            //   await progressAgentRun.Load(progressAgentRunId);
-            // }
             // Capture the agent run ID from the first progress message
             if (!capturedAgentRunId && progressAgentRunId) {
                 capturedAgentRunId = progressAgentRunId;
@@ -581,25 +617,20 @@ export class MessageInputComponent {
                 agentName: 'Sage',
                 status: 'Evaluating message...',
                 relatedMessageId: userMessage.ID,
-                conversationDetailId: conversationManagerMessage.ID
+                conversationDetailId: conversationManagerMessage.ID,
+                conversationId: this.conversationId,
+                conversationName: this.conversationName
             });
             const result = await this.agentService.processMessage(conversationId, userMessage, this.conversationHistory, conversationManagerMessage.ID, this.createProgressCallback(conversationManagerMessage, 'Sage'));
-            // Remove Sage from active tasks
-            if (taskId) {
-                this.activeTasks.remove(taskId);
-                taskId = null;
-            }
+            // Task will be removed automatically in markMessageComplete()
+            // DO NOT remove here - agent may still be streaming/processing
+            taskId = null; // Clear reference but don't remove from service
             if (!result || !result.success) {
-                // Evaluation failed - mark as complete to stop progress updates
-                this.markMessageComplete(conversationManagerMessage);
-                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);
+                // Evaluation failed - use updateConversationDetail to ensure task cleanup
+                const errorMsg = result?.agentRun?.ErrorMessage || 'Agent evaluation failed';
+                conversationManagerMessage.Error = errorMsg;
+                await this.updateConversationDetail(conversationManagerMessage, `❌ Evaluation failed`, 'Error');
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
                 console.warn('⚠️ Sage failed:', result?.agentRun?.ErrorMessage);
                 // Clean up completion timestamp
                 this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
@@ -619,7 +650,7 @@ export class MessageInputComponent {
                 await this.handleTaskGraphExecution(userMessage, result, this.conversationId, conversationManagerMessage);
                 // Remove CM from active tasks
                 if (taskId) {
-                    this.activeTasks.remove(taskId);
+                    // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
                 }
             }
             // Stage 3: Check for sub-agent invocation (single-step delegation)
@@ -628,7 +659,7 @@ export class MessageInputComponent {
                 await this.handleSubAgentInvocation(userMessage, result, this.conversationId, conversationManagerMessage);
                 // Remove CM from active tasks
                 if (taskId) {
-                    this.activeTasks.remove(taskId);
+                    // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
                 }
             }
             // Stage 4: Direct chat response from Sage
@@ -651,12 +682,10 @@ export class MessageInputComponent {
                     console.log('🎨 Server created artifact, UI will reload to show it');
                     this.messageSent.emit(conversationManagerMessage);
                 }
-                userMessage.Status = 'Complete';
-                await userMessage.Save();
-                this.messageSent.emit(userMessage);
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
                 // Remove CM from active tasks
                 if (taskId) {
-                    this.activeTasks.remove(taskId);
+                    // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
                 }
                 // Clean up completion timestamp after delay
                 this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
@@ -690,7 +719,7 @@ export class MessageInputComponent {
                 }
                 // Remove CM from active tasks
                 if (taskId) {
-                    this.activeTasks.remove(taskId);
+                    // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
                 }
             }
         }
@@ -698,23 +727,17 @@ export class MessageInputComponent {
             console.error('❌ Error processing message through agents:', error);
             // Update conversationManagerMessage status to Error
             if (conversationManagerMessage && conversationManagerMessage.ID) {
-                // Mark as complete to stop progress updates
-                this.markMessageComplete(conversationManagerMessage);
-                conversationManagerMessage.Status = 'Error';
-                conversationManagerMessage.Message = `❌ Error: ${String(error)}`;
+                // Use updateConversationDetail to ensure task cleanup
                 conversationManagerMessage.Error = String(error);
-                await conversationManagerMessage.Save();
-                this.messageSent.emit(conversationManagerMessage);
+                await this.updateConversationDetail(conversationManagerMessage, `❌ Error: ${String(error)}`, 'Error');
                 // Clean up completion timestamp
                 this.cleanupCompletionTimestamp(conversationManagerMessage.ID);
             }
             // Mark user message as complete
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             // Clean up active task
             if (taskId) {
-                this.activeTasks.remove(taskId);
+                // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             }
         }
     }
@@ -731,7 +754,6 @@ export class MessageInputComponent {
             reasoning,
             taskCount
         });
-        const md = new Metadata();
         // Deduplicate tasks by tempId (LLM sometimes returns duplicates)
         const seenTempIds = new Set();
         const uniqueTasks = taskGraph.tasks.filter((task) => {
@@ -818,18 +840,14 @@ export class MessageInputComponent {
             // ExecuteGQL returns data directly (not wrapped in {data, errors})
             if (result?.ExecuteTaskGraph?.success) {
                 console.log('✅ Task graph execution completed successfully');
-                taskExecutionMessage.Message = `✅ **${workflowName}** completed successfully`;
-                taskExecutionMessage.Status = 'Complete';
+                await this.updateConversationDetail(taskExecutionMessage, `✅ **${workflowName}** completed successfully`, 'Complete');
             }
             else {
                 const errorMsg = result?.ExecuteTaskGraph?.errorMessage || 'Unknown error';
                 console.error('❌ Task graph execution failed:', errorMsg);
-                taskExecutionMessage.Message = `❌ **${workflowName}** failed: ${errorMsg}`;
-                taskExecutionMessage.Status = 'Error';
                 taskExecutionMessage.Error = errorMsg;
+                await this.updateConversationDetail(taskExecutionMessage, `❌ **${workflowName}** failed: ${errorMsg}`, 'Error');
             }
-            await taskExecutionMessage.Save();
-            this.messageSent.emit(taskExecutionMessage);
             // Trigger artifact reload for this message
             // Artifacts were created on server during task execution and linked to this message
             // This event triggers the parent component to reload artifacts from the database
@@ -842,18 +860,15 @@ export class MessageInputComponent {
             });
             // Unregister from real-time updates (task complete)
             this.activeTaskExecutionMessageIds.delete(taskExecutionMessage.ID);
+            // Mark agent response message as complete (removes task from active tasks)
+            await this.updateConversationDetail(conversationManagerMessage, conversationManagerMessage.Message, 'Complete');
             // Mark user message as complete
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
         catch (error) {
             console.error('❌ Error executing task graph:', error);
-            taskExecutionMessage.Message = `❌ **${workflowName}** - Error: ${String(error)}`;
-            taskExecutionMessage.Status = 'Error';
             taskExecutionMessage.Error = String(error);
-            await taskExecutionMessage.Save();
-            this.messageSent.emit(taskExecutionMessage);
+            await this.updateConversationDetail(taskExecutionMessage, `❌ **${workflowName}** - Error: ${String(error)}`, 'Error');
             // Trigger artifact reload even on error - partial artifacts may have been created
             this.artifactCreated.emit({
                 artifactId: '',
@@ -864,19 +879,23 @@ export class MessageInputComponent {
             });
             // Unregister from real-time updates (task failed)
             this.activeTaskExecutionMessageIds.delete(taskExecutionMessage.ID);
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            // Mark agent response message as complete (removes task from active tasks)
+            conversationManagerMessage.Error = String(error);
+            await this.updateConversationDetail(conversationManagerMessage, conversationManagerMessage.Message, 'Error');
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
     }
     async updateConversationDetail(convoDetail, message, status, suggestedResponses) {
-        if (convoDetail.Status === 'Complete' || convoDetail.Status === 'Error') {
-            return; // Do not update completed or errored messages
-        }
-        // Mark as completing BEFORE updating if status is Complete or Error
+        // Mark as completing FIRST if status is Complete or Error
+        // This ensures task cleanup happens even if we return early due to guard clause
         if (status === 'Complete' || status === 'Error') {
             this.markMessageComplete(convoDetail);
         }
+        // Guard clause: Don't re-save if already complete/errored (prevents duplicate saves)
+        // Task has already been removed by markMessageComplete() above
+        if (convoDetail.Status === 'Complete' || convoDetail.Status === 'Error') {
+            return; // Already complete, no need to save again
+        }
         const maxAttempts = 2;
         let attempts = 0, done = false;
         while (attempts < maxAttempts && !done) {
@@ -928,16 +947,18 @@ export class MessageInputComponent {
                 agentName: agentName,
                 status: 'Starting...',
                 relatedMessageId: userMessage.ID,
-                conversationDetailId: agentResponseMessage.ID
+                conversationDetailId: agentResponseMessage.ID,
+                conversationId: this.conversationId,
+                conversationName: this.conversationName
             });
             // Invoke agent with task's input payload
             const agentResult = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, task.description || task.name, agentResponseMessage.ID, task.inputPayload, // Pass the task's input payload
             this.createProgressCallback(agentResponseMessage, agentName));
-            // Remove from active tasks
-            this.activeTasks.remove(newTaskId);
+            // Task will be removed automatically in markMessageComplete() when status changes to Complete/Error
+            // DO NOT remove here - allows UI to show task during entire execution
             if (agentResult && agentResult.success) {
                 // Update message with result
-                await this.updateConversationDetail(agentResponseMessage, agentResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
+                await this.updateConversationDetail(agentResponseMessage, agentResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', agentResult.suggestedResponses);
                 // Server created artifacts - emit event to trigger UI reload
                 if (agentResult.payload && Object.keys(agentResult.payload).length > 0) {
                     this.artifactCreated.emit({
@@ -954,22 +975,15 @@ export class MessageInputComponent {
             else {
                 // Handle failure
                 const errorMsg = agentResult?.agentRun?.ErrorMessage || 'Agent execution failed';
-                agentResponseMessage.Message = `❌ **${agentName}** failed: ${errorMsg}`;
-                agentResponseMessage.Status = 'Error';
                 agentResponseMessage.Error = errorMsg;
-                await agentResponseMessage.Save();
-                this.messageSent.emit(agentResponseMessage);
+                await this.updateConversationDetail(agentResponseMessage, `❌ **${agentName}** failed: ${errorMsg}`, 'Error');
             }
             // Mark user message as complete
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
         catch (error) {
             console.error('❌ Error in single task execution:', error);
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
     }
     /**
@@ -1004,20 +1018,22 @@ export class MessageInputComponent {
                 agentName: agentName,
                 status: 'Starting...',
                 relatedMessageId: userMessage.ID,
-                conversationDetailId: agentResponseMessage.ID
+                conversationDetailId: agentResponseMessage.ID,
+                conversationId: this.conversationId,
+                conversationName: this.conversationName
             });
             // 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, agentName));
-            // Remove from active tasks
-            this.activeTasks.remove(newTaskId);
+            // Task will be removed automatically in markMessageComplete() when status changes to Complete/Error
+            // DO NOT remove here - allows UI to show task during entire execution
             if (subResult && subResult.success) {
                 // Update the response message with agent result
                 // Store the agent ID for display
                 if (subResult.agentRun.AgentID) {
                     agentResponseMessage.AgentID = subResult.agentRun.AgentID;
                 }
-                await this.updateConversationDetail(agentResponseMessage, subResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
+                await this.updateConversationDetail(agentResponseMessage, subResult.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', subResult.suggestedResponses);
                 // Server created artifacts - emit event to trigger UI reload
                 if (subResult.payload && Object.keys(subResult.payload).length > 0) {
                     this.artifactCreated.emit({
@@ -1032,9 +1048,7 @@ export class MessageInputComponent {
                     this.messageSent.emit(agentResponseMessage);
                 }
                 // Mark user message as complete
-                userMessage.Status = 'Complete';
-                await userMessage.Save();
-                this.messageSent.emit(userMessage);
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
             else {
                 // Sub-agent failed - attempt auto-retry once
@@ -1062,33 +1076,21 @@ export class MessageInputComponent {
                         });
                         this.messageSent.emit(agentResponseMessage);
                     }
-                    userMessage.Status = 'Complete';
-                    await userMessage.Save();
-                    this.messageSent.emit(userMessage);
+                    await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
                 }
                 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);
+                    await this.updateConversationDetail(conversationManagerMessage, `❌ **${agentName}** failed after retry\n\n${retryResult?.agentRun?.ErrorMessage || 'Unknown error'}`, 'Error');
+                    await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
                 }
             }
         }
         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);
+            await this.updateConversationDetail(conversationManagerMessage, `❌ **${agentName}** encountered an error\n\n${String(error)}`, 'Error');
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
     }
     /**
@@ -1106,59 +1108,40 @@ export class MessageInputComponent {
         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);
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             return;
         }
         // Load the agent entity to get its name
-        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) {
+        const previousAgent = AIEngineBase.Instance.Agents.find(a => a.ID === lastAIMessage.AgentID);
+        if (!previousAgent) {
             console.warn('⚠️ Could not load previous agent - marking complete');
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             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;
         let previousArtifactInfo = 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 {
+        // Use pre-loaded artifact data (no DB queries!)
+        if (this.artifactsByDetailId) {
+            const artifacts = this.artifactsByDetailId.get(lastAIMessage.ID);
+            if (artifacts && artifacts.length > 0) {
+                try {
+                    // Use the first artifact (should only be one OUTPUT per message)
+                    const artifact = artifacts[0];
+                    const version = await artifact.getVersion();
+                    if (version.Content) {
                         previousPayload = JSON.parse(version.Content);
                         previousArtifactInfo = {
-                            artifactId: version.ArtifactID,
-                            versionId: version.ID,
-                            versionNumber: version.VersionNumber || 1
+                            artifactId: artifact.artifactId,
+                            versionId: artifact.artifactVersionId,
+                            versionNumber: artifact.versionNumber
                         };
                         console.log('📦 Loaded previous OUTPUT artifact as payload for continuity', previousArtifactInfo);
                     }
-                    catch (error) {
-                        console.warn('⚠️ Could not parse previous artifact content:', error);
-                    }
+                }
+                catch (error) {
+                    console.warn('⚠️ Could not parse previous artifact content:', error);
                 }
             }
         }
@@ -1178,13 +1161,15 @@ export class MessageInputComponent {
             agentName: agentName,
             status: 'Processing refinement...',
             relatedMessageId: userMessage.ID,
-            conversationDetailId: statusMessage.ID
+            conversationDetailId: statusMessage.ID,
+            conversationId: this.conversationId,
+            conversationName: this.conversationName
         });
         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, agentName), previousArtifactInfo?.artifactId, previousArtifactInfo?.versionId);
             // Remove from active tasks
-            this.activeTasks.remove(taskId);
+            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             if (continuityResult && continuityResult.success) {
                 // Create response message
                 const agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
@@ -1210,33 +1195,21 @@ export class MessageInputComponent {
                     this.messageSent.emit(agentResponseMessage);
                 }
                 // Mark user message as complete
-                userMessage.Status = 'Complete';
-                await userMessage.Save();
-                this.messageSent.emit(userMessage);
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
             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);
+                await this.updateConversationDetail(statusMessage, `❌ **${agentName}** failed during refinement\n\n${continuityResult?.agentRun?.ErrorMessage || 'Unknown error'}`, 'Error');
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
         }
         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)}`;
+            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             statusMessage.Error = String(error);
-            await statusMessage.Save();
-            this.messageSent.emit(statusMessage);
-            userMessage.Status = 'Complete';
-            await userMessage.Save();
-            this.messageSent.emit(userMessage);
+            await this.updateConversationDetail(statusMessage, `❌ **${agentName}** encountered an error\n\n${String(error)}`, 'Error');
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
     }
     /**
@@ -1250,8 +1223,12 @@ export class MessageInputComponent {
             agentName: agentName,
             status: 'Processing...',
             relatedMessageId: userMessage.ID,
-            conversationDetailId: userMessage.ID
+            conversationDetailId: userMessage.ID,
+            conversationId: this.conversationId,
+            conversationName: this.conversationName
         });
+        // Declare agentResponseMessage outside try block so it's accessible in catch
+        let agentResponseMessage = undefined;
         try {
             // Update user message status to In-Progress
             userMessage.Status = 'In-Progress';
@@ -1260,7 +1237,7 @@ export class MessageInputComponent {
             // 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 agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
+            agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -1278,7 +1255,7 @@ export class MessageInputComponent {
             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, agentName));
             // Remove from active tasks
-            this.activeTasks.remove(taskId);
+            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             if (result && result.success) {
                 if (result.agentRun.AgentID) {
                     agentResponseMessage.AgentID = result.agentRun.AgentID;
@@ -1296,7 +1273,7 @@ export class MessageInputComponent {
                 }
                 // Stage 3: Normal chat response
                 else {
-                    await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
+                    await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', result.suggestedResponses);
                     // Server created artifacts - emit event to trigger UI reload
                     if (result.payload && Object.keys(result.payload).length > 0) {
                         this.artifactCreated.emit({
@@ -1309,103 +1286,100 @@ export class MessageInputComponent {
                         this.messageSent.emit(agentResponseMessage);
                     }
                     // Mark user message as complete
-                    userMessage.Status = 'Complete';
-                    await userMessage.Save();
-                    this.messageSent.emit(userMessage);
+                    await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
                 }
             }
             else {
-                // Agent failed - create error message
-                const errorMessage = await this.dataCache.createConversationDetail(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);
+                // Agent failed - update the existing message instead of creating a new one
+                agentResponseMessage.Error = result?.agentRun?.ErrorMessage || null;
+                await this.updateConversationDetail(agentResponseMessage, `❌ **@${agentName}** failed\n\n${result?.agentRun?.ErrorMessage || 'Unknown error'}`, 'Error');
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
         }
         catch (error) {
             console.error(`❌ Error invoking mentioned agent ${agentName}:`, error);
-            this.activeTasks.remove(taskId);
-            const errorMessage = await this.dataCache.createConversationDetail(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);
+            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
+            // Update the existing agent response message if it was created
+            if (agentResponseMessage) {
+                agentResponseMessage.Error = String(error);
+                await this.updateConversationDetail(agentResponseMessage, `❌ **@${agentName}** encountered an error\n\n${String(error)}`, 'Error');
+            }
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
     }
     /**
      * Continue with the same agent from previous message (implicit continuation)
      * Bypasses Sage - no status messages
+     *
+     * @param targetArtifactVersionId Optional specific artifact version to use as payload (from intent check)
      */
-    async continueWithAgent(userMessage, agentId, conversationId) {
+    async continueWithAgent(userMessage, agentId, conversationId, targetArtifactVersionId) {
         // Load the agent entity to get its name
-        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) {
+        const agent = AIEngineBase.Instance.Agents.find(a => a.ID === agentId);
+        if (!agent) {
             console.warn('⚠️ Could not load agent for continuation - falling back to Sage');
             await this.processMessageThroughAgent(userMessage, { mentions: [], agentMention: null, userMentions: [] });
             return;
         }
-        const agent = agentResult.Results[0];
         const agentName = agent.Name || 'Agent';
-        // Find the last AI message from this same agent to get the previous OUTPUT artifact
-        const lastAIMessage = this.conversationHistory
-            .slice()
-            .reverse()
-            .find(msg => msg.Role === 'AI' && msg.AgentID === agentId);
         let previousPayload = null;
         let previousArtifactInfo = null;
-        if (lastAIMessage) {
-            // 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);
-            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 {
+        // Use targetArtifactVersionId if specified (from intent check)
+        if (targetArtifactVersionId && this.artifactsByDetailId) {
+            console.log('🎯 Using target artifact version from intent check:', targetArtifactVersionId);
+            // Find the artifact in pre-loaded data (O(n) search across all messages)
+            for (const [detailId, artifacts] of this.artifactsByDetailId.entries()) {
+                const targetArtifact = artifacts.find(a => a.artifactVersionId === targetArtifactVersionId);
+                if (targetArtifact) {
+                    try {
+                        // Lazy load the full version entity to get Content
+                        const version = await targetArtifact.getVersion();
+                        if (version.Content) {
                             previousPayload = JSON.parse(version.Content);
                             previousArtifactInfo = {
-                                artifactId: version.ArtifactID,
-                                versionId: version.ID,
-                                versionNumber: version.VersionNumber || 1
+                                artifactId: targetArtifact.artifactId,
+                                versionId: targetArtifact.artifactVersionId,
+                                versionNumber: targetArtifact.versionNumber
                             };
-                            console.log('📦 Loaded previous OUTPUT artifact as payload for continuation', previousArtifactInfo);
+                            console.log('📦 Loaded target artifact version as payload', previousArtifactInfo);
                         }
-                        catch (error) {
-                            console.warn('⚠️ Could not parse previous artifact content:', error);
+                    }
+                    catch (error) {
+                        console.warn('⚠️ Could not load target artifact version:', error);
+                    }
+                    break;
+                }
+            }
+        }
+        // Fall back to most recent artifact if no target specified or target not found
+        if (!previousPayload) {
+            console.log('📦 Using most recent artifact from last agent message');
+            // Find the last AI message from this same agent
+            const lastAIMessage = this.conversationHistory
+                .slice()
+                .reverse()
+                .find(msg => msg.Role === 'AI' && msg.AgentID === agentId);
+            if (lastAIMessage && this.artifactsByDetailId) {
+                // Get artifacts from pre-loaded data (no DB query!)
+                const artifacts = this.artifactsByDetailId.get(lastAIMessage.ID);
+                if (artifacts && artifacts.length > 0) {
+                    try {
+                        // Use the first artifact (should only be one OUTPUT per message)
+                        const artifact = artifacts[0];
+                        const version = await artifact.getVersion();
+                        if (version.Content) {
+                            previousPayload = JSON.parse(version.Content);
+                            previousArtifactInfo = {
+                                artifactId: artifact.artifactId,
+                                versionId: artifact.artifactVersionId,
+                                versionNumber: artifact.versionNumber
+                            };
+                            console.log('📦 Loaded most recent artifact as payload', previousArtifactInfo);
                         }
                     }
+                    catch (error) {
+                        console.warn('⚠️ Could not parse artifact content:', error);
+                    }
                 }
             }
         }
@@ -1414,15 +1388,19 @@ export class MessageInputComponent {
             agentName: agentName,
             status: 'Processing...',
             relatedMessageId: userMessage.ID,
-            conversationDetailId: userMessage.ID
+            conversationDetailId: userMessage.ID,
+            conversationId: this.conversationId,
+            conversationName: this.conversationName
         });
+        // Declare agentResponseMessage outside try block so it's accessible in catch
+        let agentResponseMessage = undefined;
         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 this.dataCache.createConversationDetail(this.currentUser);
+            agentResponseMessage = await this.dataCache.createConversationDetail(this.currentUser);
             agentResponseMessage.ConversationID = conversationId;
             agentResponseMessage.Role = 'AI';
             agentResponseMessage.Message = '⏳ Starting...'; // Initial message
@@ -1437,10 +1415,10 @@ export class MessageInputComponent {
             const result = await this.agentService.invokeSubAgent(agentName, conversationId, userMessage, this.conversationHistory, 'Continuing previous conversation with user', agentResponseMessage.ID, previousPayload, // Pass previous OUTPUT artifact payload for continuity
             this.createProgressCallback(agentResponseMessage, agentName), previousArtifactInfo?.artifactId, previousArtifactInfo?.versionId);
             // Remove from active tasks
-            this.activeTasks.remove(taskId);
+            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
             if (result && result.success) {
                 // Update the response message with agent result
-                await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete');
+                await this.updateConversationDetail(agentResponseMessage, result.agentRun?.Message || `✅ **${agentName}** completed`, 'Complete', result.suggestedResponses);
                 // Server created artifacts (handles versioning) - emit event to trigger UI reload
                 if (result.payload && Object.keys(result.payload).length > 0) {
                     this.artifactCreated.emit({
@@ -1453,43 +1431,24 @@ export class MessageInputComponent {
                     this.messageSent.emit(agentResponseMessage);
                 }
                 // Mark user message as complete
-                userMessage.Status = 'Complete';
-                await userMessage.Save();
-                this.messageSent.emit(userMessage);
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
             else {
-                // Agent failed - create error message
-                const errorMessage = await this.dataCache.createConversationDetail(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);
+                // Agent failed - update the existing message instead of creating a new one
+                agentResponseMessage.Error = result?.agentRun?.ErrorMessage || null;
+                await this.updateConversationDetail(agentResponseMessage, `❌ **${agentName}** failed\n\n${result?.agentRun?.ErrorMessage || 'Unknown error'}`, 'Error');
+                await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
             }
         }
         catch (error) {
             console.error(`❌ Error continuing with agent ${agentName}:`, error);
-            this.activeTasks.remove(taskId);
-            const errorMessage = await this.dataCache.createConversationDetail(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);
+            // Task removed in markMessageComplete() - this.activeTasks.remove(taskId);
+            // Update the existing agent response message if it was created
+            if (agentResponseMessage) {
+                agentResponseMessage.Error = String(error);
+                await this.updateConversationDetail(agentResponseMessage, `❌ **${agentName}** encountered an error\n\n${String(error)}`, 'Error');
+            }
+            await this.updateConversationDetail(userMessage, userMessage.Message, 'Complete');
         }
     }
     /**
@@ -1553,6 +1512,22 @@ export class MessageInputComponent {
     markMessageComplete(conversationDetail) {
         const now = Date.now();
         this.completionTimestamps.set(conversationDetail.ID, now);
+        // Remove task from active tasks if it exists
+        const task = this.activeTasks.getByConversationDetailId(conversationDetail.ID);
+        if (task) {
+            console.log(`✅ Task found for message ${conversationDetail.ID} - removing from active tasks:`, {
+                taskId: task.id,
+                agentName: task.agentName,
+                conversationId: task.conversationId,
+                conversationName: task.conversationName
+            });
+            this.activeTasks.remove(task.id);
+            // Show completion notification
+            MJNotificationService.Instance?.CreateSimpleNotification(`${task.agentName} completed in ${task.conversationName || 'conversation'}`, 'success', 3000);
+        }
+        else {
+            console.warn(`⚠️ No task found for completed message ${conversationDetail.ID} - task may have been removed prematurely or not added`);
+        }
         // Emit completion event to parent so it can refresh agent run data
         this.messageComplete.emit({
             conversationDetailId: conversationDetail.ID,
@@ -1574,7 +1549,7 @@ export class MessageInputComponent {
         } if (rf & 2) {
             let _t;
             i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.inputBox = _t.first);
-        } }, inputs: { conversationId: "conversationId", currentUser: "currentUser", disabled: "disabled", placeholder: "placeholder", parentMessageId: "parentMessageId", conversationHistory: "conversationHistory", initialMessage: "initialMessage" }, outputs: { messageSent: "messageSent", agentResponse: "agentResponse", agentRunDetected: "agentRunDetected", agentRunUpdate: "agentRunUpdate", messageComplete: "messageComplete", artifactCreated: "artifactCreated", conversationRenamed: "conversationRenamed", intentCheckStarted: "intentCheckStarted", intentCheckCompleted: "intentCheckCompleted" }, features: [i0.ɵɵNgOnChangesFeature], decls: 4, vars: 8, consts: [["inputBox", ""], [1, "message-input-wrapper"], ["class", "processing-indicator", 4, "ngIf"], [3, "valueChange", "textSubmitted", "placeholder", "disabled", "showCharacterCount", "enableMentions", "currentUser", "rows", "value"], [1, "processing-indicator"], [1, "fas", "fa-circle-notch", "fa-spin"]], template: function MessageInputComponent_Template(rf, ctx) { if (rf & 1) {
+        } }, inputs: { conversationId: "conversationId", conversationName: "conversationName", currentUser: "currentUser", disabled: "disabled", placeholder: "placeholder", parentMessageId: "parentMessageId", conversationHistory: "conversationHistory", initialMessage: "initialMessage", artifactsByDetailId: "artifactsByDetailId", agentRunsByDetailId: "agentRunsByDetailId", inProgressMessageIds: "inProgressMessageIds" }, outputs: { messageSent: "messageSent", agentResponse: "agentResponse", agentRunDetected: "agentRunDetected", agentRunUpdate: "agentRunUpdate", messageComplete: "messageComplete", artifactCreated: "artifactCreated", conversationRenamed: "conversationRenamed", intentCheckStarted: "intentCheckStarted", intentCheckCompleted: "intentCheckCompleted" }, features: [i0.ɵɵNgOnChangesFeature], decls: 4, vars: 8, consts: [["inputBox", ""], [1, "message-input-wrapper"], ["class", "processing-indicator", 4, "ngIf"], [3, "valueChange", "textSubmitted", "placeholder", "disabled", "showCharacterCount", "enableMentions", "currentUser", "rows", "value"], [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);
             i0.ɵɵtemplate(1, MessageInputComponent_div_1_Template, 4, 1, "div", 2);
@@ -1595,6 +1570,8 @@ export class MessageInputComponent {
         args: [{ selector: 'mj-message-input', template: "<div class=\"message-input-wrapper\">\n  <!-- Processing Indicator Overlay -->\n  <div class=\"processing-indicator\" *ngIf=\"isProcessing\">\n    <i class=\"fas fa-circle-notch fa-spin\"></i>\n    <span>{{ processingMessage }}</span>\n  </div>\n\n  <!-- Message Input Box -->\n  <mj-message-input-box\n    #inputBox\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled || isProcessing\"\n    [showCharacterCount]=\"false\"\n    [enableMentions]=\"true\"\n    [currentUser]=\"currentUser\"\n    [rows]=\"3\"\n    [(value)]=\"messageText\"\n    (textSubmitted)=\"onTextSubmitted($event)\">\n  </mj-message-input-box>\n</div>", styles: [".message-input-wrapper {\n  position: relative;\n  width: 100%;\n}\n\n.processing-indicator {\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  display: flex;\n  align-items: center;\n  gap: 0.5rem;\n  padding: 0.75rem 1.25rem;\n  background: rgba(255, 255, 255, 0.95);\n  border-radius: 8px;\n  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);\n  z-index: 10;\n  pointer-events: none;\n\n  i {\n    color: var(--primary-color, #007bff);\n  }\n\n  span {\n    font-size: 0.9rem;\n    color: var(--text-primary, #333);\n  }\n}"] }]
     }], () => [{ type: i1.DialogService }, { type: i2.ToastService }, { type: i3.ConversationAgentService }, { type: i4.ConversationStateService }, { type: i5.DataCacheService }, { type: i6.ActiveTasksService }, { type: i7.MentionParserService }, { type: i8.MentionAutocompleteService }], { conversationId: [{
             type: Input
+        }], conversationName: [{
+            type: Input
         }], currentUser: [{
             type: Input
         }], disabled: [{
@@ -1607,6 +1584,12 @@ export class MessageInputComponent {
             type: Input
         }], initialMessage: [{
             type: Input
+        }], artifactsByDetailId: [{
+            type: Input
+        }], agentRunsByDetailId: [{
+            type: Input
+        }], inProgressMessageIds: [{
+            type: Input
         }], messageSent: [{
             type: Output
         }], agentResponse: [{
@@ -1629,5 +1612,5 @@ export class MessageInputComponent {
             type: ViewChild,
             args: ['inputBox']
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 23 }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(MessageInputComponent, { className: "MessageInputComponent", filePath: "src/lib/components/message/message-input.component.ts", lineNumber: 25 }); })();
 //# sourceMappingURL=message-input.component.js.map