@memberjunction/ng-conversations 6.2.0-edge.4 → 6.2.0-edge.6

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

@@ -1,12 +1,12 @@
 import { Injectable } from '@angular/core';
-import { Metadata, RunView } from '@memberjunction/core';
+import { LogStatusEx, Metadata, RunView } from '@memberjunction/core';
 import { GraphQLAIClient } from '@memberjunction/graphql-dataprovider';
 import { coerceFailedExecuteAgentResult } from '@memberjunction/ai-core-plus';
 import { AIEngineBase } from '@memberjunction/ai-engine-base';
 import { ConversationEngine } from '@memberjunction/core-entities';
 import { MJNotificationService } from '@memberjunction/ng-notifications';
 import { ConversationsRuntime } from '@memberjunction/conversations-runtime';
-import { UUIDsEqual } from '@memberjunction/global';
+import { EscapeSQLString, UUIDsEqual } from '@memberjunction/global';
 import { GroupVersionsByArtifact } from '../utils/agent-artifact-summary';
 import * as i0 from "@angular/core";
 import * as i1 from "./conversations-runtime-bootstrap.service";
@@ -115,6 +115,11 @@ export class ConversationAgentService {
         if (this._conversationManagerAgent) {
             return this._conversationManagerAgent;
         }
+        // A user who may not read the agents has no manager agent to resolve: say nothing, rather than an error for a state
+        // that is theirs by design (MJ#5240)
+        if (AIEngineBase.Instance.IsPermissionConstrained && AIEngineBase.Instance.ReadableAgents.length === 0) {
+            return null;
+        }
         try {
             const provider = this.Provider;
             const agent = await ConversationsRuntime.Instance.DefaultAgent.resolve({
@@ -158,17 +163,19 @@ export class ConversationAgentService {
      * Process a message through the conversation manager agent. Delegates to
      * `ConversationsRuntime.Instance.AgentRunner.processMessage(...)`.
      *
-     * 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).
+     * The unused `conversationHistory` parameter is kept for backwards compatibility (it was already
+     * documented as "kept for backwards compatibility but not used" in the original).
+     *
+     * @param onReplyAccepted Called with the reply row the server creates for the turn (only the server
+     *   writes agent replies), before any progress: key the turn's task and completion by its ID.
      */
-    async ProcessMessage(conversationId, message, conversationHistory, conversationDetailId, onProgress, appContext, planMode, requestedSkillIDs, 
+    async ProcessMessage(conversationId, message, conversationHistory, onReplyAccepted, onProgress, appContext, planMode, requestedSkillIDs, 
     /** The agents the conversation manager may delegate to. Null or omitted allows every agent. */
     allowedAgentIDs, 
     /** The first moment of the conversation the run may read. Null or omitted reads all of it. */
-    agentHistoryFrom) {
+    agentHistoryFrom, 
+    /** The branch the turn runs on when it forks off an earlier message on another branch. */
+    replyBranchId) {
         // Warm the cached default-agent name for any synchronous consumers
         // before the runtime resolves on its own.
         if (!this._conversationManagerAgent) {
@@ -177,18 +184,19 @@ export class ConversationAgentService {
         return ConversationsRuntime.Instance.AgentRunner.processMessage({
             conversationId,
             message,
-            conversationDetailId,
+            onReplyAccepted,
             appContext,
             onProgress,
             ...(planMode ? { planMode: true } : {}),
             ...(requestedSkillIDs?.length ? { requestedSkillIDs } : {}),
             ...(allowedAgentIDs != null ? { AllowedAgentIDs: allowedAgentIDs } : {}),
             ...(agentHistoryFrom ? { AgentHistoryFrom: agentHistoryFrom } : {}),
+            ...(replyBranchId ? { ReplyBranchID: replyBranchId } : {}),
         });
     }
     /** @deprecated Use {@link ProcessMessage}. */
-    async processMessage(conversationId, message, conversationHistory, conversationDetailId, onProgress, appContext, planMode, requestedSkillIDs, allowedAgentIDs, agentHistoryFrom) {
-        return this.ProcessMessage(conversationId, message, conversationHistory, conversationDetailId, onProgress, appContext, planMode, requestedSkillIDs, allowedAgentIDs, agentHistoryFrom);
+    async processMessage(conversationId, message, conversationHistory, onReplyAccepted, onProgress, appContext, planMode, requestedSkillIDs, allowedAgentIDs, agentHistoryFrom, replyBranchId) {
+        return this.ProcessMessage(conversationId, message, conversationHistory, onReplyAccepted, onProgress, appContext, planMode, requestedSkillIDs, allowedAgentIDs, agentHistoryFrom, replyBranchId);
     }
     /**
      * Configuration preset an agent was pinned to by a previous `@mention` in this conversation.
@@ -232,7 +240,7 @@ export class ConversationAgentService {
         for (const row of result.Results || []) {
             const configurationId = this.readAgentConfigFromMention(row.Message, agentId);
             if (configurationId) {
-                console.log(`\u{1F3AF} Found configuration preset from @mention: ${configurationId}`);
+                LogStatusEx({ message: `\u{1F3AF} Found configuration preset from @mention: ${configurationId}`, verboseOnly: true });
                 return configurationId;
             }
         }
@@ -243,7 +251,7 @@ export class ConversationAgentService {
         if (!message) {
             return null;
         }
-        const parsed = this.mentionParser.parseMentions(message, AIEngineBase.Instance.Agents, []);
+        const parsed = this.mentionParser.parseMentions(message, AIEngineBase.Instance.ReadableAgents, []);
         const mention = parsed.agentMention;
         return mention?.id === agentId && mention.configurationId ? mention.configurationId : null;
     }
@@ -280,15 +288,20 @@ export class ConversationAgentService {
      *
      * Stays on the Angular shim because it directly uses AgentClientService.
      * Could move to the runtime in a follow-up if needed.
+     *
+     * @param onReplyAccepted Called with the reply row the server creates for the run (only the server
+     *   writes agent replies), before any progress: key the run's task and completion by its ID.
      */
-    async InvokeSubAgent(agentName, conversationId, message, conversationHistory, reasoning, conversationDetailId, payload, onProgress, sourceArtifactId, sourceArtifactVersionId, agentConfigurationPresetId, appContext, planMode, requestedSkillIDs, 
+    async InvokeSubAgent(agentName, conversationId, message, conversationHistory, reasoning, onReplyAccepted, payload, onProgress, sourceArtifactId, sourceArtifactVersionId, agentConfigurationPresetId, appContext, planMode, requestedSkillIDs, 
     /** The first moment of the conversation the run may read. Null or omitted reads all of it. */
-    agentHistoryFrom) {
+    agentHistoryFrom, 
+    /** Where the reply sits in the conversation. Omitted, it answers `message` directly. */
+    threading) {
         try {
             // Ensure AIEngineBase is configured
             await AIEngineBase.Instance.Config(false);
             // Find the agent by name
-            const agent = AIEngineBase.Instance.Agents.find(a => a.Name === agentName);
+            const agent = AIEngineBase.Instance.ReadableAgents.find(a => a.Name === agentName);
             if (!agent || !agent.ID) {
                 const errorMsg = `Sub-agent "${agentName}" not found`;
                 console.warn(`${errorMsg}`);
@@ -298,7 +311,11 @@ export class ConversationAgentService {
             if (requestedSkillIDs?.length) {
                 this.warnOnUnacceptedSkills(agent, requestedSkillIDs);
             }
-            console.log(`Invoking sub-agent: ${agentName}`, { reasoning, hasPayload: !!payload, hasConfigPreset: !!agentConfigurationPresetId });
+            LogStatusEx({
+                message: `Invoking sub-agent: ${agentName}`,
+                verboseOnly: true,
+                additionalArgs: [{ reasoning, hasPayload: !!payload, hasConfigPreset: !!agentConfigurationPresetId }]
+            });
             // Map AIAgentConfiguration preset ID to actual AIConfiguration ID
             let aiConfigurationId = undefined;
             if (agentConfigurationPresetId) {
@@ -306,14 +323,18 @@ export class ConversationAgentService {
                 const preset = presets.find(p => UUIDsEqual(p.ID, agentConfigurationPresetId) || UUIDsEqual(p.AIConfigurationID, agentConfigurationPresetId));
                 if (preset) {
                     aiConfigurationId = preset.AIConfigurationID || undefined;
-                    console.log(`Mapped agent configuration preset "${preset.Name}" to AIConfigurationID: ${aiConfigurationId || 'default'}`);
+                    LogStatusEx({ message: `Mapped agent configuration preset "${preset.Name}" to AIConfigurationID: ${aiConfigurationId || 'default'}`, verboseOnly: true });
                 }
                 else {
                     console.warn(`Agent configuration preset ${agentConfigurationPresetId} not found for agent ${agent.ID}`);
                 }
             }
             const agentParams = {
-                ConversationDetailId: conversationDetailId,
+                UserMessageId: message.ID,
+                OnAccepted: onReplyAccepted,
+                ...(threading?.ReplyParentId ? { ReplyParentId: threading.ReplyParentId } : {}),
+                ...(threading?.AnnouncedByAgentId ? { AnnouncedByAgentId: threading.AnnouncedByAgentId } : {}),
+                ...(threading?.ReplyBranchId ? { ReplyBranchId: threading.ReplyBranchId } : {}),
                 AgentId: agent.ID,
                 MaxHistoryMessages: 20,
                 Data: {
@@ -358,8 +379,8 @@ export class ConversationAgentService {
         }
     }
     /** @deprecated Use {@link InvokeSubAgent}. */
-    async invokeSubAgent(agentName, conversationId, message, conversationHistory, reasoning, conversationDetailId, payload, onProgress, sourceArtifactId, sourceArtifactVersionId, agentConfigurationPresetId, appContext, planMode, requestedSkillIDs, agentHistoryFrom) {
-        return this.InvokeSubAgent(agentName, conversationId, message, conversationHistory, reasoning, conversationDetailId, payload, onProgress, sourceArtifactId, sourceArtifactVersionId, agentConfigurationPresetId, appContext, planMode, requestedSkillIDs, agentHistoryFrom);
+    async invokeSubAgent(agentName, conversationId, message, conversationHistory, reasoning, onReplyAccepted, payload, onProgress, sourceArtifactId, sourceArtifactVersionId, agentConfigurationPresetId, appContext, planMode, requestedSkillIDs, agentHistoryFrom, threading) {
+        return this.InvokeSubAgent(agentName, conversationId, message, conversationHistory, reasoning, onReplyAccepted, payload, onProgress, sourceArtifactId, sourceArtifactVersionId, agentConfigurationPresetId, appContext, planMode, requestedSkillIDs, agentHistoryFrom, threading);
     }
     /**
      * Check if user's latest message should continue with the previous agent or route through Sage.
@@ -383,7 +404,7 @@ export class ConversationAgentService {
                 console.warn('⚠️ Check Sage Intent prompt not found, defaulting to UNSURE');
                 return { decision: 'UNSURE', reasoning: 'Check Sage Intent prompt not found' };
             }
-            const agent = AIEngineBase.Instance.Agents.find(a => UUIDsEqual(a.ID, agentId));
+            const agent = AIEngineBase.Instance.ReadableAgents.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' };
@@ -419,10 +440,14 @@ export class ConversationAgentService {
 ${compactHistory}${artifactContext}
 
 **Latest User Message**: "${latestMessage}"`;
-            console.log('🔍 Checking agent continuity intent...', {
-                agentName: agent.Name,
-                messagePreview: latestMessage.substring(0, 50),
-                artifactCount: agentArtifacts.length
+            LogStatusEx({
+                message: '🔍 Checking agent continuity intent...',
+                verboseOnly: true,
+                additionalArgs: [{
+                        agentName: agent.Name,
+                        messagePreview: latestMessage.substring(0, 50),
+                        artifactCount: agentArtifacts.length
+                    }]
             });
             const result = await this._aiClient.RunAIPrompt({
                 promptId: prompt.ID,
@@ -439,10 +464,14 @@ ${compactHistory}${artifactContext}
                     const decision = parsed.continuesWith.toUpperCase();
                     const reasoning = parsed.reasoning || 'No reasoning provided';
                     const targetArtifactVersionId = parsed.targetArtifactVersionId || undefined;
-                    console.log(`✅ Intent check result: ${decision}`, {
-                        reasoning,
-                        targetArtifactVersionId,
-                        latency: result.executionTimeMs || 'unknown'
+                    LogStatusEx({
+                        message: `✅ Intent check result: ${decision}`,
+                        verboseOnly: true,
+                        additionalArgs: [{
+                                reasoning,
+                                targetArtifactVersionId,
+                                latency: result.executionTimeMs || 'unknown'
+                            }]
                     });
                     if (decision === 'YES' || decision === 'NO' || decision === 'UNSURE') {
                         return {
@@ -510,21 +539,21 @@ ${compactHistory}${artifactContext}
      * plausible, and wrong: the same failure class as {@link FindLatestAgentOutputVersion},
      * closed the same way.
      *
-     * Two reads, not the four the old shape would have needed — see
+     * Three reads: the agent's replies, their Output versions, and the artifacts' names. See
      * {@link AgentArtifactSummary} for why dropping `runId` removes the join back to agent runs.
      *
      * @param historyFrom The chat's history floor, when set (see {@link FindAgentArtifacts}).
      * @param branchId The branch whose path to read; null or omitted reads the trunk.
      */
     async findAllAgentArtifacts(conversationId, agentId, historyFrom, branchId) {
-        const pathFilter = await this.branchPathFilter(conversationId, branchId);
-        if (pathFilter == null) {
+        const versionFilter = await this.agentOutputVersionFilter(conversationId, agentId, historyFrom, branchId);
+        if (!versionFilter) {
             return []; // the classifier degrades to no artifact context
         }
         const rv = RunView.FromMetadataProvider(this.Provider);
         const versionResult = await rv.RunView({
             EntityName: 'MJ: Artifact Versions',
-            ExtraFilter: this.agentOutputVersionFilter(pathFilter, agentId, historyFrom),
+            ExtraFilter: versionFilter,
             OrderBy: '__mj_CreatedAt DESC',
             MaxRows: MAX_AGENT_ARTIFACT_VERSIONS,
             Fields: ['ID', 'ArtifactID', 'VersionNumber', 'Name'],
@@ -566,7 +595,7 @@ ${compactHistory}${artifactContext}
      * again" exchanges where payload continuity matters most. A null payload is a LEGAL agent
      * input, so the failure is silent: the agent regenerates from scratch instead of modifying.
      *
-     * One round trip. The subquery walks details -> Output junctions, and versions carry
+     * Two reads: the agent's replies, then their newest Output version. Versions carry
      * `__mj_CreatedAt`, so "newest" is expressible without joining back for `Sequence`.
      *
      * @param historyFrom The chat's history floor. When set, only artifacts on replies written at
@@ -576,35 +605,60 @@ ${compactHistory}${artifactContext}
      *   another branch is never the latest here; null or omitted reads the trunk.
      */
     async FindLatestAgentOutputVersion(conversationId, agentId, historyFrom, branchId) {
-        const pathFilter = await this.branchPathFilter(conversationId, branchId);
-        if (pathFilter == null) {
+        const versionFilter = await this.agentOutputVersionFilter(conversationId, agentId, historyFrom, branchId);
+        return versionFilter ? this.runPayloadSourceQuery(versionFilter, '__mj_CreatedAt DESC') : null;
+    }
+    /**
+     * `ArtifactVersion.ID IN (...)` for every OUTPUT artifact an agent produced on one
+     * conversation path, in messages no rerun replaced, or null when the agent has no such reply
+     * there. Shared by {@link FindLatestAgentOutputVersion} and {@link findAllAgentArtifacts} so
+     * the two can never disagree about what "this agent's artifacts" means.
+     *
+     * The replies are read with their own RunView ({@link agentReplyIds}), so the row-level
+     * security on conversation messages applies. A subquery over their view would skip it, and the
+     * server refuses one for a user whose read of messages is row-filtered.
+     */
+    async agentOutputVersionFilter(conversationId, agentId, historyFrom, branchId) {
+        const replyIds = await this.agentReplyIds(conversationId, agentId, historyFrom, branchId);
+        if (replyIds.length === 0) {
             return null;
         }
-        return this.runPayloadSourceQuery(this.agentOutputVersionFilter(pathFilter, agentId, historyFrom), '__mj_CreatedAt DESC');
+        const inReplies = replyIds.map(id => `'${EscapeSQLString(id)}'`).join(',');
+        return `ID IN (
+        SELECT ArtifactVersionID FROM [__mj].[vwConversationDetailArtifacts]
+        WHERE Direction='Output' AND ConversationDetailID IN (${inReplies})
+      )`;
     }
     /**
-     * `ArtifactVersion.ID IN (...)` for every OUTPUT artifact an agent produced on one
-     * conversation path, in messages no rerun replaced. Shared by {@link FindLatestAgentOutputVersion} and
-     * {@link findAllAgentArtifacts} so the two can never disagree about what "this agent's
-     * artifacts" means.
+     * IDs of the agent's replies on one conversation path, in messages no rerun replaced, written
+     * at or after the history floor when one is set. Empty when the path cannot be built
+     * ({@link branchPathFilter}) or the read fails.
      *
      * Filters on the DETAIL's `Status <> 'Error'` rather than the agent run's
      * `Status = 'Completed'` (which is what the array scan this replaced used). Doing it on the
      * run would mean joining back to `MJ: AI Agent Runs` purely to restate a condition the
      * detail already carries.
-     *
-     * @param pathFilter The conversation-and-branch predicate from {@link branchPathFilter}.
      */
-    agentOutputVersionFilter(pathFilter, agentId, historyFrom) {
+    async agentReplyIds(conversationId, agentId, historyFrom, branchId) {
+        const pathFilter = await this.branchPathFilter(conversationId, branchId);
+        if (pathFilter == null) {
+            return [];
+        }
         const floor = historyFrom ? ` AND ${ConversationEngine.HistoryFromFilter(historyFrom)}` : '';
-        return `ID IN (
-        SELECT ArtifactVersionID FROM [__mj].[vwConversationDetailArtifacts]
-        WHERE Direction='Output' AND ConversationDetailID IN (
-          SELECT ID FROM [__mj].[vwConversationDetails]
-          WHERE ${ConversationEngine.LiveRowsFilter(pathFilter)} AND AgentID='${agentId}'
-            AND Role='AI' AND Status <> 'Error'${floor}
-        )
-      )`;
+        const rv = RunView.FromMetadataProvider(this.Provider);
+        const result = await rv.RunView({
+            EntityName: 'MJ: Conversation Details',
+            ExtraFilter: `${ConversationEngine.LiveRowsFilter(pathFilter)} AND AgentID='${EscapeSQLString(agentId)}'` +
+                ` AND Role='AI' AND Status <> 'Error'${floor}`,
+            Fields: ['ID'],
+            ResultType: 'simple',
+            IgnoreMaxRows: true
+        }, this.Provider.CurrentUser ?? undefined);
+        if (!result.Success) {
+            console.error('Failed to load agent replies:', result.ErrorMessage);
+            return [];
+        }
+        return (result.Results || []).map(reply => reply.ID);
     }
     /**
      * The SQL predicate for one branch's path in a conversation, from