@memberjunction/server 6.2.0-edge.4 → 6.2.0-edge.6

package/src/__tests__/SessionManager.test.ts

@@ -29,6 +29,16 @@ vi.mock('@memberjunction/ai-agents', () => ({
     },
 }));
 
+// --- Mock the recording assembly scheduler so a close's assembly request is observable (#5294) ---
+const scheduleAssemblyMock = vi.fn();
+vi.mock('../realtimeSessions/RecordingAssemblyScheduler.js', () => ({
+    RecordingAssemblyScheduler: {
+        get Instance() {
+            return { ScheduleAssembly: scheduleAssemblyMock };
+        },
+    },
+}));
+
 // --- Mock RunView.FromMetadataProvider so channel sweeps and run-id lookups are controllable,
 //     while leaving the rest of @memberjunction/core intact. RunViews runs each view through runViewMock. ---
 const runViewMock = vi.fn();
@@ -135,6 +145,7 @@ beforeEach(() => {
     hostSessionClosedMock.mockResolvedValue(undefined);
     runViewMock.mockReset();
     runViewMock.mockResolvedValue({ Success: true, Results: [] });
+    scheduleAssemblyMock.mockReset();
     getSystemUserMock.mockReset();
     getSystemUserMock.mockReturnValue(undefined);
 });
@@ -175,6 +186,64 @@ describe('SessionManager.CreateSession', () => {
         expect(result.HostInstanceID).toBeTypeOf('string');
     });
 
