@memberjunction/server 6.2.0-edge.0 → 6.2.0-edge.2

package/src/__tests__/RemoteBrowserGoalEngine.test.ts

@@ -5,11 +5,11 @@ import { MJComputerUseEngine, MJRunComputerUseParams } from '@memberjunction/com
 import { CdpRemoteBrowserSession, type ComputerUseGoalRun } from '@memberjunction/remote-browser-cdp';
 import type { MJAIAgentRunStepEntity } from '@memberjunction/core-entities';
 import {
-  buildMJGoalParams,
+  BuildMJGoalParams,
   BindRemoteBrowserGoalEngine,
   MJProgressComputerUseEngine,
-  extractCoAgentRunID,
-  finalizeBrowserGoalStep,
+  ExtractCoAgentRunID,
+  FinalizeBrowserGoalStep,
 } from '../agentSessions/remoteBrowserGoalEngine.js';
 
 const USER = { ID: 'u-1', Email: 'amith@bluecypress.io' } as unknown as UserInfo;
@@ -21,7 +21,7 @@ function baseParams(): RunComputerUseParams {
 
 describe('buildMJGoalParams', () => {
   it('produces MJ-aware params that carry over the base goal/step/url fields', () => {
-    const mj = buildMJGoalParams(baseParams(), USER);
+    const mj = BuildMJGoalParams(baseParams(), USER);
     expect(mj).toBeInstanceOf(MJRunComputerUseParams);
     expect(mj.Goal).toBe('log in');
     expect(mj.MaxSteps).toBe(7);
@@ -29,21 +29,21 @@ describe('buildMJGoalParams', () => {
   });
 
   it('injects the acting ContextUser so MJ prompts run as that user', () => {
-    expect(buildMJGoalParams(baseParams(), USER).ContextUser).toBe(USER);
+    expect(BuildMJGoalParams(baseParams(), USER).ContextUser).toBe(USER);
   });
 
   it('leaves ContextUser undefined when none is supplied', () => {
-    expect(buildMJGoalParams(baseParams()).ContextUser).toBeUndefined();
+    expect(BuildMJGoalParams(baseParams()).ContextUser).toBeUndefined();
   });
 
   it('threads the parent run + step ids for observability nesting', () => {
-    const mj = buildMJGoalParams(baseParams(), USER, 'coagent-run-1', 'goal-step-1');
+    const mj = BuildMJGoalParams(baseParams(), USER, 'coagent-run-1', 'goal-step-1');
     expect(mj.AgentRunId).toBe('coagent-run-1');
     expect(mj.AgentRunStepID).toBe('goal-step-1');
   });
 
   it('leaves the run/step ids undefined when not supplied', () => {
-    const mj = buildMJGoalParams(baseParams(), USER);
+    const mj = BuildMJGoalParams(baseParams(), USER);
     expect(mj.AgentRunId).toBeUndefined();
     expect(mj.AgentRunStepID).toBeUndefined();
   });
@@ -51,17 +51,17 @@ describe('buildMJGoalParams', () => {
 
 describe('extractCoAgentRunID', () => {
   it('pulls coAgentRunID out of a session Config_ blob', () => {
-    expect(extractCoAgentRunID(JSON.stringify({ coAgentRunID: 'run-9', promptRunID: 'p' }))).toBe('run-9');
+    expect(ExtractCoAgentRunID(JSON.stringify({ coAgentRunID: 'run-9', promptRunID: 'p' }))).toBe('run-9');
   });
   it('returns undefined for a missing key, null/empty config, or non-string value', () => {
-    expect(extractCoAgentRunID(JSON.stringify({ promptRunID: 'p' }))).toBeUndefined();
-    expect(extractCoAgentRunID(null)).toBeUndefined();
-    expect(extractCoAgentRunID(undefined)).toBeUndefined();
-    expect(extractCoAgentRunID('')).toBeUndefined();
-    expect(extractCoAgentRunID(JSON.stringify({ coAgentRunID: 123 }))).toBeUndefined();
+    expect(ExtractCoAgentRunID(JSON.stringify({ promptRunID: 'p' }))).toBeUndefined();
+    expect(ExtractCoAgentRunID(null)).toBeUndefined();
+    expect(ExtractCoAgentRunID(undefined)).toBeUndefined();
+    expect(ExtractCoAgentRunID('')).toBeUndefined();
+    expect(ExtractCoAgentRunID(JSON.stringify({ coAgentRunID: 123 }))).toBeUndefined();
   });
   it('returns undefined for malformed JSON (best-effort)', () => {
-    expect(extractCoAgentRunID('{not json')).toBeUndefined();
+    expect(ExtractCoAgentRunID('{not json')).toBeUndefined();
   });
 });
 
@@ -76,7 +76,7 @@ describe('finalizeBrowserGoalStep', () => {
 
   it('finalizes the parent step Completed from a successful goal result + saves', async () => {
     const step = fakeStep();
-    await finalizeBrowserGoalStep(step, { Success: true, Strategy: 'ComputerUse', Status: 'Completed', StepCount: 4, CurrentUrl: 'https://done/' });
+    await FinalizeBrowserGoalStep(step, { Success: true, Strategy: 'ComputerUse', Status: 'Completed', StepCount: 4, CurrentUrl: 'https://done/' });
     expect(step.Status).toBe('Completed');
     expect(step.Success).toBe(true);
     expect((step as unknown as { Save: ReturnType<typeof vi.fn> }).Save).toHaveBeenCalledOnce();
@@ -87,13 +87,13 @@ describe('finalizeBrowserGoalStep', () => {
 
   it('finalizes Failed and carries the detail as the error message', async () => {
     const step = fakeStep();
-    await finalizeBrowserGoalStep(step, { Success: false, Status: 'Error', Detail: 'login blocked' });
+    await FinalizeBrowserGoalStep(step, { Success: false, Status: 'Error', Detail: 'login blocked' });
     expect(step.Status).toBe('Failed');
     expect(step.ErrorMessage).toBe('login blocked');
   });
 
   it('is a no-op when the step is null (no co-agent run to nest under)', async () => {
-    await expect(finalizeBrowserGoalStep(null, { Success: true })).resolves.toBeUndefined();
+    await expect(FinalizeBrowserGoalStep(null, { Success: true })).resolves.toBeUndefined();
   });
 });
 

package/src/__tests__/RemoteBrowserSnapshot.test.ts

@@ -62,7 +62,13 @@ vi.mock('@memberjunction/remote-browser-server', () => ({
 
 // Keep the AI imports (visual interpreter) inert — they aren't exercised by the snapshot path.
 vi.mock('@memberjunction/aiengine', () => ({ AIEngine: { Instance: { Config: vi.fn(), Prompts: [] } } }));
-vi.mock('@memberjunction/ai-prompts', () => ({ AIPromptRunner: class {} }));
+// Spread the real module, as for ai-core-plus below, so transitively-loaded modules resolve: runners such as
+// AIRerankerRunner (which extends BaseModelRunner), and RunDecisionResolver's AIDecisionRunner. Only
+// AIPromptRunner is overridden for the test.
+vi.mock('@memberjunction/ai-prompts', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@memberjunction/ai-prompts')>()),
+  AIPromptRunner: class {},
+}));
 // Spread the real module so transitively-loaded code still resolves with its REAL base classes; only
 // AIPromptParams is overridden for the test.
 vi.mock('@memberjunction/ai-core-plus', async (importOriginal) => ({

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

@@ -0,0 +1,52 @@
+// Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+import { describe, it, expect } from 'vitest';
+import { EntityFieldTSType, type EntityFieldInfo, type EntityInfo } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+
+/**
+ * Client old values arrive as strings, with dates as epoch milliseconds (the GraphQL Timestamp form).
+ * Loading them as-is made an unchanged date field an Invalid Date, so it read as edited: a
+ * Comments-only update to an MJ: Record Changes row was refused for "changing" ChangedAt.
+ */
+class Probe extends ResolverBase {
+    public Convert(field: Partial<EntityFieldInfo>, raw: unknown) {
+        return this.ClientOldValueToFieldValue(field as EntityFieldInfo, raw);
+    }
+    public MustLoad(entity: Partial<EntityInfo>, oldValues: boolean) {
+        return this.MustLoadTruthFromDatabase(entity as EntityInfo, { OldValues___: oldValues ? [{ Key: 'Comments', Value: null }] : undefined }, false, false);
+    }
+}
+const probe = new Probe();
+const dateField = { Name: 'ChangedAt', TSType: EntityFieldTSType.Date, Type: 'datetimeoffset', AllowsNull: false, DefaultValue: 'getutcdate()' };
+
+describe('ResolverBase.ClientOldValueToFieldValue', () => {
+    it('reads an epoch-milliseconds string as the same instant', () => {
+        const value = probe.Convert(dateField, '1790365634563') as Date;
+        expect(value).toBeInstanceOf(Date);
+        expect(value.getTime()).toBe(1790365634563);
+    });
+
+    it('reads an ISO date string too, and keeps null as null for a nullable date', () => {
+        expect((probe.Convert(dateField, '2026-09-25T19:47:14.563Z') as Date).toISOString()).toBe('2026-09-25T19:47:14.563Z');
+        expect(probe.Convert({ ...dateField, AllowsNull: true, DefaultValue: null }, null)).toBeNull();
+    });
+
+    it('types numbers and booleans like the field', () => {
+        expect(probe.Convert({ Name: 'N', TSType: EntityFieldTSType.Number, Type: 'int' }, '42')).toBe(42);
+        expect(probe.Convert({ Name: 'B', TSType: EntityFieldTSType.Boolean, Type: 'bit' }, 'false')).toBe(false);
+        expect(probe.Convert({ Name: 'B', TSType: EntityFieldTSType.Boolean, Type: 'bit', AllowsNull: true }, null)).toBe(false);
+        expect(probe.Convert({ Name: 'B', TSType: EntityFieldTSType.Boolean, Type: 'bit' }, '1')).toBe(true);
+        expect(probe.Convert({ Name: 'M', TSType: EntityFieldTSType.Number, Type: 'money' }, '1.5')).toBe(1.5);
+    });
+});
+
+describe('ResolverBase.MustLoadTruthFromDatabase', () => {
+    it('always loads a Record Change from the database, so client OldValues cannot pin forged audit columns', () => {
+        expect(probe.MustLoad({ Name: 'MJ: Record Changes', TrackRecordChanges: false }, true)).toBe(true);
+    });
+
+    it('still trusts OldValues on other untracked entities without field security', () => {
+        expect(probe.MustLoad({ Name: 'MJ: Tags', TrackRecordChanges: false, EnableFieldLevelSecurity: false }, true)).toBe(false);
+    });
+});

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

@@ -0,0 +1,398 @@
+/**
+ * @fileoverview The agent's history floor on `RunAIAgentFromConversationDetail`.
+ *
+ * `agentHistoryFrom` is the one server change behind the conversations host rules: an optional
+ * ISO-8601 timestamp, the first moment of the conversation a run may read. These tests pin that
+ * the mutation parses it before anything loads, fails the request on an unreadable value instead
+ * of dropping it, loads history from it (in the query AND in the window assembly), and hands it to
+ * the agent run as `ConversationHistoryFrom` on both the synchronous and fire-and-forget paths —
+ * and that leaving it out changes nothing.
+ */
+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(),
+}));
+
+vi.mock('@memberjunction/ai-agents', () => ({
+    AgentRunner: class {
+        RunAgentInConversation(...args: unknown[]) {
+            return hoisted.runAgentInConversation(...args);
+        }
+    },
+    ArtifactToolManager: class {},
+}));
+
+vi.mock('../realtimeWidget/widgetGuestElevation.js', () => ({
+    ResolveWidgetGuestRunContext: vi.fn().mockResolvedValue(null),
+    ElevateUserPayload: vi.fn(),
+}));
+
+import { ConversationEngine } from '@memberjunction/core-entities';
+import { RunAIAgentResolver } from '../resolvers/RunAIAgentResolver.js';
+import type { AppContext, UserPayload } from '../types.js';
+
+const FLOOR_ISO = '2026-09-01T12:00:00.000Z';
+const USER = { ID: 'user-1', Email: 'user@example.com' };
+
+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;
+    executeAIAgent: Fn;
+    executeAgentInBackground: Fn;
+    loadInputArtifactsBatch: Fn;
+    validateAgent: Fn;
+    persistInFlightAgentFailure: Fn;
+}
+
+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().mockReturnValue(USER);
+    return { resolver, seams };
+}
+
+function makeContext(): AppContext {
+    const provider = {
+        GetEntityObject: vi.fn().mockResolvedValue({
+            ConversationID: 'conv-1',
+            Load: vi.fn().mockResolvedValue(true),
+        }),
+    };
+    return {
+        userPayload: { sessionId: 'session-1', userRecord: USER } as unknown as UserPayload,
+        providers: [{ type: 'Read-Write', provider }],
+        dataSource: {},
+    } as unknown as AppContext;
+}
+
+const pubSub = { publish: vi.fn() } as unknown as PubSubEngine;
+
+async function runMutation(
+    resolver: RunAIAgentResolver,
+    options: { agentHistoryFrom?: string; fireAndForget?: boolean }
+) {
+    return resolver.RunAIAgentFromConversationDetail(
+        'detail-1', 'agent-1', makeContext(), 'session-1', pubSub,
+        undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+        undefined, undefined, options.fireAndForget, undefined, undefined,
+        options.agentHistoryFrom
+    );
+}
+
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+
+describe('RunAIAgentFromConversationDetail — agentHistoryFrom', () => {
+    let resolver: RunAIAgentResolver;
+    let seams: ResolverSeams;
+
+    beforeEach(() => {
+        ({ resolver, seams } = makeResolver());
+        seams.loadConversationHistoryWithAttachments = vi.fn().mockResolvedValue([]);
+        seams.executeAIAgent = vi.fn().mockResolvedValue({ success: true, result: '{}' });
+        seams.executeAgentInBackground = vi.fn();
+    });
+
+    it('loads history from the floor and hands the floor to the run', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: FLOOR_ISO });
+
+        expect(result.success).toBe(true);
+        const loaderArgs = seams.loadConversationHistoryWithAttachments.mock.calls[0];
+        expect(loaderArgs[0]).toBe('conv-1');
+        expect(loaderArgs[4]).toEqual(['detail-1']);
+        expect((loaderArgs[5] as Date).toISOString()).toBe(FLOOR_ISO);
+        const runFloor = seams.executeAIAgent.mock.calls[0].at(-1) as Date;
+        expect(runFloor.toISOString()).toBe(FLOOR_ISO);
+    });
+
+    it('hands the floor to a fire-and-forget run too', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: FLOOR_ISO, fireAndForget: true });
+
+        expect(result.success).toBe(true);
+        expect(seams.executeAIAgent).not.toHaveBeenCalled();
+        const runFloor = seams.executeAgentInBackground.mock.calls[0].at(-1) as Date;
+        expect(runFloor.toISOString()).toBe(FLOOR_ISO);
+    });
+
+    it('left out, reads the whole conversation as before', async () => {
+        await runMutation(resolver, {});
+
+        expect(seams.loadConversationHistoryWithAttachments.mock.calls[0][5]).toBeUndefined();
+        expect(seams.executeAIAgent.mock.calls[0].at(-1)).toBeUndefined();
+    });
+
+    it('fails the request on an unreadable floor, before loading or running anything', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: 'last tuesday' });
+
+        expect(result.success).toBe(false);
+        expect(result.errorMessage).toContain('agentHistoryFrom');
+        expect(seams.loadConversationHistoryWithAttachments).not.toHaveBeenCalled();
+        expect(seams.executeAIAgent).not.toHaveBeenCalled();
+        expect(seams.executeAgentInBackground).not.toHaveBeenCalled();
+    });
+
+    it('treats an empty string as unreadable too, never as "no floor"', async () => {
+        const result = await runMutation(resolver, { agentHistoryFrom: '' });
+
+        expect(result.success).toBe(false);
+        expect(seams.executeAIAgent).not.toHaveBeenCalled();
+    });
+});
+
+describe('loadConversationHistoryWithAttachments — history floor', () => {
+    it('passes the floor to the fresh loader and to the window assembly', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.loadInputArtifactsBatch = vi.fn().mockResolvedValue(new Map());
+        const loadRows = vi.spyOn(ConversationEngine, 'LoadWindowRowsFresh').mockResolvedValue([]);
+        const assemble = vi.spyOn(ConversationEngine, 'AssembleContextWindow');
+        const floor = new Date(FLOOR_ISO);
+        const provider = {};
+
+        const load = (resolver as unknown as {
+            loadConversationHistoryWithAttachments(
+                conversationId: string, user: unknown, max: number, provider: unknown, exclude?: string[], historyFrom?: Date
+            ): Promise<unknown[]>;
+        }).loadConversationHistoryWithAttachments.bind(resolver);
+        await load('conv-1', USER, 20, provider, ['detail-1'], floor);
+
+        expect(loadRows).toHaveBeenCalledWith('conv-1', USER, provider, floor);
+        expect(assemble.mock.calls[0][1]).toEqual({ maxTailMessages: 20, excludeDetailIds: ['detail-1'], historyFrom: floor });
+    });
+});
+
+function executeArgs(conversationHistoryFrom?: Date): unknown[] {
+    const userPayload = { sessionId: 'session-1', userRecord: USER };
+    return [
+        {}, {}, '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,
+        conversationHistoryFrom,
+    ];
+}
+
+describe('executeAIAgent — ConversationHistoryFrom', () => {
+    function wire() {
+        const { resolver, seams } = makeResolver();
+        seams.validateAgent = vi.fn().mockResolvedValue({ ID: 'agent-1', Name: 'Test Agent' });
+        seams.persistInFlightAgentFailure = vi.fn().mockResolvedValue(undefined);
+        // Stop right after the params are captured — the rest of the run is out of scope, and so
+        // is the failure it logs.
+        hoisted.runAgentInConversation.mockReset().mockRejectedValue(new Error('stop here'));
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const execute = (resolver as unknown as {
+            executeAIAgent(...args: unknown[]): Promise<{ success: boolean }>;
+        }).executeAIAgent.bind(resolver);
+        return execute;
+    }
+
+    it('puts the floor on the run\'s params', async () => {
+        const execute = wire();
+        const floor = new Date(FLOOR_ISO);
+        await execute(...executeArgs(floor));
+
+        const params = hoisted.runAgentInConversation.mock.calls[0][0] as Record<string, unknown>;
+        expect(params.ConversationHistoryFrom).toBe(floor);
+    });
+
+    it('leaves it unset without a floor', async () => {
+        const execute = wire();
+        await execute(...executeArgs());
+
+        const params = hoisted.runAgentInConversation.mock.calls[0][0] as Record<string, unknown>;
+        expect(params.ConversationHistoryFrom).toBeUndefined();
+    });
+});
+
+describe('executeAIAgent — status publishing', () => {
+    const agentRun = {
+        ID: 'run-1',
+        ConversationDetailID: 'detail-1',
+        Steps: [{ StepName: 'Answer' }],
+        GetAll: () => ({ ID: 'run-1', ConversationDetailID: 'detail-1', Agent: 'Betty' }),
+    };
+
+    function envelopes(publish: ReturnType<typeof vi.fn>): Array<Record<string, unknown>> {
+        return publish.mock.calls.map((call) => JSON.parse((call[1] as { message: string }).message) as Record<string, unknown>);
+    }
+
+    it('publishes progress, streamed text, the partial result, and the completion from the runner callbacks', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.validateAgent = vi.fn().mockResolvedValue({ ID: 'agent-1', Name: 'Test Agent' });
+        seams.persistInFlightAgentFailure = vi.fn().mockResolvedValue(undefined);
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const publish = vi.fn().mockResolvedValue(undefined);
+        (pubSub as unknown as { publish: Fn }).publish = publish;
+        hoisted.runAgentInConversation.mockReset().mockImplementation(async (params: {
+            onProgress?: (progress: { step: string; message?: string; percentage?: number; metadata?: Record<string, unknown> }) => void;
+            onStreaming?: (chunk: { content: string; isComplete: boolean; stepType?: string; kind?: string }) => void;
+        }) => {
+            params.onProgress?.({ step: 'initialization', message: 'noise', metadata: { agentRun } });
+            params.onProgress?.({
+                step: 'prompt_execution',
+                message: 'Writing',
+                percentage: 40,
+                metadata: { agentRun, agentName: 'Betty' },
+            });
+            params.onStreaming?.({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+            return {
+                agentResult: { success: true, agentRun, payload: { text: 'Hello' } },
+                agentResponseDetailId: 'detail-1',
+                conversationId: 'conv-1',
+            };
+        });
+        const execute = (resolver as unknown as {
+            executeAIAgent(...args: unknown[]): Promise<{ success: boolean }>;
+        }).executeAIAgent.bind(resolver);
+
+        const result = await execute(...executeArgs());
+
+        expect(result.success).toBe(true);
+        const sent = envelopes(publish);
+        expect(sent.map((row) => (row.data as { type: string }).type)).toEqual([
+            'progress',
+            'streaming',
+            'partial_result',
+            'complete',
+        ]);
+        expect(sent[0].type).toBe('ExecutionProgress');
+        expect(sent[0].resolver).toBe('RunAIAgentResolver');
+        expect((sent[1].data as { streaming: { content: string } }).streaming.content).toBe('Hel');
+        const completion = sent[3].data as { conversationDetailId: string; agentRunId: string; success: boolean };
+        expect(completion.conversationDetailId).toBe('detail-1');
+        expect(completion.agentRunId).toBe('run-1');
+        expect(completion.success).toBe(true);
+    });
+
+    it('publishes a failure completion when a fire-and-forget run rejects', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.executeAIAgent = vi.fn().mockRejectedValue(new Error('background blew up'));
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const localPubSub = { publish } as unknown as PubSubEngine;
+        const userPayload = { sessionId: 'session-1', userRecord: USER };
+        const runInBackground = (resolver as unknown as {
+            executeAgentInBackground(...args: unknown[]): void;
+        }).executeAgentInBackground.bind(resolver);
+
+        runInBackground(
+            {}, {}, 'agent-1', userPayload, '[]', 'session-1', localPubSub,
+            undefined, undefined, undefined, undefined, undefined, 'detail-1',
+        );
+        await vi.waitFor(() => expect(publish).toHaveBeenCalled());
+
+        const sent = envelopes(publish);
+        expect(sent).toHaveLength(1);
+        expect(sent[0].type).toBe('StreamingContent');
+        expect(sent[0].resolver).toBe('RunAIAgentResolver');
+        const completion = sent[0].data as {
+            type: string;
+            agentRunId: string;
+            conversationDetailId: string;
+            success: boolean;
+            errorMessage: string;
+            result: string;
+        };
+        expect(completion).toMatchObject({
+            type: 'complete',
+            agentRunId: 'unknown',
+            conversationDetailId: 'detail-1',
+            success: false,
+            errorMessage: 'background blew up',
+            result: JSON.stringify({ success: false, errorMessage: 'background blew up' }),
+        });
+    });
+
+    it('saves a Running run reported by progress as Failed when the agent throws', async () => {
+        const { resolver, seams } = makeResolver();
+        seams.validateAgent = vi.fn().mockResolvedValue({ ID: 'agent-1', Name: 'Test Agent' });
+        vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        const runningRun = {
+            ID: 'run-1',
+            Status: 'Running',
+            ErrorMessage: '',
+            CompletedAt: null as Date | null,
+            EnsureSaveComplete: vi.fn().mockResolvedValue(undefined),
+            Save: vi.fn().mockResolvedValue(true),
+        };
+        const detail = {
+            Status: 'Complete',
+            Load: vi.fn().mockResolvedValue(true),
+            Save: vi.fn().mockResolvedValue(true),
+        };
+        const provider = { GetEntityObject: vi.fn().mockResolvedValue(detail) };
+        hoisted.runAgentInConversation.mockReset().mockImplementation(async (params: {
+            onProgress?: (progress: { step: string; metadata?: Record<string, unknown> }) => void;
+        }) => {
+            params.onProgress?.({ step: 'prompt_execution', metadata: { agentRun: runningRun } });
+            throw new Error('agent threw mid-run');
+        });
+        const execute = (resolver as unknown as {
+            executeAIAgent(...args: unknown[]): Promise<{ success: boolean; errorMessage?: string }>;
+        }).executeAIAgent.bind(resolver);
+        const args = executeArgs();
+        args[0] = provider;
+
+        const result = await execute(...args);
+
+        expect(result.success).toBe(false);
+        expect(result.errorMessage).toBe('agent threw mid-run');
+        expect(runningRun.Status).toBe('Failed');
+        expect(runningRun.ErrorMessage).toBe('agent threw mid-run');
+        expect(runningRun.CompletedAt).toBeInstanceOf(Date);
+        expect(runningRun.EnsureSaveComplete).toHaveBeenCalled();
+        expect(runningRun.Save).toHaveBeenCalled();
+        expect(detail.Save).not.toHaveBeenCalled();
+    });
+});
+
+describe('persistInFlightAgentFailure — a refused conversation-detail save logs the reason (MJ#4791)', () => {
+    it('includes LatestResult.CompleteMessage when the Error-status save is refused', async () => {
+        const { resolver } = makeResolver();
+        const errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const detail = {
+            Status: 'In-Progress',
+            LatestResult: { CompleteMessage: 'You do not have access to this conversation.' },
+            Load: vi.fn().mockResolvedValue(true),
+            EnsureSaveComplete: vi.fn().mockResolvedValue(undefined),
+            Save: vi.fn().mockResolvedValue(false),
+        };
+        const provider = { GetEntityObject: vi.fn().mockResolvedValue(detail) };
+        const persist = (resolver as unknown as {
+            persistInFlightAgentFailure(...args: unknown[]): Promise<void>;
+        }).persistInFlightAgentFailure.bind(resolver);
+
+        await persist(provider, { sessionId: 'session-1', userRecord: USER }, null, 'detail-1', 'agent threw');
+
+        const lines = errSpy.mock.calls.map((call) => String(call[0]));
+        const line = lines.find((l) => l.includes('Failed to persist Error on conversation detail detail-1'));
+        expect(line).toBeDefined();
+        expect(line).toContain('You do not have access to this conversation.');
+    });
+});

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

