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

package/src/__tests__/ResolverBase.includeBinaryFields.test.ts

@@ -158,7 +158,7 @@ describe('IncludeBinaryFields forwarding — batch resolver path', () => {
     it('RunViewsGeneric → RunViewsGenericInternal forwards the per-view flag to provider.RunViews', async () => {
         const { provider, runViewsCalls } = recordingProvider();
         const inputs = [
-            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', IncludeBinaryFields: true },
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', IncludeBinaryFields: true, AlternateBaseView: 'Active Vectors' },
             { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '' },
         ] as (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[];
 
@@ -167,7 +167,29 @@ describe('IncludeBinaryFields forwarding — batch resolver path', () => {
         expect(runViewsCalls).toHaveLength(1);
         expect(runViewsCalls[0]).toHaveLength(2);
         expect(runViewsCalls[0][0].IncludeBinaryFields).toBe(true);
+        expect(runViewsCalls[0][0].AlternateBaseView).toBe('Active Vectors');
         expect(runViewsCalls[0][1].IncludeBinaryFields).toBeUndefined();
+        expect(runViewsCalls[0][1].AlternateBaseView).toBeUndefined();
+    });
+
+    it('RunDynamicViewGeneric, RunViewByNameGeneric, and RunViewByIDGeneric forward AlternateBaseView to provider.RunView', async () => {
+        const { provider, runViewCalls } = recordingProvider();
+        const probe = new Probe();
+
+        await probe.RunDynamicViewGeneric(
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', AlternateBaseView: 'Active Vectors' } as RunDynamicViewInput,
+            provider, fakePayload(), undefined as never,
+        );
+        await probe.RunViewByNameGeneric(
+            { ViewName: 'Saved View', ExtraFilter: '', OrderBy: '', AlternateBaseView: '' } as RunViewByNameInput,
+            provider, fakePayload(), undefined as never,
+        );
+        await probe.RunViewByIDGeneric(
+            { ViewID: 'view-1', ExtraFilter: '', OrderBy: '', AlternateBaseView: 'Draft Vectors' } as RunViewByIDInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(runViewCalls.map(c => c.AlternateBaseView)).toEqual(['Active Vectors', '', 'Draft Vectors']);
     });
 });
 

package/src/__tests__/ResolverBase.publishStatusUpdate.test.ts

@@ -0,0 +1,68 @@
+// ResolverBase transitively pulls in type-graphql decorators, which need the
+// Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+import { describe, it, expect, vi } from 'vitest';
+import type { PubSubEngine } from 'type-graphql';
+import { UserInfo } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { PUSH_STATUS_UPDATES_TOPIC, StatusUpdateOwnerID } from '../generic/PushStatusResolver.js';
+import type { UserPayload } from '../types.js';
+
+/**
+ * `ResolverBase.PublishStatusUpdate` stamps the owner the caller's socket is authenticated as. For a widget guest
+ * whose run is elevated to the system user, that is the guest's owner key: a push stamped with the elevated user's ID
+ * never passes the subscription filter on the guest's socket.
+ */
+
+const ANONYMOUS_USER_ID = 'AAAAAAAA-0000-4000-8000-0000000000A0';
+const SYSTEM_USER_ID = 'BBBBBBBB-0000-4000-8000-0000000000B0';
+
+/** Reaches the protected publish wrapper. */
+class Probe extends ResolverBase {
+    public Publish(pubSub: PubSubEngine, userPayload: UserPayload): void {
+        this.PublishStatusUpdate(pubSub, 'session-1', 'progress', userPayload);
+    }
+}
+
+function elevatedGuestPayload(): UserPayload {
+    const guest = new UserInfo(null, { ID: ANONYMOUS_USER_ID, Email: 'anonymous@magic-link.local' });
+    guest.IsMagicLinkAnonymous = true;
+    guest.AnonymousVisitorID = 'sid-guest-1';
+    return {
+        sessionId: 'session-1',
+        email: 'system@example.com',
+        userRecord: new UserInfo(null, { ID: SYSTEM_USER_ID, Email: 'system@example.com' }),
+        ElevatedFrom: guest,
+    };
+}
+
+describe('ResolverBase.PublishStatusUpdate — the owner it stamps', () => {
+    it("stamps an elevated widget guest's own owner key, not the system user it was elevated to", () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const pubSub: PubSubEngine = { publish, subscribe: vi.fn(), unsubscribe: vi.fn(), asyncIterator: vi.fn() };
+        const userPayload = elevatedGuestPayload();
+
+        new Probe().Publish(pubSub, userPayload);
+
+        expect(publish).toHaveBeenCalledOnce();
+        expect(publish.mock.calls[0][0]).toBe(PUSH_STATUS_UPDATES_TOPIC);
+        const payload = publish.mock.calls[0][1] as { sessionId: string; ownerUserId: string; message: string };
+        expect(payload).toMatchObject({ sessionId: 'session-1', message: 'progress' });
+        expect(payload.ownerUserId).toBe(StatusUpdateOwnerID(userPayload));
+        expect(payload.ownerUserId).toBe(`${ANONYMOUS_USER_ID.toLowerCase()}|sid-guest-1`);
+    });
+
+    it('stamps a signed-in user with their user ID', () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const pubSub: PubSubEngine = { publish, subscribe: vi.fn(), unsubscribe: vi.fn(), asyncIterator: vi.fn() };
+        const userPayload: UserPayload = {
+            sessionId: 'session-1',
+            email: 'user@example.com',
+            userRecord: new UserInfo(null, { ID: 'CCCCCCCC-0000-4000-8000-0000000000C0', Email: 'user@example.com' }),
+        };
+
+        new Probe().Publish(pubSub, userPayload);
+
+        expect((publish.mock.calls[0][1] as { ownerUserId: string }).ownerUserId).toBe('CCCCCCCC-0000-4000-8000-0000000000C0');
+    });
+});

package/src/__tests__/ResolverBase.userViewCacheAndDedup.test.ts

@@ -0,0 +1,130 @@
+import 'reflect-metadata';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { UserViewEngine } from '@memberjunction/core-entities';
+import type { MJUserViewEntityExtended } from '@memberjunction/core-entities';
+import { RunView } from '@memberjunction/core';
+import type { IMetadataProvider, IRunViewProvider, RunViewParams, UserInfo } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { RunViewResolver, RunViewByNameInput, RunViewByIDInput } from '../generic/RunViewResolver.js';
+
+class UserViewProbe extends ResolverBase {
+    public async TestRunViewByID(
+        viewInput: RunViewByIDInput,
+        provider: IMetadataProvider,
+        userPayload: { userRecord: UserInfo; email: string }
+    ) {
+        return this.RunViewByIDGeneric(viewInput, provider, userPayload as never);
+    }
+
+    public async TestRunViewByName(
+        viewInput: RunViewByNameInput,
+        provider: IMetadataProvider,
+        userPayload: { userRecord: UserInfo; email: string }
+    ) {
+        return this.RunViewByNameGeneric(viewInput, provider, userPayload as never);
+    }
+}
+
+describe('ResolverBase & RunViewResolver UserViewEngine cache and ViewEntity forwarding (MJ-CORE-9)', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it('resolves MJ: User Views from UserViewEngine cache first, forwards ViewEntity into RunViewParams, and reuses _resolvedViewEntity in RunViewResolver', async () => {
+        const mockViewEntity = {
+            ID: 'view-123',
+            Name: 'Active Widgets',
+            EntityID: 'entity-widgets',
+            Entity: 'Widgets',
+            WhereClause: 'Status = 1',
+            GridState: null,
+            SortState: null,
+        } as unknown as MJUserViewEntityExtended;
+
+        vi.spyOn(UserViewEngine.Instance, 'Loaded', 'get').mockReturnValue(true);
+        const getViewByIdSpy = vi.spyOn(UserViewEngine.Instance, 'GetViewById').mockReturnValue(mockViewEntity);
+        const getViewByNameSpy = vi.spyOn(UserViewEngine.Instance, 'GetViewByName').mockReturnValue(mockViewEntity);
+
+        const capturedRunViewParams: RunViewParams[] = [];
+        const providerRunViewSpy = vi.fn().mockImplementation(async (params: RunViewParams) => {
+            capturedRunViewParams.push(params);
+            return {
+                Success: true,
+                Results: [{ ID: 'w-1', Name: 'Widget A' }],
+                RowCount: 1,
+                TotalRowCount: 1,
+                ExecutionTime: 2,
+                ErrorMessage: '',
+                UserViewRunID: '',
+            };
+        });
+        const fakeProvider = {
+            Entities: [
+                {
+                    ID: 'entity-widgets',
+                    Name: 'Widgets',
+                    PrimaryKeys: [{ Name: 'ID', CodeName: 'ID' }],
+                    Fields: [
+                        { Name: 'ID', CodeName: 'ID', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                        { Name: 'Name', CodeName: 'Name', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                    ],
+                    EncryptedFields: [],
+                },
+            ],
+            EntityByName: () => ({
+                ID: 'entity-widgets',
+                Name: 'Widgets',
+                PrimaryKeys: [{ Name: 'ID', CodeName: 'ID' }],
+                Fields: [
+                    { Name: 'ID', CodeName: 'ID', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                    { Name: 'Name', CodeName: 'Name', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                ],
+                EncryptedFields: [],
+            }),
+            EntityByID: () => ({
+                ID: 'entity-widgets',
+                Name: 'Widgets',
+                PrimaryKeys: [{ Name: 'ID', CodeName: 'ID' }],
+                Fields: [
+                    { Name: 'ID', CodeName: 'ID', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                    { Name: 'Name', CodeName: 'Name', AllowInView: true, DefaultInView: true, IsBinaryFieldType: false },
+                ],
+                EncryptedFields: [],
+            }),
+            RunView: providerRunViewSpy,
+        } as unknown as IMetadataProvider & IRunViewProvider;
+
+        const userPayload = {
+            email: 'tester@example.com',
+            userRecord: { ID: 'u-1', Email: 'tester@example.com' } as unknown as UserInfo,
+        };
+
+        const resolver = new RunViewResolver();
+        const findBySpy = vi.spyOn(
+            resolver as unknown as { findBy: (...args: unknown[]) => Promise<unknown> },
+            'findBy'
+        );
+
+        const byIdResult = await resolver.RunViewByID(
+            { ViewID: 'view-123' } as RunViewByIDInput,
+            { providers: [{ provider: fakeProvider, type: 'Read-Only' }], userPayload } as never
+        );
+
+        expect(getViewByIdSpy).toHaveBeenCalledWith('view-123');
+        expect(findBySpy).not.toHaveBeenCalled();
+        expect(capturedRunViewParams).toHaveLength(1);
+        expect(capturedRunViewParams[0].ViewEntity).toBe(mockViewEntity);
+        expect(byIdResult?.Results).toHaveLength(1);
+
+        const byNameResult = await resolver.RunViewByName(
+            { ViewName: 'Active Widgets' } as RunViewByNameInput,
+            { providers: [{ provider: fakeProvider, type: 'Read-Only' }], userPayload } as never
+        );
+
+        expect(getViewByNameSpy).toHaveBeenCalledWith('Active Widgets');
+        expect(findBySpy).not.toHaveBeenCalled();
+        expect(capturedRunViewParams).toHaveLength(2);
+        expect(capturedRunViewParams[1].ViewEntity).toBe(mockViewEntity);
+        expect(byNameResult?.Results).toHaveLength(1);
+    });
+});

package/src/__tests__/RunAIAgentResolver.branch.test.ts

@@ -1,10 +1,12 @@
 /**
  * @fileoverview The conversation branch on `RunAIAgentFromConversationDetail`.
  *
- * The branch comes from the placeholder row the mutation is given, never from a request argument.
- * These tests pin that the mutation loads history along that branch's path, hands the branch to the
- * agent run on both the synchronous and fire-and-forget paths, and reads the trunk when the row has
- * no branch; and that `executeAIAgent` puts the branch on the run's params only when there is one.
+ * The branch defaults to the person's message the mutation is given, or — when `replyBranchId` is supplied
+ * (such as Regenerate forking from an earlier message) — is validated to be a branch of the conversation
+ * whose path holds the person's message. These tests pin that the mutation loads history along that branch's
+ * path, creates the reply on that branch, hands the branch to the agent run on both the synchronous and
+ * fire-and-forget paths, and reads the trunk when the message has no branch; and that `executeAIAgent` puts
+ * the branch on the run's params only when there is one.
  */
 import 'reflect-metadata'; // must precede any type-graphql decorator evaluation
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
@@ -26,6 +28,7 @@ vi.mock('type-graphql', () => {
 
 const hoisted = vi.hoisted(() => ({
     runAgentInConversation: vi.fn(),
+    createAgentReplyDetail: vi.fn(),
 }));
 
 vi.mock('@memberjunction/ai-agents', () => ({
@@ -33,6 +36,9 @@ vi.mock('@memberjunction/ai-agents', () => ({
         RunAgentInConversation(...args: unknown[]) {
             return hoisted.runAgentInConversation(...args);
         }
+        CreateAgentReplyDetail(...args: unknown[]) {
+            return hoisted.createAgentReplyDetail(...args);
+        }
     },
     ArtifactToolManager: class {},
 }));
@@ -70,11 +76,12 @@ function makeResolver(): { resolver: RunAIAgentResolver; seams: ResolverSeams }
     return { resolver, seams };
 }
 
-function makeContext(branchId: string | null): AppContext {
+function makeContext(branchId: string | null, sequence = 3): AppContext {
     const provider = {
         GetEntityObject: vi.fn().mockResolvedValue({
             ConversationID: 'conv-1',
             BranchID: branchId,
+            Sequence: sequence,
             Load: vi.fn().mockResolvedValue(true),
         }),
     };
@@ -87,11 +94,18 @@ function makeContext(branchId: string | null): AppContext {
 
 const pubSub = { publish: vi.fn() } as unknown as PubSubEngine;
 
-async function runMutation(resolver: RunAIAgentResolver, branchId: string | null, fireAndForget?: boolean) {
+async function runMutation(
+    resolver: RunAIAgentResolver,
+    branchId: string | null,
+    fireAndForget?: boolean,
+    replyBranchId?: string,
+    sequence = 3
+) {
     return resolver.RunAIAgentFromConversationDetail(
-        'detail-1', 'agent-1', makeContext(branchId), 'session-1', pubSub,
+        'detail-1', 'agent-1', makeContext(branchId, sequence), 'session-1', pubSub,
         undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined,
-        undefined, undefined, fireAndForget, undefined, undefined, undefined
+        undefined, undefined, fireAndForget, undefined, undefined, undefined,
+        undefined, undefined, replyBranchId
     );
 }
 
@@ -108,23 +122,64 @@ describe('RunAIAgentFromConversationDetail — branch', () => {
         seams.loadConversationHistoryWithAttachments = vi.fn().mockResolvedValue([]);
         seams.executeAIAgent = vi.fn().mockResolvedValue({ success: true, result: '{}' });
         seams.executeAgentInBackground = vi.fn();
+        hoisted.createAgentReplyDetail.mockReset().mockResolvedValue({ ID: 'reply-1', __mj_CreatedAt: new Date() });
     });
 
-    it('loads history on the placeholder row\'s branch and hands the branch to the run', async () => {
+    // executeAIAgent / executeAgentInBackground end with (..., branchId, replyDetail).
+    it('loads history on the message\'s branch, creates the reply there, and hands the branch to the run', async () => {
         await runMutation(resolver, 'branch-b');
         expect(seams.loadConversationHistoryWithAttachments.mock.calls[0][6]).toBe('branch-b');
-        expect(seams.executeAIAgent.mock.calls[0].at(-1)).toBe('branch-b');
+        expect(hoisted.createAgentReplyDetail).toHaveBeenCalledWith(expect.objectContaining({ branchId: 'branch-b' }));
+        expect(seams.executeAIAgent.mock.calls[0].at(-2)).toBe('branch-b');
     });
 
     it('passes the branch to the background path too', async () => {
         await runMutation(resolver, 'branch-b', true);
-        expect(seams.executeAgentInBackground.mock.calls[0].at(-1)).toBe('branch-b');
+        expect(seams.executeAgentInBackground.mock.calls[0].at(-2)).toBe('branch-b');
     });
 
-    it('reads the trunk when the placeholder has no branch (control)', async () => {
+    it('reads the trunk when the message has no branch (control)', async () => {
         await runMutation(resolver, null);
         expect(seams.loadConversationHistoryWithAttachments.mock.calls[0][6]).toBeNull();
-        expect(seams.executeAIAgent.mock.calls[0].at(-1)).toBeNull();
+        expect(hoisted.createAgentReplyDetail).toHaveBeenCalledWith(expect.objectContaining({ branchId: null }));
+        expect(seams.executeAIAgent.mock.calls[0].at(-2)).toBeNull();
+    });
+
+    it('places the reply and history on replyBranchId when a regeneration forks from a message on its ancestor path', async () => {
+        vi.spyOn(ConversationEngine, 'LoadBranchesFresh').mockResolvedValue([
+            {
+                ID: 'branch-regen',
+                ConversationID: 'conv-1',
+                ParentBranchID: null,
+                ForkFromSequence: 5,
+            } as never,
+        ]);
+
+        const result = await runMutation(resolver, null, false, 'branch-regen', 3);
+
+        expect(result.success).toBe(true);
+        expect(seams.loadConversationHistoryWithAttachments.mock.calls[0][6]).toBe('branch-regen');
+        expect(hoisted.createAgentReplyDetail).toHaveBeenCalledWith(expect.objectContaining({ branchId: 'branch-regen' }));
+        expect(seams.executeAIAgent.mock.calls[0].at(-2)).toBe('branch-regen');
+    });
+
+    it('refuses a replyBranchId whose path does not include the user message, and creates nothing', async () => {
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(ConversationEngine, 'LoadBranchesFresh').mockResolvedValue([
+            {
+                ID: 'branch-regen',
+                ConversationID: 'conv-1',
+                ParentBranchID: null,
+                ForkFromSequence: 5,
+            } as never,
+        ]);
+
+        const result = await runMutation(resolver, null, false, 'branch-regen', 8);
+
+        expect(result.success).toBe(false);
+        expect(result.errorMessage).toContain('branch-regen');
+        expect(hoisted.createAgentReplyDetail).not.toHaveBeenCalled();
+        expect(seams.executeAIAgent).not.toHaveBeenCalled();
     });
 });
 
@@ -159,6 +214,7 @@ describe('executeAIAgent — ConversationBranchID', () => {
             {}, {}, 'agent-1', userPayload, '[{"role":"user","content":"hi"}]', 'session-1', pubSub,
             undefined, undefined, undefined, undefined, undefined, undefined, 'detail-1', false, false,
             undefined, undefined, 'conv-1', undefined, undefined, undefined, undefined, undefined,
+            false, // trustReservedRunData
         ];
         await execute(...base, 'branch-b');
         await execute(...base, null);

package/src/__tests__/RunAIAgentResolver.conversationWriter.test.ts

@@ -0,0 +1,210 @@
+/**
+ * @fileoverview A widget guest's agent run executes as the system user, but the conversation belongs to the guest,
+ * and only the owner (or a grantee) may write a conversation's messages (MJConversationDetailEntityExtended, MJ#4791).
+ * So the resolver names the guest as `ConversationWriter`: AgentRunner then writes the reply as the guest and the
+ * run's own records as the system user. Before this, every reply save of a widget guest was refused and the widget
+ * never showed the agent's answer.
+ */
+import 'reflect-metadata'; // must precede any type-graphql decorator evaluation
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type { PubSubEngine } from 'type-graphql';
+
+// type-graphql's real decorators need emitDecoratorMetadata, which vitest's esbuild transform
+// does not emit; the schema is irrelevant here, so every decorator is a no-op.
+vi.mock('type-graphql', () => {
+    const decoratorFactory = (..._args: unknown[]) => (..._decorated: unknown[]) => undefined;
+    const exportNames = [
+        'Resolver', 'Query', 'Mutation', 'Subscription', 'Arg', 'Args', 'ArgsType', 'Ctx', 'Root',
+        'Info', 'Field', 'FieldResolver', 'ObjectType', 'InputType', 'InterfaceType', 'Authorized',
+        'UseMiddleware', 'Extensions', 'Directive', 'ID', 'Int', 'Float', 'GraphQLISODateTime',
+        'GraphQLTimestamp', 'registerEnumType', 'createMethodDecorator', 'createParamDecorator',
+        'buildSchema', 'buildSchemaSync', 'PubSub',
+    ];
+    return Object.fromEntries(exportNames.map((name) => [name, decoratorFactory]));
+});
+
+const hoisted = vi.hoisted(() => ({
+    runAgentInConversation: vi.fn(),
+    createAgentReplyDetail: vi.fn(),
+    resolveWidgetGuestRunContext: vi.fn(),
+    authorize: vi.fn(),
+}));
+
+// Only the key engine is stubbed: Authorize allows `agent:trusted` for the key whose hash is 'hash-trusted'.
+vi.mock('@memberjunction/api-keys', async (importOriginal) => ({
+    ...(await importOriginal<typeof import('@memberjunction/api-keys')>()),
+    GetAPIKeyEngine: () => ({ Authorize: hoisted.authorize }),
+}));
+
+vi.mock('@memberjunction/ai-agents', () => ({
+    AgentRunner: class {
+        RunAgentInConversation(...args: unknown[]) {
+            return hoisted.runAgentInConversation(...args);
+        }
+        CreateAgentReplyDetail(...args: unknown[]) {
+            return hoisted.createAgentReplyDetail(...args);
+        }
+    },
+    ArtifactToolManager: class {},
+}));
+
+// Only the widget lookup is stubbed; ElevateUserPayload is the real one, so the widget-guest test runs
+// against the elevated system-user payload the resolver really builds.
+vi.mock('../realtimeWidget/widgetGuestElevation.js', async (importOriginal) => ({
+    ...(await importOriginal<typeof import('../realtimeWidget/widgetGuestElevation.js')>()),
+    ResolveWidgetGuestRunContext: hoisted.resolveWidgetGuestRunContext,
+}));
+
+import { UserCache } from '@memberjunction/generic-database-provider';
+import type { UserInfo } from '@memberjunction/core';
+import { RunAIAgentResolver } from '../resolvers/RunAIAgentResolver.js';
+import type { AppContext, UserPayload } from '../types.js';
+
+const SCOPE_RECORD_ID = 'B1A2C3D4-0000-4000-8000-00000000A115';
+const ORDINARY = { conversationId: 'conv-1', latestMessageId: 'detail-1', invocationReason: 'user-message' };
+const CLIENT_DATA = JSON.stringify({
+    ...ORDINARY,
+    PrimaryScopeRecordID: SCOPE_RECORD_ID,
+    PrimaryScopeEntityName: 'MJ: Companies',
+    SecondaryScopes: { TeamID: 'team-other' },
+    __agentTypePromptParams: { enableTaskGraphs: true },
+});
+
+const USER = { ID: 'user-1', Email: 'browser.user@example.com' };
+const SYSTEM_USER = { ID: 'system-user', Email: 'system@example.com' };
+// A widget guest always carries its per-visitor scope id (mj_sid) as its MagicLinkScope.ResourceID, and its
+// conversation is stamped with the same value as ExternalID: that stamp is what tells one guest from another
+// under the shared Anonymous user (MJ#6032), so the fake conversation below carries it.
+const GUEST = { ID: 'guest-1', Email: 'anonymous@magic-link.local', IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-1', MagicLinkScope: { ResourceID: 'sid-1' } };
+
+type Fn = ReturnType<typeof vi.fn>;
+
+/** The private members this test reaches, through an explicit shape (no `any`). */
+interface ResolverSeams {
+    CheckAPIKeyScopeAuthorization: Fn;
+    GetUserFromPayload: Fn;
+    loadConversationHistoryWithAttachments: Fn;
+    validateAgent: Fn;
+    persistInFlightAgentFailure: Fn;
+}
+
+const pubSub = { publish: vi.fn().mockResolvedValue(undefined) } as unknown as PubSubEngine;
+
+function makeResolver(): { resolver: RunAIAgentResolver; seams: ResolverSeams } {
+    const resolver = new RunAIAgentResolver();
+    const seams = resolver as unknown as ResolverSeams;
+    seams.CheckAPIKeyScopeAuthorization = vi.fn().mockResolvedValue(undefined);
+    seams.GetUserFromPayload = vi.fn((payload: UserPayload) => payload.userRecord);
+    seams.loadConversationHistoryWithAttachments = vi.fn().mockResolvedValue([{ role: 'user', content: 'hi' }]);
+    seams.validateAgent = vi.fn().mockResolvedValue({ ID: 'agent-1', Name: 'Test Agent' });
+    seams.persistInFlightAgentFailure = vi.fn().mockResolvedValue(undefined);
+    return { resolver, seams };
+}
+
+function makeContext(userPayload: Partial<UserPayload>): AppContext {
+    const provider = {
+        GetEntityObject: vi.fn().mockResolvedValue({ ConversationID: 'conv-1', UserID: GUEST.ID, ExternalID: 'sid-1', Load: vi.fn().mockResolvedValue(true) }),
+    };
+    return {
+        userPayload: { sessionId: 'session-1', email: USER.Email, userRecord: USER, ...userPayload } as UserPayload,
+        providers: [{ type: 'Read-Write', provider }],
+        dataSource: {},
+    } as unknown as AppContext;
+}
+
+/** The params the n-th run was handed by the real executeAIAgent (what AgentRunner.RunAgentInConversation received). */
+interface HandedParams {
+    data: Record<string, unknown>;
+    TrustReservedRunData?: boolean;
+    contextUser: { ID: string };
+}
+
+/** Waits for the n-th run to start (the fire-and-forget path starts it after the resolver has returned). */
+async function handedParams(n = 0): Promise<HandedParams> {
+    await vi.waitFor(() => expect(hoisted.runAgentInConversation.mock.calls.length).toBeGreaterThan(n));
+    return hoisted.runAgentInConversation.mock.calls[n][0] as HandedParams;
+}
+
+function runAIAgent(resolver: RunAIAgentResolver, ctx: AppContext, fireAndForget?: boolean) {
+    return resolver.RunAIAgent(
+        'agent-1', ctx, '[{"role":"user","content":"hi"}]', 'session-1', pubSub, CLIENT_DATA,
+        undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+        fireAndForget
+    );
+}
+
+function runFromDetail(resolver: RunAIAgentResolver, ctx: AppContext, fireAndForget?: boolean) {
+    return resolver.RunAIAgentFromConversationDetail(
+        'detail-1', 'agent-1', ctx, 'session-1', pubSub, undefined, CLIENT_DATA,
+        undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, fireAndForget
+    );
+}
+
+beforeEach(() => {
+    hoisted.resolveWidgetGuestRunContext.mockReset().mockResolvedValue(null);
+    // Stop right after the run's params are captured — the rest of the run is out of scope.
+    hoisted.runAgentInConversation.mockReset().mockRejectedValue(new Error('stop here'));
+    hoisted.createAgentReplyDetail.mockReset().mockResolvedValue({ ID: 'reply-1', __mj_CreatedAt: new Date() });
+    hoisted.authorize.mockReset().mockImplementation(async (apiKeyHash: string, _app: string, scopePath: string) =>
+        apiKeyHash === 'hash-trusted' && scopePath === 'agent:trusted'
+            ? { Allowed: true, MatchedKeyRule: { ScopePath: scopePath }, EvaluatedRules: [] }
+            : { Allowed: false, Reason: 'No matching key scope rules', EvaluatedRules: [] });
+    vi.spyOn(UserCache.Instance, 'GetSystemUser').mockReturnValue(SYSTEM_USER as UserInfo);
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+});
+
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+
+/** The options the n-th run was handed (the second argument of AgentRunner.RunAgentInConversation). */
+async function handedOptions(n = 0): Promise<{ ConversationWriter?: { ID: string } }> {
+    await vi.waitFor(() => expect(hoisted.runAgentInConversation.mock.calls.length).toBeGreaterThan(n));
+    return hoisted.runAgentInConversation.mock.calls[n][1] as { ConversationWriter?: { ID: string } };
+}
+
+describe('RunAIAgentFromConversationDetail — who writes the conversation', () => {
+    it('runs a widget guest as the system user but writes its conversation as the guest, on both paths', async () => {
+        const { resolver } = makeResolver();
+        hoisted.resolveWidgetGuestRunContext.mockResolvedValue({ ElevatedUser: SYSTEM_USER, Widget: {}, PinnedAgentId: 'pinned-agent' });
+        const ctx = makeContext({ email: GUEST.Email, userRecord: GUEST });
+
+        await runFromDetail(resolver, ctx);
+        await runFromDetail(resolver, ctx, true);
+
+        expect((await handedParams(0)).contextUser.ID).toBe(SYSTEM_USER.ID);
+        expect((await handedOptions(0)).ConversationWriter?.ID).toBe(GUEST.ID);
+        expect((await handedParams(1)).contextUser.ID).toBe(SYSTEM_USER.ID);
+        expect((await handedOptions(1)).ConversationWriter?.ID).toBe(GUEST.ID);
+        // The server-created reply row (A19) is written as the guest too, never as the elevated system user.
+        for (const [args] of hoisted.createAgentReplyDetail.mock.calls) {
+            expect((args as { contextUser: { ID: string } }).contextUser.ID).toBe(GUEST.ID);
+        }
+        expect(hoisted.createAgentReplyDetail).toHaveBeenCalledTimes(2);
+    });
+
+    it('refuses a widget guest on another visitor\'s conversation before any row is written (MJ#6032)', async () => {
+        const { resolver } = makeResolver();
+        hoisted.resolveWidgetGuestRunContext.mockResolvedValue({ ElevatedUser: SYSTEM_USER, Widget: {}, PinnedAgentId: 'pinned-agent' });
+        // The conversation is stamped sid-1; this guest's scope is sid-2, so the shared Anonymous user must not be
+        // enough. Without the AuthorizeConversationTurn gate the run would proceed and the reply row below be created.
+        const ctx = makeContext({ email: GUEST.Email, userRecord: { ...GUEST, AnonymousVisitorID: 'sid-2', MagicLinkScope: { ResourceID: 'sid-2' } } as UserPayload['userRecord'] });
+
+        const result = await runFromDetail(resolver, ctx);
+
+        expect(result.success).toBe(false);
+        expect(result.errorMessage).toContain('Not authorized: you do not own this conversation');
+        expect(hoisted.createAgentReplyDetail).not.toHaveBeenCalled();
+        expect(hoisted.runAgentInConversation).not.toHaveBeenCalled();
+    });
+
+    it('names no separate writer for an ordinary user (it runs and writes as itself)', async () => {
+        const { resolver } = makeResolver();
+
+        await runFromDetail(resolver, makeContext({}));
+
+        expect((await handedOptions()).ConversationWriter).toBeUndefined();
+        expect((await handedParams()).contextUser.ID).toBe(USER.ID);
+    });
+});