@memberjunction/server 6.2.0-edge.5 → 6.2.0-edge.7

package/src/__tests__/TaskGraphAgentRunner.test.ts

@@ -1,19 +1,54 @@
 /**
- * Tests for `TaskGraphAgentRunner`.
- *
- * Verifies that when a task node in a durable task graph executes a specialist agent
- * (such as Query Builder or Research Report Writer) and finishes with a payload,
- * the runner resolves the originating `ConversationDetailID` and persists artifacts
- * via `AgentRunner.ProcessAgentArtifacts`.
+ * Tests for `TaskGraphAgentRunner`:
+ * - VS-CON-7 preset resolution (`ConfigurationPresetName`)
+ * - VS-INV-2b / VS-QA-3 #9 `parentAgentHierarchy` from submitted task
+ * - Specialist agent artifact persistence (`ProcessAgentArtifacts`), `CanUserRunAgent` permission check,
+ *   task Name/Description prompt formatting, and output normalization.
  */
 import 'reflect-metadata';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { TaskAgentRunParams } from '@memberjunction/task-graph';
 
-vi.mock('@memberjunction/core', () => ({
-    LogError: vi.fn(),
-    LogStatus: vi.fn(),
+const {
+    runAgent,
+    processAgentArtifacts,
+    canUserRunAgent,
+    mockEngineAgents,
+    mockGetAgentConfigurationPresets,
+    mockEngineConfig,
+    mockRunView,
+    mockLogError,
+} = vi.hoisted(() => ({
+    runAgent: vi.fn(),
+    processAgentArtifacts: vi.fn(),
+    canUserRunAgent: vi.fn().mockResolvedValue(true),
+    mockEngineAgents: [
+        { ID: 'agent-1', Name: 'Storyboard Artist' },
+        { ID: 'qb-agent' },
+        { ID: 'writer-agent' },
+    ] as Array<{ ID: string; Name?: string }>,
+    mockGetAgentConfigurationPresets: vi.fn(),
+    mockEngineConfig: vi.fn(),
+    mockRunView: vi.fn(),
+    mockLogError: vi.fn(),
 }));
 
+const mockRunAgent = runAgent;
+
+vi.mock('@memberjunction/core', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('@memberjunction/core')>();
+    return {
+        ...actual,
+        LogError: (...args: unknown[]) => mockLogError(...args),
+        LogStatus: vi.fn(),
+        RunView: class {
+            static FromMetadataProvider = () => ({ RunView: mockRunView });
+            RunView = mockRunView;
+        },
+    };
+});
+
 vi.mock('@memberjunction/generic-database-provider', () => ({
     UserCache: {
         Instance: { Users: [] },
@@ -31,31 +66,251 @@ vi.mock('@memberjunction/ai-core-plus', () => ({
 }));
 vi.mock('@memberjunction/ai', () => ({ ChatMessageRole: { user: 'user' } }));
 
-const { runAgent, processAgentArtifacts, canUserRunAgent, mockEngineAgents } = vi.hoisted(() => ({
-    runAgent: vi.fn(),
-    processAgentArtifacts: vi.fn(),
-    canUserRunAgent: vi.fn().mockResolvedValue(true),
-    mockEngineAgents: [{ ID: 'qb-agent' }, { ID: 'writer-agent' }] as Array<{ ID: string }>,
-}));
 vi.mock('@memberjunction/ai-agents', () => ({
     AgentRunner: class {
         RunAgent = runAgent;
         ProcessAgentArtifacts = processAgentArtifacts;
     },
 }));
+
 vi.mock('@memberjunction/aiengine', () => ({
     AIEngine: {
         get Instance() {
             return {
+                Config: mockEngineConfig,
                 Agents: mockEngineAgents,
                 CanUserRunAgent: canUserRunAgent,
+                GetAgentConfigurationPresets: mockGetAgentConfigurationPresets,
+                FindActiveAgentConfigurationPreset: (agentId: string, presetName: string) => {
+                    const target = presetName.trim().toLowerCase();
+                    if (!target) return undefined;
+                    const presets = (mockGetAgentConfigurationPresets(agentId, true) ?? []) as Array<{
+                        Name?: string;
+                        DisplayName?: string;
+                    }>;
+                    return presets.find((p) => p.Name?.trim().toLowerCase() === target)
+                        ?? presets.find((p) => p.DisplayName?.trim().toLowerCase() === target);
+                },
             };
         },
     },
 }));
 
 import { TaskGraphAgentRunner } from '../services/TaskGraphAgentRunner';
-import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+
+interface SubmittingRunOverrides {
+    ID?: string;
+    ConfigurationID?: string | null;
+    Agent?: string | null;
+    AgentID?: string | null;
+    ParentRunID?: string | null;
+    LoadSuccess?: boolean;
+}
+
+function makeParams(
+    overrides: Partial<TaskAgentRunParams> = {},
+    parentConfigurationID: string | null = 'parent-cfg-1',
+    submittingRunOverrides: SubmittingRunOverrides = {},
+): TaskAgentRunParams {
+    const loadSuccess = submittingRunOverrides.LoadSuccess ?? true;
+    const provider = {
+        GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+            if (entityName === 'MJ: AI Agents') {
+                return {
+                    Load: vi.fn().mockResolvedValue(true),
+                    ID: overrides.AgentID ?? 'agent-1',
+                    Name: 'Storyboard Artist',
+                };
+            }
+            if (entityName === 'MJ: Tasks') {
+                return {
+                    Load: vi.fn().mockResolvedValue(false),
+                };
+            }
+            return {
+                Load: vi.fn().mockResolvedValue(loadSuccess),
+                ID: submittingRunOverrides.ID ?? 'submitting-run-1',
+                ConfigurationID:
+                    'ConfigurationID' in submittingRunOverrides
+                        ? submittingRunOverrides.ConfigurationID
+                        : parentConfigurationID,
+                Agent: submittingRunOverrides.Agent ?? null,
+                AgentID: submittingRunOverrides.AgentID ?? null,
+                ParentRunID: submittingRunOverrides.ParentRunID ?? null,
+            };
+        }),
+    } as unknown as IMetadataProvider;
+
+    return {
+        TaskID: 'task-1',
+        AgentID: 'agent-1',
+        InputPayload: 'Draw the opening shot',
+        DependencyOutputs: new Map(),
+        SubmittingAgentRunID: 'submitting-run-1',
+        Provider: provider,
+        ContextUser: { ID: 'user-1' } as unknown as UserInfo,
+        ...overrides,
+    };
+}
+
+describe('VS-CON-7: TaskGraphAgentRunner preset resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        canUserRunAgent.mockResolvedValue(true);
+        processAgentArtifacts.mockResolvedValue(undefined);
+        mockEngineConfig.mockResolvedValue(undefined);
+        mockRunAgent.mockResolvedValue({
+            success: true,
+            agentRun: { ID: 'child-run-1', Message: 'Done' },
+            payload: { result: 'ok' },
+        });
+    });
+
+    it('resolves ConfigurationPresetName to the matching preset AIConfigurationID', async () => {
+        mockGetAgentConfigurationPresets.mockReturnValue([
+            {
+                ID: 'preset-draft',
+                Name: 'Draft',
+                DisplayName: 'Draft Mode',
+                AIConfigurationID: 'cfg-draft-1',
+                Status: 'Active',
+            },
+            {
+                ID: 'preset-high',
+                Name: 'High',
+                DisplayName: 'High Fidelity',
+                AIConfigurationID: 'cfg-high-1',
+                Status: 'Active',
+            },
+        ]);
+
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ ConfigurationPresetName: 'high fidelity' })
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].configurationId).toBe('cfg-high-1');
+    });
+
+    it('passes configurationId: undefined when the matched preset has NULL AIConfigurationID, even if the submitting run has a ConfigurationID', async () => {
+        mockGetAgentConfigurationPresets.mockReturnValue([
+            {
+                ID: 'preset-default',
+                Name: 'SystemDefault',
+                DisplayName: 'System Default',
+                AIConfigurationID: null,
+                Status: 'Active',
+            },
+        ]);
+
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ ConfigurationPresetName: 'SystemDefault' }, 'parent-cfg-1')
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].configurationId).toBeUndefined();
+    });
+
+    it('falls back to the submitting run ConfigurationID when ConfigurationPresetName is not specified', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(makeParams({}, 'parent-cfg-99'));
+
+        expect(result.Success).toBe(true);
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].configurationId).toBe('parent-cfg-99');
+    });
+
+    it('fails the task with a clear message when ConfigurationPresetName does not match any active preset at run time', async () => {
+        mockGetAgentConfigurationPresets.mockReturnValue([
+            {
+                ID: 'preset-draft',
+                Name: 'Draft',
+                DisplayName: 'Draft Mode',
+                AIConfigurationID: 'cfg-draft-1',
+                Status: 'Active',
+            },
+        ]);
+
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ ConfigurationPresetName: 'DeletedPreset' })
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toBe(
+            "Agent 'Storyboard Artist' has no active preset 'DeletedPreset'. Available: Draft."
+        );
+        expect(mockRunAgent).not.toHaveBeenCalled();
+    });
+});
+
+describe('VS-INV-2b / VS-QA-3 #9: TaskGraphAgentRunner parentAgentHierarchy from submitted task', () => {
+    const RUN_B_ID = '22222222-2222-4222-8222-222222222222';
+    const RUN_C_ID = '33333333-3333-4333-8333-333333333333';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        canUserRunAgent.mockResolvedValue(true);
+        processAgentArtifacts.mockResolvedValue(undefined);
+        mockEngineConfig.mockResolvedValue(undefined);
+        mockRunAgent.mockResolvedValue({
+            success: true,
+            agentRun: { ID: 'child-run-1', Message: 'Done' },
+            payload: { result: 'ok' },
+        });
+    });
+
+    it('reads root-first ParentAgentHierarchy carried from the submitted task without running RunView in a loop (VS-QA-3 #9)', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const params = makeParams(
+            {
+                SubmittingAgentRunID: RUN_C_ID,
+                ParentAgentHierarchy: ['A', 'B', 'C'],
+            },
+            'parent-cfg-1',
+            { ID: RUN_C_ID, Agent: 'C', ParentRunID: RUN_B_ID },
+        );
+
+        const result = await runner.RunAgentForTask(params);
+
+        expect(result.Success).toBe(true);
+        expect(mockRunView).not.toHaveBeenCalled();
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].parentAgentHierarchy).toEqual(['A', 'B', 'C']);
+    });
+
+    it('falls back to the loaded parentRun agent name when ParentAgentHierarchy is omitted, with zero RunView calls', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const params = makeParams(
+            { SubmittingAgentRunID: RUN_C_ID },
+            'parent-cfg-1',
+            { ID: RUN_C_ID, Agent: 'C', ParentRunID: RUN_B_ID },
+        );
+
+        const result = await runner.RunAgentForTask(params);
+
+        expect(result.Success).toBe(true);
+        expect(mockRunView).not.toHaveBeenCalled();
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].parentAgentHierarchy).toEqual(['C']);
+    });
+
+    it('passes undefined parentAgentHierarchy and performs no RunView reads when there is no parentRun and no ParentAgentHierarchy', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ SubmittingAgentRunID: undefined }),
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockRunView).not.toHaveBeenCalled();
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].parentAgentHierarchy).toBeUndefined();
+    });
+});
 
 describe('TaskGraphAgentRunner', () => {
     beforeEach(() => {
@@ -264,3 +519,4 @@ describe('TaskGraphAgentRunner', () => {
     });
 });
 
+

package/src/__tests__/TaskGraphContinuationDeliverer.test.ts

@@ -26,15 +26,18 @@ vi.mock('@memberjunction/core', () => ({
     },
 }));
 
+const { OWNER, SUBMITTER } = vi.hoisted(() => ({ OWNER: { ID: 'owner-1' }, SUBMITTER: { ID: 'submitter-1' } }));
 vi.mock('@memberjunction/generic-database-provider', () => ({
     UserCache: {
-        Instance: { Users: [{ ID: 'owner-user-99', Email: 'owner@example.com' }] },
-        Users: [{ ID: 'owner-user-99', Email: 'owner@example.com' }],
+        Instance: { Users: [OWNER, SUBMITTER, { ID: 'owner-user-99', Email: 'owner@example.com' }] },
+        Users: [OWNER, SUBMITTER, { ID: 'owner-user-99', Email: 'owner@example.com' }],
     },
 }));
 
 vi.mock('@memberjunction/core-entities', () => ({
     MJConversationDetailEntity: class {},
+    MJConversationDetailEntityExtended: class {},
+    MJConversationEntity: class {},
     MJAIAgentRunEntity: class {},
 }));
 
@@ -56,15 +59,19 @@ import type { PubSubEngine } from 'type-graphql';
 /** A conversation-detail row that can be loaded (the source) and saved (the reply). */
 function detailRow(over: Partial<{ loads: boolean; saves: boolean; conversationID: string; branchID: string | null }> = {}) {
     const { loads = true, saves = true, conversationID = 'conv-1', branchID = null } = over;
+    let marked = false;
     return {
         ID: 'reply-detail-1',
         ConversationID: conversationID,
         BranchID: branchID as string | null,
+        UserID: 'owner-1',
         Role: '', Status: '', HiddenToUser: true, Message: '',
         AgentID: null as string | null,
         NewRecord: vi.fn(),
+        MarkServerAuthoredReply: vi.fn(() => { marked = true; }),
         Load: vi.fn().mockResolvedValue(loads),
-        Save: vi.fn().mockResolvedValue(saves),
+        // Like MJConversationDetailEntityExtended, refuses to save an unmarked AI reply.
+        Save: vi.fn().mockImplementation(async () => saves && marked),
         LatestResult: { CompleteMessage: 'FK violation' },
     };
 }
@@ -88,6 +95,8 @@ function harness(over: Parameters<typeof detailRow>[0] = {}) {
         { ID: 'user-1' } as UserInfo,
         pubSub,
     );
+    // Rows in order: the source detail (Load), the reply (Save). The reply starts on a 'stale' fork, so a test sees
+    // the deliverer set it.
     return { deliverer, providerFactory, provider, rows, pubSub, reply: () => rows[1] };
 }
 