@@ -29,31 +29,27 @@ vi.mock('type-graphql', () => {
 });
 import type { AgentExecutionStreamingCallback } from '@memberjunction/ai-core-plus';
 
-import { RunAIAgentResolver } from '../resolvers/RunAIAgentResolver.js';
+import { AgentRunStatusPublisher } from '../resolvers/AgentRunStatusPublisher.js';
 import type { UserPayload } from '../types.js';
 
-/** Access the private factory without widening the class's public API. */
-interface StreamingCallbackFactory {
-    createStreamingCallback(
-        pubSub: PubSubEngine,
-        sessionId: string,
-        userPayload: UserPayload,
-        agentRunRef: { current: unknown }
-    ): AgentExecutionStreamingCallback;
-}
+const agentRun = {
+    ID: 'run-1',
+    GetAll: () => ({ ID: 'run-1', ConversationDetailID: 'detail-1', Agent: 'Betty' }),
+};
 
 function buildHarness() {
     const publish = vi.fn().mockResolvedValue(undefined);
     const pubSub = { publish } as unknown as PubSubEngine;
-    const userPayload = { sessionId: 'session-1' } as UserPayload;
-    const agentRunRef = {
-        current: {
-            ID: 'run-1',
-            GetAll: () => ({ ID: 'run-1', ConversationDetailID: 'detail-1', Agent: 'Betty' }),
-        },
-    };
-    const resolver = new RunAIAgentResolver() as unknown as StreamingCallbackFactory;
-    const callback = resolver.createStreamingCallback(pubSub, 'session-1', userPayload, agentRunRef);
+    const userPayload = { sessionId: 'session-1', userRecord: { ID: 'user-1' } } as UserPayload;
+    const publisher = new AgentRunStatusPublisher(pubSub, userPayload, 'session-1');
+    // A progress event, even a noise step, is how the publisher learns the run.
+    publisher.OnProgress({
+        step: 'initialization',
+        message: 'starting',
+        metadata: { agentRun },
+    });
+    publish.mockClear();
+    const callback: AgentExecutionStreamingCallback = publisher.OnStreaming;
     return { publish, callback };
 }
 
@@ -67,7 +63,7 @@ function publishedData(publish: ReturnType<typeof vi.fn>): Record<string, unknow
     return parsed.data as Record<string, unknown>;
 }
 
-describe('RunAIAgentResolver.createStreamingCallback', () => {
+describe('AgentRunStatusPublisher streaming wire shape', () => {
     it('publishes the streaming wire shape the conversation client parses', () => {
         const { publish, callback } = buildHarness();
 
@@ -110,13 +106,8 @@ describe('RunAIAgentResolver.createStreamingCallback', () => {
     it('does not publish when no agent run is available yet', () => {
         const publish = vi.fn();
         const pubSub = { publish } as unknown as PubSubEngine;
-        const resolver = new RunAIAgentResolver() as unknown as StreamingCallbackFactory;
-        const callback = resolver.createStreamingCallback(
-            pubSub,
-            'session-1',
-            { sessionId: 'session-1' } as UserPayload,
-            { current: null }
-        );
+        const publisher = new AgentRunStatusPublisher(pubSub, { sessionId: 'session-1', userRecord: { ID: 'user-1' } } as UserPayload, 'session-1');
+        const callback = publisher.OnStreaming;
         const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
         try {
             callback({ content: 'early', isComplete: false });