@memberjunction/ng-conversations 5.40.1 → 5.41.0

package/dist/lib/services/conversation-agent.service.js

@@ -1,38 +1,57 @@
 import { Injectable } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
-import { Metadata, RunView } from '@memberjunction/core';
+import { Metadata } from '@memberjunction/core';
 import { GraphQLAIClient } from '@memberjunction/graphql-dataprovider';
-import { AIEngineBase, AIAgentPermissionHelper } from '@memberjunction/ai-engine-base';
+import { AIEngineBase } from '@memberjunction/ai-engine-base';
 import { MJNotificationService } from '@memberjunction/ng-notifications';
+import { ConversationsRuntime } from '@memberjunction/conversations-runtime';
 import { UUIDsEqual } from '@memberjunction/global';
 import * as i0 from "@angular/core";
-import * as i1 from "./mention-parser.service";
-import * as i2 from "@memberjunction/ng-agent-client";
+import * as i1 from "./conversations-runtime-bootstrap.service";
+import * as i2 from "./mention-parser.service";
+import * as i3 from "@memberjunction/ng-agent-client";
 /**
- * Service for managing agent interactions within conversations.
- * Handles communication with the ambient Sage Agent and other agents.
+ * Angular DI service for conversation-level agent orchestration.
+ *
+ * After PR 2 of the conversations-runtime extraction, the core
+ * `processMessage` flow and the conversation-manager-agent resolution are
+ * delegated to `@memberjunction/conversations-runtime`. This service is
+ * primarily a shim for those operations PLUS the holder of the helpers
+ * that haven't been ported yet:
+ *
+ * - `invokeSubAgent(...)` — used by Sage's routing decisions in
+ *   `message-input.component`.
+ * - `checkAgentContinuityIntent(...)` — fast intent classification when the
+ *   user replies to a previous-agent thread.
+ * - `findConfigurationPresetFromHistory(...)` — locates an agent's preset
+ *   from prior @mentions in the conversation.
+ * - `clearSession(...)` — per-conversation session-id bookkeeping.
+ *
+ * These can move to the runtime in a follow-up; they aren't strictly needed
+ * to invoke an agent end-to-end and stay here so the shim has zero behavior
+ * difference vs. the original.
  */
 export class ConversationAgentService {
     mentionParser;
     agentClientService;
     /** GraphQL AI client - retained for RunAIPrompt (intent checking) which AgentClientService doesn't wrap */
     _aiClient = null;
+    /** Cached resolution of the conversation manager agent (default agent). */
     _conversationManagerAgent = null;
-    _sessionIds = new Map(); // conversationId -> sessionId
-    _isProcessing$ = new BehaviorSubject(false);
-    /**
-     * Observable indicating if the ambient agent is currently processing
-     */
-    isProcessing$ = this._isProcessing$.asObservable();
+    _sessionIds = new Map();
+    /** Observable indicating if the ambient agent is currently processing — delegated to the runtime's AgentRunner. */
+    isProcessing$;
     _provider = null;
-    constructor(mentionParser, agentClientService) {
+    constructor(_bootstrap, mentionParser, agentClientService) {
         this.mentionParser = mentionParser;
         this.agentClientService = agentClientService;
+        // Injecting `_bootstrap` forces the runtime's INotificationAdapter +
+        // IActiveTaskTracker adapters to register before any shim method runs.
+        this.isProcessing$ = ConversationsRuntime.Instance.AgentRunner.isProcessing$;
         this.initializeAIClient();
     }
     /**
      * The metadata provider this service uses. When unset, falls back to Metadata.Provider.
-     * Setting it re-initializes the AI client to bind to the supplied provider.
+     * Setting it re-initializes the AI client and forwards the provider to the runtime's runner.
      */
     get Provider() {
         return this._provider ?? Metadata.Provider;
@@ -40,11 +59,12 @@ export class ConversationAgentService {
     set Provider(value) {
         this._provider = value;
         this.initializeAIClient();
+        ConversationsRuntime.Instance.AgentRunner.Provider = value;
     }
     /**
      * Initialize the GraphQL AI Client.
      * Retained for RunAIPrompt calls (intent checking) which the AgentClientService doesn't wrap.
-     * Agent execution (RunAIAgentFromConversationDetail) now goes through AgentClientService.
+     * Agent execution (RunAIAgentFromConversationDetail) now goes through ConversationsRuntime.AgentRunner.
      */
     initializeAIClient() {
         try {
@@ -61,133 +81,78 @@ export class ConversationAgentService {
         }
     }
     /**
-     * Get or load the Sage Agent (formerly Conversation Manager Agent)
+     * Resolve the conversation manager agent via the runtime's 4-step
+     * DefaultAgentResolver chain (explicit input → app-scoped Application
+     * Setting → global Application Setting → code-const Sage fallback). The
+     * result is cached on this service for use by the synchronous
+     * {@link ConversationManagerAgentName} getter.
+     *
+     * Existing callers expect a Promise<MJAIAgentEntityExtended | null> — we
+     * preserve that shape (returning null on failure rather than throwing)
+     * so the call sites don't need to change.
      */
     async getConversationManagerAgent() {
         if (this._conversationManagerAgent) {
             return this._conversationManagerAgent;
         }
         try {
-            // Ensure AIEngineBase is configured
-            await AIEngineBase.Instance.Config(false);
-            // Find the Sage Agent
-            const agents = AIEngineBase.Instance.Agents;
-            this._conversationManagerAgent = agents.find((agent) => agent.Name === 'Sage') || null;
-            if (!this._conversationManagerAgent) {
-                const errorMsg = 'Sage Agent not found in AIEngineBase.Agents';
-                console.warn(errorMsg);
-                MJNotificationService.Instance?.CreateSimpleNotification(errorMsg, 'error', 5000);
-            }
-            return this._conversationManagerAgent;
+            const provider = this.Provider;
+            const agent = await ConversationsRuntime.Instance.DefaultAgent.resolve({
+                contextUser: provider.CurrentUser ?? undefined,
+                provider,
+            });
+            this._conversationManagerAgent = agent;
+            return agent;
         }
         catch (error) {
-            const errorMsg = 'Error loading Sage Agent: ' + (error instanceof Error ? error.message : String(error));
-            console.error('Error loading Sage Agent:', error);
+            const errorMsg = 'Error resolving conversation manager agent: ' + (error instanceof Error ? error.message : String(error));
+            console.error(errorMsg);
             MJNotificationService.Instance?.CreateSimpleNotification(errorMsg, 'error', 5000);
             return null;
         }
     }
     /**
-     * Process a message through the ambient Sage Agent.
-     * This should be called for every message sent in a conversation.
-     *
-     * Uses the optimized RunAIAgentFromConversationDetail mutation which loads
-     * conversation history (including attachments) server-side for better performance.
+     * Synchronous read of the cached conversation-manager-agent name. Returns
+     * `null` until {@link getConversationManagerAgent} has been called at least
+     * once and resolved successfully. Used by `MessageItemComponent.isConversationManager`
+     * to flag messages from the routing agent without hardcoding `'Sage'`.
+     */
+    get ConversationManagerAgentName() {
+        return this._conversationManagerAgent?.Name ?? null;
+    }
+    /**
+     * Returns `true` if the supplied agent identifier (UUID or name) matches the
+     * currently cached conversation manager agent. Robust to either input.
+     */
+    IsConversationManagerAgent(agentIdOrName) {
+        if (!agentIdOrName || !this._conversationManagerAgent)
+            return false;
+        return (UUIDsEqual(this._conversationManagerAgent.ID, agentIdOrName) ||
+            this._conversationManagerAgent.Name === agentIdOrName);
+    }
+    /**
+     * Process a message through the conversation manager agent. Delegates to
+     * `ConversationsRuntime.Instance.AgentRunner.processMessage(...)`.
      *
-     * @param conversationId The conversation ID
-     * @param message The message that was just sent
-     * @param conversationHistory Recent messages in the conversation for context (kept for backwards compatibility but not used)
-     * @param conversationDetailId The ID of the conversation detail record to link to the agent run
-     * @param onProgress Optional callback for receiving progress updates during execution
-     * @returns The agent's response, or null if the agent chooses not to respond
+     * Signature is preserved verbatim from the original service so existing
+     * call sites continue to compile. The unused `conversationHistory`
+     * parameter is kept for backwards compatibility (it was already
+     * documented as "kept for backwards compatibility but not used" in the
+     * original).
      */
     async processMessage(conversationId, message, conversationHistory, conversationDetailId, onProgress, appContext) {
-        // Don't process if user is tagging someone else (future enhancement)
-        // For now, we'll always send to the ambient agent
-        const agent = await this.getConversationManagerAgent();
-        if (!agent || !agent.ID) {
-            const errorMsg = 'Sage Agent not available';
-            console.warn(errorMsg);
-            MJNotificationService.Instance?.CreateSimpleNotification(errorMsg, 'warning', 5000);
-            return null;
-        }
-        try {
-            // Indicate agent is processing
-            this._isProcessing$.next(true);
-            // Get current user for permission filtering
-            const currentUser = this.Provider.CurrentUser;
-            if (!currentUser) {
-                console.warn('⚠️ No current user available for permission filtering, using unfiltered agents');
-            }
-            // Filter agents by status and hierarchy first
-            const candidateAgents = AIEngineBase.Instance.Agents.filter(a => !UUIDsEqual(a.ID, agent.ID) &&
-                !a.ParentID &&
-                a.Status === 'Active' &&
-                a.InvocationMode !== 'Sub-Agent' // ensure that the agent is intended to run as top-level
-            );
-            // Filter by user permissions if user context available
-            const availAgents = currentUser
-                ? await this.filterAgentsByPermissions(candidateAgents, currentUser)
-                : candidateAgents;
-            console.log(`📋 Available agents for Sage: ${availAgents.length} (filtered from ${candidateAgents.length} candidates)`);
-            // Use AgentClientService which wraps GraphQLAIClient.RunAIAgentFromConversationDetail
-            // and automatically integrates with client tool request handling
-            const agentParams = {
-                ConversationDetailId: conversationDetailId,
-                AgentId: agent.ID,
-                MaxHistoryMessages: 20,
-                Data: {
-                    ALL_AVAILABLE_AGENTS: availAgents.map(a => ({
-                        ID: a.ID,
-                        Name: a.Name,
-                        Description: a.Description
-                    })),
-                    conversationId: conversationId,
-                    latestMessageId: message.ID,
-                    ...(appContext ? { appContext } : {}),
-                    // Include all registered client tools so the LLM sees them in the prompt.
-                    // These are ephemeral tools registered by the client app (CopyToClipboard, etc.)
-                    // that supplement the metadata-defined tools from the junction table.
-                    clientTools: this.agentClientService.GetRegisteredTools().map(t => ({
-                        Name: t.Name,
-                        Description: t.Description,
-                        InputSchema: t.ParameterSchema
-                    }))
-                },
-                CreateArtifacts: true,
-                CreateNotification: true,
-                OnProgress: onProgress ? (progress) => {
-                    onProgress({
-                        step: progress.CurrentStep,
-                        percentage: progress.Percentage,
-                        message: progress.Message,
-                        metadata: progress.Metadata
-                    });
-                } : undefined
-            };
-            const runResult = await this.agentClientService.RunAgentFromConversationDetail(agentParams);
-            // Unwrap RunAgentResult to get the original ExecuteAgentResult
-            if (runResult.Success && runResult.Result) {
-                return runResult.Result;
-            }
-            else if (!runResult.Success) {
-                const errorMsg = runResult.ErrorMessage || 'Agent execution failed';
-                console.error('Agent execution failed:', errorMsg);
-                MJNotificationService.Instance?.CreateSimpleNotification(errorMsg, 'error', 5000);
-                return null;
-            }
-            return null;
-        }
-        catch (error) {
-            const errorMsg = 'Error processing message through agent: ' + (error instanceof Error ? error.message : String(error));
-            console.error('Error processing message through agent:', error);
-            MJNotificationService.Instance?.CreateSimpleNotification(errorMsg, 'error', 5000);
-            return null;
-        }
-        finally {
-            // Always clear processing state
-            this._isProcessing$.next(false);
+        // Warm the cached default-agent name for any synchronous consumers
+        // before the runtime resolves on its own.
+        if (!this._conversationManagerAgent) {
+            await this.getConversationManagerAgent();
         }
+        return ConversationsRuntime.Instance.AgentRunner.processMessage({
+            conversationId,
+            message,
+            conversationDetailId,
+            appContext,
+            onProgress,
+        });
     }
     /**
      * Find the configuration preset ID from a previous @mention of an agent in conversation history.
@@ -206,7 +171,6 @@ export class ConversationAgentService {
             .find(msg => {
             if (msg.Role !== 'User' || !msg.Message)
                 return false;
-            // Parse the message to check for an @mention of this agent with a configId
             const mentionResult = this.mentionParser.parseMentions(msg.Message, AIEngineBase.Instance.Agents, []);
             return mentionResult.agentMention?.id === agentId && mentionResult.agentMention?.configurationId;
         });
@@ -220,132 +184,17 @@ export class ConversationAgentService {
         return undefined;
     }
     /**
-     * Build the message array for the agent from conversation history.
-     * Note: conversationHistory already includes the current message, so we don't add it separately.
-     * IMPORTANT: This method loads artifacts and attachments for each message.
-     *
-     * @deprecated This method is no longer used by processMessage() which now uses the optimized
-     * RunAIAgentFromConversationDetail mutation that loads history server-side. Kept for backwards
-     * compatibility with other callers that may need client-side message building.
-     */
-    async buildAgentMessages(history) {
-        const messages = [];
-        // Add historical messages (limit to recent context, e.g., last 20 messages)
-        // History already includes the current message from the caller
-        const recentHistory = history.slice(-20);
-        // Get IDs of all messages in history
-        const messageIds = recentHistory.map(msg => msg.ID).filter(id => id); // Filter out any undefined IDs
-        // Create lookup maps
-        const artifactsByDetailId = new Map(); // DetailID -> array of artifact JSON strings
-        // attachmentsByDetailId removed — artifact junction is the single source of truth
-        // after the backfill migration. Multimodal content handled server-side.
-        if (messageIds.length > 0) {
-            const rv = RunView.FromMetadataProvider(this.Provider);
-            // Load artifacts for messages. Since the backfill migration
-            // (V202605271400__Backfill_Attachment_Artifacts) converted all legacy
-            // ConversationDetailAttachment rows to artifact pairs, the artifact
-            // junction is the single source of truth. Multimodal content (images,
-            // audio, video) is handled server-side by the resolver's artifact path.
-            const artifactsLoaded = await this.loadArtifactsForMessages(rv, messageIds, artifactsByDetailId);
-            if (artifactsLoaded) {
-                console.log(`📦 Loaded ${artifactsByDetailId.size} artifact groups for ${messageIds.length} messages`);
-            }
-        }
-        // Build messages with artifact context
-        for (const msg of recentHistory) {
-            const messageText = msg.Message || '';
-            const artifacts = artifactsByDetailId.get(msg.ID);
-            let content = messageText;
-            if (artifacts && artifacts.length > 0) {
-                for (const artifactJson of artifacts) {
-                    content += `\n\n# Artifact\n${artifactJson}\n`;
-                }
-            }
-            messages.push({
-                role: this.mapRoleToAgentRole(msg.Role),
-                content: content
-            });
-        }
-        return messages;
-    }
-    /**
-     * Load artifacts for messages (OUTPUT direction only)
-     */
-    async loadArtifactsForMessages(rv, messageIds, artifactsByDetailId) {
-        try {
-            const junctionResult = await rv.RunView({
-                EntityName: 'MJ: Conversation Detail Artifacts',
-                ExtraFilter: `ConversationDetailID IN ('${messageIds.join("','")}') AND Direction='Output'`,
-                ResultType: 'entity_object'
-            });
-            if (junctionResult.Success && junctionResult.Results && junctionResult.Results.length > 0) {
-                // Collect unique version IDs
-                const versionIds = new Set();
-                for (const junction of junctionResult.Results) {
-                    versionIds.add(junction.ArtifactVersionID);
-                }
-                // Batch load all artifact versions
-                const versionResult = await rv.RunView({
-                    EntityName: 'MJ: Artifact Versions',
-                    ExtraFilter: `ID IN ('${Array.from(versionIds).join("','")}')`,
-                    ResultType: 'entity_object'
-                });
-                if (versionResult.Success && versionResult.Results) {
-                    const versionMap = new Map(versionResult.Results.map(v => [v.ID, v]));
-                    for (const junction of junctionResult.Results) {
-                        const version = versionMap.get(junction.ArtifactVersionID);
-                        if (version && version.Content) {
-                            const existing = artifactsByDetailId.get(junction.ConversationDetailID) || [];
-                            existing.push(version.Content);
-                            artifactsByDetailId.set(junction.ConversationDetailID, existing);
-                        }
-                    }
-                    return true;
-                }
-            }
-        }
-        catch (error) {
-            console.error('Error loading artifacts for conversation context:', error);
-        }
-        return false;
-    }
-    /**
-     * Map ConversationDetail Role to agent message role
-     */
-    mapRoleToAgentRole(role) {
-        const roleLower = (role || '').toLowerCase();
-        if (roleLower === 'user')
-            return 'user';
-        if (roleLower === 'assistant' || roleLower === 'agent')
-            return 'assistant';
-        return 'user'; // Default to user
-    }
-    /**
-     * Check if a message is tagging another user or agent.
-     * Returns true if the message contains @mentions that are NOT the ambient agent.
-     * Future enhancement: parse @mentions and determine if ambient agent should process.
+     * Clear the session for a conversation (useful when starting a new topic)
      */
-    isTaggingOthers(message) {
-        // Future implementation: check for @mentions
-        // For now, always return false (always process through ambient agent)
-        return false;
+    clearSession(conversationId) {
+        this._sessionIds.delete(conversationId);
     }
     /**
      * Invoke a sub-agent based on Sage Agent's payload.
      * This is called when Sage decides to delegate to a specialist agent.
      *
-     * @param agentName Name of the agent to invoke
-     * @param conversationId The conversation ID
-     * @param message The user message that triggered this
-     * @param conversationHistory Recent conversation history for context
-     * @param reasoning Why this agent is being invoked
-     * @param conversationDetailId The ID of the conversation detail record to link to the agent run
-     * @param payload Optional payload to pass to the agent (e.g., previous OUTPUT artifact for continuity)
-     * @param onProgress Optional callback for receiving progress updates during execution
-     * @param sourceArtifactId Optional source artifact ID for versioning
-     * @param sourceArtifactVersionId Optional source artifact version ID for versioning
-     * @param agentConfigurationPresetId Optional ID of the AIAgentConfiguration preset (will be mapped to AIConfigurationID)
-     * @returns The agent's execution result, or null if agent not found
+     * Stays on the Angular shim because it directly uses AgentClientService.
+     * Could move to the runtime in a follow-up if needed.
      */
     async invokeSubAgent(agentName, conversationId, message, conversationHistory, reasoning, conversationDetailId, payload, onProgress, sourceArtifactId, sourceArtifactVersionId, agentConfigurationPresetId, appContext) {
         try {
@@ -363,10 +212,7 @@ export class ConversationAgentService {
             // Map AIAgentConfiguration preset ID to actual AIConfiguration ID
             let aiConfigurationId = undefined;
             if (agentConfigurationPresetId) {
-                // Get the preset from AIEngineBase to extract the AIConfigurationID
                 const presets = AIEngineBase.Instance.GetAgentConfigurationPresets(agent.ID, false);
-                // check by preset ID or AIConfigurationID - since sometimes we have the actual
-                // configuration ID. Since both UUID no collisions should ever be possible.
                 const preset = presets.find(p => UUIDsEqual(p.ID, agentConfigurationPresetId) || UUIDsEqual(p.AIConfigurationID, agentConfigurationPresetId));
                 if (preset) {
                     aiConfigurationId = preset.AIConfigurationID || undefined;
@@ -376,8 +222,6 @@ export class ConversationAgentService {
                     console.warn(`Agent configuration preset ${agentConfigurationPresetId} not found for agent ${agent.ID}`);
                 }
             }
-            // Use AgentClientService which wraps GraphQLAIClient.RunAIAgentFromConversationDetail
-            // and integrates with client tool request handling
             const agentParams = {
                 ConversationDetailId: conversationDetailId,
                 AgentId: agent.ID,
@@ -386,12 +230,6 @@ export class ConversationAgentService {
                     conversationId: conversationId,
                     latestMessageId: message.ID,
                     invocationReason: reasoning,
-                    // Pass the embedder's appContext through to the agent runtime
-                    // so direct-routed sub-agents (e.g. Form Builder invoked via the
-                    // cockpit's `defaultAgentId`) see the same `appContext` block in
-                    // their system prompt that Sage-routed agents do. Without this,
-                    // the ActiveForm/Schema/OverrideID context the embedder
-                    // assembles is dropped on the floor for direct routing.
                     ...(appContext ? { appContext } : {}),
                 },
                 ...(payload ? { Payload: payload } : {}),
@@ -410,7 +248,6 @@ export class ConversationAgentService {
                 } : undefined
             };
             const runResult = await this.agentClientService.RunAgentFromConversationDetail(agentParams);
-            // Unwrap RunAgentResult to get the original ExecuteAgentResult
             if (runResult.Success && runResult.Result) {
                 return runResult.Result;
             }
@@ -433,11 +270,8 @@ export class ConversationAgentService {
      * Check if user's latest message should continue with the previous agent or route through Sage.
      * Uses fast inference (<500ms) to determine intent and avoid unnecessary Sage overhead.
      *
-     * @param agentId The ID of the previous agent
-     * @param latestMessage The user's new message
-     * @param conversationHistory Recent conversation history for context (last 10 messages)
-     * @param context Pre-loaded artifact and agent run data to avoid database queries
-     * @returns IntentCheckResult with decision, reasoning, and optional target artifact version
+     * Stays on the Angular shim because it directly uses GraphQLAIClient.
+     * Could move to the runtime in a follow-up.
      */
     async checkAgentContinuityIntent(agentId, latestMessage, conversationHistory, context) {
         if (!this._aiClient) {
@@ -445,29 +279,24 @@ export class ConversationAgentService {
             return { decision: 'UNSURE', reasoning: 'AI Client not initialized' };
         }
         try {
-            // Load the Check Sage Intent prompt
             await AIEngineBase.Instance.Config(false);
             const prompt = AIEngineBase.Instance.Prompts.find(p => p.Name === 'Check Sage Intent');
             if (!prompt) {
                 console.warn('⚠️ Check Sage Intent prompt not found, defaulting to UNSURE');
                 return { decision: 'UNSURE', reasoning: 'Check Sage Intent prompt not found' };
             }
-            // Get agent details
             const agent = AIEngineBase.Instance.Agents.find(a => UUIDsEqual(a.ID, agentId));
             if (!agent) {
                 console.warn('⚠️ Previous agent not found, defaulting to UNSURE');
                 return { decision: 'UNSURE', reasoning: 'Previous agent not found' };
             }
-            // Find all artifacts from this agent in this conversation
             const agentArtifacts = this.findAllAgentArtifacts(agentId, conversationHistory, context);
-            // Build compact conversation history (last 10 messages)
             const recentHistory = conversationHistory.slice(-10);
             const compactHistory = recentHistory.map((msg, idx) => {
                 const role = msg.Role === 'User' ? 'User' : agent.Name || 'Agent';
                 const content = msg.Message || '';
                 return `${idx + 1}. ${role}: ${content.substring(0, 150)}${content.length > 150 ? '...' : ''}`;
             }).join('\n');
-            // Build artifact context if available
             let artifactContext = '';
             if (agentArtifacts.length > 0) {
                 artifactContext = '\n\n**Prior Artifacts Created by This Agent**:\n';
@@ -483,7 +312,6 @@ export class ConversationAgentService {
                     }
                 });
             }
-            // Build user message with context
             const userMessage = `**Previous Agent**: ${agent.Name} - ${agent.Description || 'No description'}
 
 **Conversation History** (last ${recentHistory.length} messages):
@@ -495,7 +323,6 @@ ${compactHistory}${artifactContext}
                 messagePreview: latestMessage.substring(0, 50),
                 artifactCount: agentArtifacts.length
             });
-            // Run the prompt with artifact data included
             const result = await this._aiClient.RunAIPrompt({
                 promptId: prompt.ID,
                 messages: [{ role: 'user', content: userMessage }],
@@ -516,7 +343,6 @@ ${compactHistory}${artifactContext}
                         targetArtifactVersionId,
                         latency: result.executionTimeMs || 'unknown'
                     });
-                    // Validate the response
                     if (decision === 'YES' || decision === 'NO' || decision === 'UNSURE') {
                         return {
                             decision: decision,
@@ -531,43 +357,12 @@ ${compactHistory}${artifactContext}
         }
         catch (error) {
             console.error('❌ Error checking agent continuity intent:', error);
-            // On error, default to UNSURE (safer to let Sage evaluate)
             return {
                 decision: 'UNSURE',
                 reasoning: `Error during intent check: ${error instanceof Error ? error.message : String(error)}`
             };
         }
     }
-    /**
-     * Clear the session for a conversation (useful when starting a new topic)
-     */
-    clearSession(conversationId) {
-        this._sessionIds.delete(conversationId);
-    }
-    /**
-     * Filter agents based on user's 'run' permission.
-     * Only returns agents that the user has permission to run.
-     *
-     * @param agents List of candidate agents to filter
-     * @param user User to check permissions for
-     * @returns Filtered list of agents the user can run
-     */
-    async filterAgentsByPermissions(agents, user) {
-        const permittedAgents = [];
-        for (const agent of agents) {
-            try {
-                const hasPermission = await AIAgentPermissionHelper.HasPermission(agent.ID, user, 'run');
-                if (hasPermission) {
-                    permittedAgents.push(agent);
-                }
-            }
-            catch (error) {
-                console.error(`Error checking permission for agent ${agent.Name}:`, error);
-                // On error, exclude agent (fail closed)
-            }
-        }
-        return permittedAgents;
-    }
     /**
      * Find all artifacts created by the specified agent in this conversation.
      * Returns artifacts grouped by artifact with versions, ordered most recent first.
@@ -577,25 +372,19 @@ ${compactHistory}${artifactContext}
      */
     findAllAgentArtifacts(agentId, conversationDetails, context) {
         const artifactMap = new Map();
-        // Iterate backwards through conversation details (most recent first)
         for (let i = conversationDetails.length - 1; i >= 0; i--) {
             const detail = conversationDetails[i];
-            // Skip non-AI messages and errors
             if (detail.Role !== 'AI' || detail.Status === 'Error')
                 continue;
-            // O(1) lookup for agent run from pre-loaded data
             const agentRun = context.agentRunsByDetailId.get(detail.ID);
             if (!agentRun || !UUIDsEqual(agentRun.AgentID, agentId) || agentRun.Status !== 'Completed') {
                 continue;
             }
-            // O(1) lookup for artifacts from pre-loaded data
             const artifacts = context.artifactsByDetailId.get(detail.ID);
             if (!artifacts || artifacts.length === 0)
                 continue;
-            // Process each artifact
             for (const lazyArtifact of artifacts) {
                 const mainArtifactId = lazyArtifact.artifactId;
-                // Get or create artifact entry
                 if (!artifactMap.has(mainArtifactId)) {
                     artifactMap.set(mainArtifactId, {
                         artifactId: mainArtifactId,
@@ -605,7 +394,6 @@ ${compactHistory}${artifactContext}
                         versions: []
                     });
                 }
-                // Add version to artifact
                 const artifactEntry = artifactMap.get(mainArtifactId);
                 artifactEntry.versions.push({
                     runId: agentRun.ID,
@@ -617,14 +405,13 @@ ${compactHistory}${artifactContext}
                 });
             }
         }
-        // Convert map to array (most recent artifacts first based on their latest version)
         return Array.from(artifactMap.values()).sort((a, b) => {
             const aLatest = a.versions[0]?.createdAt || new Date(0);
             const bLatest = b.versions[0]?.createdAt || new Date(0);
             return bLatest.getTime() - aLatest.getTime();
         });
     }
-    static ɵfac = function ConversationAgentService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ConversationAgentService)(i0.ɵɵinject(i1.MentionParserService), i0.ɵɵinject(i2.AgentClientService)); };
+    static ɵfac = function ConversationAgentService_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ConversationAgentService)(i0.ɵɵinject(i1.ConversationsRuntimeBootstrap), i0.ɵɵinject(i2.MentionParserService), i0.ɵɵinject(i3.AgentClientService)); };
     static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ConversationAgentService, factory: ConversationAgentService.ɵfac, providedIn: 'root' });
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConversationAgentService, [{
@@ -632,5 +419,5 @@ ${compactHistory}${artifactContext}
         args: [{
                 providedIn: 'root'
             }]
-    }], () => [{ type: i1.MentionParserService }, { type: i2.AgentClientService }], null); })();
+    }], () => [{ type: i1.ConversationsRuntimeBootstrap }, { type: i2.MentionParserService }, { type: i3.AgentClientService }], null); })();
 //# sourceMappingURL=conversation-agent.service.js.map