@@ -96,6 +105,7 @@ const params = (over: Partial<TaskContinuationParams> = {}): TaskContinuationPar
     WorkflowName: 'Weekly digest',
     ConversationDetailID: 'detail-1',
     SubmittedByAgentRunID: 'run-1',
+    SubmittedByUserID: 'submitter-1',
     ReinvokeDepth: 0,
     Tasks: [
         { TaskID: 't1', Name: 'Gather', Status: 'Complete', Summary: '412 rows' },
@@ -132,6 +142,51 @@ describe('posting the outcome', () => {
         expect(h.pubSub.publish).toHaveBeenCalledTimes(2);
     });
 
+    it("writes it as the graph's submitter, not the conversation's owner, marked as the server's reply", async () => {
+        // TaskGraph.Submit takes any conversation detail ID. Written as the owner, the gate would pass for a
+        // conversation the submitter cannot reach; written as the submitter, the gate checks their access.
+        const h = harness();
+        await h.deliverer.PostMessage(params());
+
+        expect(h.provider.GetEntityObject.mock.calls[0]).toEqual(['MJ: Conversation Details', SUBMITTER]);
+        expect(h.provider.GetEntityObject.mock.calls[1]).toEqual(['MJ: Conversation Details', SUBMITTER]);
+        expect(h.provider.GetEntityObject.mock.calls.some((call) => call[1] === OWNER)).toBe(false);
+        expect(h.rows[0].MarkServerAuthoredReply).toHaveBeenCalledOnce();
+        expect(h.reply().MarkServerAuthoredReply).toHaveBeenCalledOnce();
+    });
+
+    it("updates the originating message in-place as the graph's submitter, marked as the server's reply, when IsLatest is true", async () => {
+        const { RunView } = await import('@memberjunction/core');
+        vi.mocked(RunView.FromMetadataProvider).mockReturnValue({
+            RunView: vi.fn().mockImplementation(async (rvParams: { EntityName: string }) => {
+                if (rvParams.EntityName === 'MJ: Conversation Details') {
+                    return { Success: true, Results: [{ ID: 'detail-1' }] };
+                }
+                return { Success: false, Results: [] };
+            }),
+        } as never);
+
+        const h = harness();
+        await h.deliverer.PostMessage(params());
+
+        expect(h.rows.length).toBe(1);
+        expect(h.provider.GetEntityObject.mock.calls[0]).toEqual(['MJ: Conversation Details', SUBMITTER]);
+        expect(h.rows[0].MarkServerAuthoredReply).toHaveBeenCalledOnce();
+        expect(h.rows[0].Save).toHaveBeenCalledOnce();
+        expect(h.rows[0].Status).toBe('Complete');
+        expect(h.rows[0].Message).toContain('Weekly digest');
+        expect(h.pubSub.publish).toHaveBeenCalledTimes(1);
+    });
+
+    it("falls back to the deliverer's own user when the graph records no submitter it knows", async () => {
+        for (const submitter of [null, 'stranger-1']) {
+            const h = harness();
+            await h.deliverer.PostMessage(params({ SubmittedByUserID: submitter }));
+            expect(h.provider.GetEntityObject.mock.calls[0]).toEqual(['MJ: Conversation Details', { ID: 'user-1' }]);
+            expect(h.provider.GetEntityObject.mock.calls[1]).toEqual(['MJ: Conversation Details', { ID: 'user-1' }]);
+        }
+    });
+
     it('names the workflow and carries the roll-up', async () => {
         const h = harness();
         await h.deliverer.PostMessage(params());
@@ -409,6 +464,8 @@ describe('Reinvoke — on the fork of the message that started the graph', () =>
         // Only the originating detail was loaded and updated in-place — no second detail row created!
         expect(createdDetails.length).toBe(1);
         expect(originDetail.NewRecord).not.toHaveBeenCalled();
+        expect(originDetail.MarkServerAuthoredReply).toHaveBeenCalledOnce();
+        expect(originDetail.Save).toHaveBeenCalledOnce();
         expect(originDetail.Message).toBe('Synthesized workflow outcome');
         expect(originDetail.Status).toBe('Complete');
         expect(runAgent.mock.calls[0][0].conversationDetailId).toBe('detail-1');
@@ -460,8 +517,11 @@ describe('Reinvoke — on the fork of the message that started the graph', () =>
         await deliverer.Reinvoke(params());
 
         expect(replyDetail.NewRecord).toHaveBeenCalledTimes(1);
+        expect(replyDetail.MarkServerAuthoredReply).toHaveBeenCalledOnce();
         expect(replyDetail.ParentID).toBe('detail-1');
         expect(replyDetail.Message).toBe('Synthesized workflow outcome');
+        expect(originDetail.MarkServerAuthoredReply).toHaveBeenCalledOnce();
+        expect(originDetail.Save).toHaveBeenCalledOnce();
         expect(originDetail.Message).toContain('*(✅ **Weekly digest** completed — synthesized results posted below.)*');
         expect(originDetail.Message).not.toContain("I'll follow up when it finishes");
         expect(pubSub.publish).toHaveBeenCalledTimes(2);
@@ -625,6 +685,57 @@ describe('Reinvoke — on the fork of the message that started the graph', () =>
         expect(sentContent).toContain('- ⏭️ **Analyze Results** — Skipped: branch condition `output.rowCount > 0` on "Run Query" evaluated to false');
         expect(sentContent).toContain('briefly explaining any conditional steps that were skipped');
     });
+
+    it('logs an error and does not publish completion when an in-place (IsLatest = true) PostMessage save fails', async () => {
+        const { LogError, RunView } = await import('@memberjunction/core');
+        vi.mocked(RunView.FromMetadataProvider).mockReturnValue({
+            RunView: vi.fn().mockResolvedValue({
+                Success: true,
+                Results: [{ ID: 'detail-1' }],
+            }),
+        } as never);
+
+        const h = harness({ saves: false });
+        await h.deliverer.PostMessage(params());
+
+        expect(h.rows[0].Save).toHaveBeenCalledOnce();
+        expect(LogError).toHaveBeenCalledWith(expect.stringContaining('Could not update in-place outcome of "Weekly digest"'));
+        expect(h.pubSub.publish).not.toHaveBeenCalled();
+    });
+
+    it('loads the originating detail as SubmittedByUserID in Reinvoke when both run UserIDs are null', async () => {
+        const runRow = {
+            ID: 'run-1',
+            AgentID: 'agent-1',
+            ParentRunID: null as string | null,
+            UserID: null as string | null,
+            Load: vi.fn().mockResolvedValue(true),
+        };
+        const agentRow = {
+            ID: 'agent-1',
+            Name: 'Sage',
+            Load: vi.fn().mockResolvedValue(true),
+        };
+        const detail = detailRow();
+        const detailUsers: Array<UserInfo | undefined> = [];
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (name: string, user?: UserInfo) => {
+                if (name === 'MJ: AI Agent Runs') return runRow;
+                if (name === 'MJ: AI Agents') return agentRow;
+                detailUsers.push(user);
+                return detail;
+            }),
+        };
+        const deliverer = new TaskGraphContinuationDeliverer(
+            { CreateProvider: vi.fn().mockResolvedValue(provider) } as never,
+            { ID: 'system-user' } as UserInfo,
+        );
+
+        await deliverer.Reinvoke(params({ SubmittedByUserID: SUBMITTER.ID }));
+
+        expect(detailUsers[0]).toBe(SUBMITTER);
+        expect(runAgent.mock.calls[0][0].contextUser).toBe(SUBMITTER);
+    });
 });