+    describe('anonymous ExternalID stamp: MagicLinkScope.ResourceID when the token carries one, else mj_sid', () => {
+        async function stampFor(anon: Record<string, unknown>): Promise<unknown> {
+            hasPermissionMock.mockResolvedValue(true);
+            const conversation = makeSessionEntity({ ID: 'conv-anon' });
+            const session = makeSessionEntity({ ID: 'session-anon' });
+            const { provider } = makeProvider((name) => (name === 'MJ: Conversations' ? conversation : session));
+            const anonUser = { ID: 'user-anon', Email: 'anonymous@magic-link.local', IsMagicLinkAnonymous: true, ...anon } as unknown as UserInfo;
+            await new SessionManager().CreateSession({ agentID: 'agent-1', userID: 'user-anon' }, anonUser, provider);
+            return conversation.ExternalID;
+        }
+
+        it('widget guest (ResourceID == mj_sid): stamps the sessionId', async () => {
+            expect(await stampFor({ AnonymousVisitorID: 'sid-w', MagicLinkScope: { ResourceID: 'sid-w' } })).toBe('sid-w');
+        });
+
+        it('anonymous invite WITH a ResourceID: stamps the ResourceID, so scope RLS ({{ScopeResourceID}}) still finds the row', async () => {
+            expect(await stampFor({ AnonymousVisitorID: 'visitor-sid-1', MagicLinkScope: { ResourceID: 'invite-scope-R' } })).toBe('invite-scope-R');
+        });
+
+        it('anonymous invite WITHOUT a ResourceID: stamps the per-redemption mj_sid', async () => {
+            expect(await stampFor({ AnonymousVisitorID: 'visitor-sid-2' })).toBe('visitor-sid-2');
+        });
+    });
+
+    it('stamps conversation ExternalID with MagicLinkScope.ResourceID for a non-anonymous scoped principal', async () => {
+        hasPermissionMock.mockResolvedValue(true);
+        const conversation = makeSessionEntity({ ID: 'conv-scoped' });
+        const session = makeSessionEntity({ ID: 'session-scoped' });
+        const { provider } = makeProvider((name) =>
+            name === 'MJ: Conversations' ? conversation : session,
+        );
+        const mgr = new SessionManager();
+        const scopedUser = {
+            ID: 'user-scoped',
+            Email: 'scoped@example.com',
+            IsMagicLinkAnonymous: false,
+            MagicLinkScope: { ResourceID: 'resource-scoped-1' },
+        } as unknown as UserInfo;
+
+        await mgr.CreateSession({ agentID: 'agent-1', userID: 'user-scoped' }, scopedUser, provider);
+
+        expect(conversation.ExternalID).toBe('resource-scoped-1');
+    });
+
+    it('does not set conversation ExternalID for a named principal without scope', async () => {
+        hasPermissionMock.mockResolvedValue(true);
+        const conversation = makeSessionEntity({ ID: 'conv-named' });
+        const session = makeSessionEntity({ ID: 'session-named' });
+        const { provider } = makeProvider((name) =>
+            name === 'MJ: Conversations' ? conversation : session,
+        );
+        const mgr = new SessionManager();
+
+        await mgr.CreateSession({ agentID: 'agent-1', userID: 'user-1' }, makeUser(), provider);
+
+        expect(conversation.ExternalID).toBeUndefined();
+    });
+
     it('reuses a supplied conversation without creating a new one', async () => {
         hasPermissionMock.mockResolvedValue(true);
         const session = makeSessionEntity({ ID: 'session-x' });
@@ -192,6 +261,43 @@ describe('SessionManager.CreateSession', () => {
         expect(session.ConversationID).toBe('conv-existing');
     });
 
+    describe('an anonymous caller binding a session to an existing conversation (#4931)', () => {
+        const anonUser = { ID: 'user-anon', Email: 'anonymous@magic-link.local', IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-a', MagicLinkScope: { ResourceID: 'sid-a' } } as unknown as UserInfo;
+
+        function providerWith(conversation: FakeEntity, session: FakeEntity) {
+            return makeProvider((name) => (name === 'MJ: Conversations' ? conversation : session));
+        }
+
+        it('refuses another visitor\'s conversation and writes no session row', async () => {
+            hasPermissionMock.mockResolvedValue(true);
+            const session = makeSessionEntity({ ID: 'session-x' });
+            const { provider } = providerWith(makeSessionEntity({ ID: 'conv-b', ExternalID: 'sid-b' }), session);
+            await expect(
+                new SessionManager().CreateSession({ agentID: 'agent-1', userID: 'user-anon', conversationID: 'conv-b' }, anonUser, provider),
+            ).rejects.toBeInstanceOf(SessionAuthorizationError);
+            expect(session.Save).not.toHaveBeenCalled();
+        });
+
+        it('refuses a conversation it cannot read', async () => {
+            hasPermissionMock.mockResolvedValue(true);
+            const session = makeSessionEntity({ ID: 'session-x' });
+            const { provider } = providerWith(makeSessionEntity({ ID: 'conv-hidden', Load: vi.fn(async () => false) }), session);
+            await expect(
+                new SessionManager().CreateSession({ agentID: 'agent-1', userID: 'user-anon', conversationID: 'conv-hidden' }, anonUser, provider),
+            ).rejects.toBeInstanceOf(SessionAuthorizationError);
+            expect(session.Save).not.toHaveBeenCalled();
+        });
+
+        it('binds to its own conversation (ExternalID equals its scope identity)', async () => {
+            hasPermissionMock.mockResolvedValue(true);
+            const session = makeSessionEntity({ ID: 'session-x' });
+            const { provider } = providerWith(makeSessionEntity({ ID: 'conv-a', ExternalID: 'sid-a' }), session);
+            await new SessionManager().CreateSession({ agentID: 'agent-1', userID: 'user-anon', conversationID: 'conv-a' }, anonUser, provider);
+            expect(session.ConversationID).toBe('conv-a');
+            expect(session.Save).toHaveBeenCalled();
+        });
+    });
+
     it('throws (with the entity error detail) when the Conversation save fails — no session row attempted', async () => {
         hasPermissionMock.mockResolvedValue(true);
         const conversation = makeSessionEntity({
@@ -566,6 +672,22 @@ describe('SessionManager.Heartbeat', () => {
     });
 });
 
+describe('SessionManager.CloseSession — recording assembly (#5294)', () => {
+    it('CloseSession of a recorded session asks for its assembly now (the hidden-tab deferral ends with the call)', async () => {
+        const session = makeSessionEntity({ ID: 'session-1', Status: 'Active', RecordingStartedAt: new Date(0) });
+        const { provider } = makeProvider(() => session);
+        await new SessionManager().CloseSession('session-1', makeUser(), provider);
+        expect(scheduleAssemblyMock).toHaveBeenCalledWith('session-1', 0, false);
+    });
+
+    it('CloseSession of a session that was not recorded asks for no assembly', async () => {
+        const session = makeSessionEntity({ ID: 'session-1', Status: 'Active', RecordingStartedAt: null });
+        const { provider } = makeProvider(() => session);
+        await new SessionManager().CloseSession('session-1', makeUser(), provider);
+        expect(scheduleAssemblyMock).not.toHaveBeenCalled();
+    });
+});
+
 describe('SessionManager.Heartbeat — the session\'s co-agent run stays alive', () => {
     beforeEach(() => {
         keepCoAgentRunAliveMock.mockClear();

package/src/__tests__/TaskGraphActionRunner.durablePayload.test.ts

@@ -169,4 +169,29 @@ describe('TaskGraphActionRunner: outputs must be storable', () => {
 
         expect(result).toMatchObject({ Success: true, Output: { AgentRunID: 'RUN-1' }, ActionLogID: 'LOG-2' });
     });
+
+    it('merges structured JSON Message properties into Output and aliases handle/Handle', async () => {
+        vi.mocked(ActionEngineServer.Instance.RunAction).mockResolvedValue({
+            Success: true,
+            Message: JSON.stringify({
+                message: 'Created new PDF document.',
+                handle: 'doc-handle-99',
+                documentType: 'pdf',
+                fileName: 'Sales_Demo_Report.pdf',
+            }),
+            Params: [],
+            LogEntry: { ID: 'LOG-3' },
+        } as never);
+
+        const result = await new TaskGraphActionRunner().RunActionForTask(baseRunParams({ DocumentType: 'pdf' }));
+
+        expect(result.Success).toBe(true);
+        expect(result.Output).toMatchObject({
+            handle: 'doc-handle-99',
+            Handle: 'doc-handle-99',
+            documentType: 'pdf',
+            fileName: 'Sales_Demo_Report.pdf',
+        });
+    });
 });
+

package/src/__tests__/TaskGraphAgentRunner.test.ts

@@ -0,0 +1,266 @@
+/**
+ * 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`.
+ */
+import 'reflect-metadata';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@memberjunction/core', () => ({
+    LogError: vi.fn(),
+    LogStatus: vi.fn(),
+}));
+
+vi.mock('@memberjunction/generic-database-provider', () => ({
+    UserCache: {
+        Instance: { Users: [] },
+        Users: [],
+    },
+}));
+
+vi.mock('@memberjunction/core-entities', () => ({
+    MJTaskEntity: class {},
+}));
+
+vi.mock('@memberjunction/ai-core-plus', () => ({
+    MJAIAgentEntityExtended: class {},
+    MJAIAgentRunEntityExtended: class {},
+}));
+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 {
+                Agents: mockEngineAgents,
+                CanUserRunAgent: canUserRunAgent,
+            };
+        },
+    },
+}));
+
+import { TaskGraphAgentRunner } from '../services/TaskGraphAgentRunner';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+
+describe('TaskGraphAgentRunner', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        canUserRunAgent.mockResolvedValue(true);
+        runAgent.mockResolvedValue({
+            success: true,
+            payload: { queryName: 'Top Users', sql: 'SELECT TOP 10 * FROM Users' },
+            agentRun: { ID: 'step-run-1', Message: 'Built Top Users query' },
+        });
+        processAgentArtifacts.mockResolvedValue(undefined);
+    });
+
+    it('resolves ConversationDetailID from the submitting parent run and persists specialist agent artifacts', async () => {
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'qb-agent', Name: 'Query Builder', Load: vi.fn().mockResolvedValue(true) };
+                }
+                if (entityName === 'MJ: AI Agent Runs') {
+                    return {
+                        ID: 'parent-run-1',
+                        ConversationID: 'conv-1',
+                        ConversationDetailID: 'origin-detail-1',
+                        Load: vi.fn().mockResolvedValue(true),
+                    };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-step-1',
+            AgentID: 'qb-agent',
+            SubmittingAgentRunID: 'parent-run-1',
+            InputPayload: { goal: 'Top 10 users' },
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        expect(outcome.AgentRunID).toBe('step-run-1');
+        expect(runAgent).toHaveBeenCalledTimes(1);
+        expect(runAgent.mock.calls[0][0].inputArtifacts).toEqual([]);
+        expect(processAgentArtifacts).toHaveBeenCalledTimes(1);
+        expect(processAgentArtifacts.mock.calls[0][0].artifactDirective?.behavior).toBe('create-new');
+        expect(processAgentArtifacts.mock.calls[0][1]).toBe('origin-detail-1');
+    });
+
+    it('falls back to resolving ConversationDetailID from the task hierarchy when SubmittingAgentRunID has none', async () => {
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'writer-agent', Name: 'Research Report Writer', Load: vi.fn().mockResolvedValue(true) };
+                }
+                if (entityName === 'MJ: Tasks') {
+                    return {
+                        ID: 'task-step-2',
+                        ConversationDetailID: 'task-detail-2',
+                        ParentID: 'parent-task-1',
+                        Load: vi.fn().mockResolvedValue(true),
+                    };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-step-2',
+            AgentID: 'writer-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: { topic: 'Executive summary' },
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        expect(processAgentArtifacts).toHaveBeenCalledTimes(1);
+        expect(processAgentArtifacts.mock.calls[0][0].artifactDirective?.behavior).toBe('create-new');
+        expect(processAgentArtifacts.mock.calls[0][1]).toBe('task-detail-2');
+    });
+
+    it('refuses execution when the acting user lacks run permission on the target agent', async () => {
+        canUserRunAgent.mockResolvedValue(false);
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'restricted-agent', Name: 'Restricted Agent', Load: vi.fn().mockResolvedValue(true) };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-step-restricted',
+            AgentID: 'restricted-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: {},
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-no-perm' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(false);
+        expect(outcome.ErrorMessage).toContain('User does not have permission to run agent "Restricted Agent"');
+        expect(runAgent).not.toHaveBeenCalled();
+    });
+
+    it('includes task Name and Description in prompt and preserves agentRun.Message when object payload lacks message/summary', async () => {
+        runAgent.mockResolvedValue({
+            success: true,
+            payload: {},
+            agentRun: {
+                ID: 'fb-run-1',
+                Message: 'Which entity would you like me to customize a form for?',
+                FinalStep: 'Chat',
+            },
+        });
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'qb-agent', Name: 'Form Builder', Load: vi.fn().mockResolvedValue(true) };
+                }
+                if (entityName === 'MJ: Tasks') {
+                    return {
+                        ID: 'task-fb-1',
+                        Name: 'Customize Orders Form',
+                        Description: 'Add a collapsible Customer Details section to the Orders form.',
+                        ConversationDetailID: 'detail-fb-1',
+                        ParentID: null,
+                        Load: vi.fn().mockResolvedValue(true),
+                    };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-fb-1',
+            AgentID: 'qb-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: { entityName: 'Orders' },
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        const promptSent = runAgent.mock.calls[0][0].conversationMessages[0].content as string;
+        expect(promptSent).toContain('## Task: Customize Orders Form');
+        expect(promptSent).toContain('Add a collapsible Customer Details section to the Orders form.');
+        expect(outcome.Output).toEqual({
+            message: 'Which entity would you like me to customize a form for?',
+            finalStep: 'Chat',
+        });
+    });
+
+    it('normalizes results/result, lifts nested results fields to top level, and populates succeeded on completed agent steps', async () => {
+        runAgent.mockResolvedValue({
+            success: true,
+            payload: {
+                code: 'output = { totalSales: 2703745, summary: "Sales exceeded $1M" };',
+                results: { totalSales: 2703745, summary: 'Sales exceeded $1M' },
+                iterations: 1,
+            },
+            agentRun: {
+                ID: 'cs-run-1',
+                Message: 'Calculated total sales across 19 quarters.',
+                FinalStep: 'Success',
+            },
+        });
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+                if (entityName === 'MJ: AI Agents') {
+                    return { ID: 'qb-agent', Name: 'Codesmith Agent', Load: vi.fn().mockResolvedValue(true) };
+                }
+                return { Load: vi.fn().mockResolvedValue(false) };
+            }),
+        } as unknown as IMetadataProvider;
+
+        const runner = new TaskGraphAgentRunner();
+        const outcome = await runner.RunAgentForTask({
+            TaskID: 'task-cs-1',
+            AgentID: 'qb-agent',
+            SubmittingAgentRunID: null,
+            InputPayload: {},
+            DependencyOutputs: new Map(),
+            Provider: provider,
+            ContextUser: { ID: 'user-1' } as UserInfo,
+        });
+
+        expect(outcome.Success).toBe(true);
+        expect(outcome.Output).toMatchObject({
+            totalSales: 2703745,
+            summary: 'Sales exceeded $1M',
+            results: { totalSales: 2703745, summary: 'Sales exceeded $1M' },
+            result: { totalSales: 2703745, summary: 'Sales exceeded $1M' },
+            succeeded: true,
+        });
+    });
+});
+