@memberjunction/server 6.2.0-edge.1 → 6.2.0-edge.3

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

@@ -0,0 +1,291 @@
+// ResolverBase / RunViewResolver transitively pull in type-graphql decorators, which need the
+// Reflect.metadata polyfill at import time.
+import 'reflect-metadata';
+import { describe, it, expect } from 'vitest';
+import type {
+    DatabaseProviderBase,
+    EntityInfo,
+    IMetadataProvider,
+    RunViewParams,
+    RunViewResult,
+    RunViewWithCacheCheckParams,
+    RunViewsWithCacheCheckResponse,
+    UserInfo,
+} from '@memberjunction/core';
+import type { MJUserViewEntityExtended } from '@memberjunction/core-entities';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import {
+    RunViewResolver,
+    type RunDynamicViewInput,
+    type RunViewByIDInput,
+    type RunViewByNameInput,
+    type RunViewResultRow,
+    type RunViewWithCacheCheckInput,
+} from '../generic/RunViewResolver.js';
+import type { AppContext, UserPayload } from '../types.js';
+
+/**
+ * Binary DB fields (varbinary / bytea) are base64 strings in JS and on the wire, and RunView
+ * omits them unless `IncludeBinaryFields: true`. These tests pin the server half:
+ *
+ *   1. the GraphQL flag reaches the provider's RunView / RunViews / RunViewsWithCacheCheck params
+ *      on every resolver path (single by-ID / by-name / dynamic, batch, and the cache-check batch);
+ *   2. any byte array that still reaches a resolver is serialized as base64 — never as the
+ *      `{"type":"Buffer","data":[...]}` that `JSON.stringify` produces for a Node Buffer.
+ */
+
+const ENTITY_NAME = 'MJ: Vector Things';
+const ENTITY_ID = 'ent-1';
+
+/** Bytes whose base64 form is easy to recognise: [1,2,3,4] → "AQIDBA==". */
+const BYTES = [1, 2, 3, 4];
+const BYTES_BASE64 = 'AQIDBA==';
+
+const fakePayload = () =>
+    ({ email: 'tester@example.com', userRecord: { Email: 'tester@example.com' } as UserInfo } as UserPayload);
+
+function entityStub() {
+    return {
+        ID: ENTITY_ID,
+        Name: ENTITY_NAME,
+        BaseView: 'vwVectorThings',
+        PrimaryKeys: [{ Name: 'ID' }],
+        Fields: [
+            { Name: 'ID', CodeName: 'ID' },
+            { Name: 'Embedding', CodeName: 'Embedding' },
+        ],
+        EncryptedFields: [],
+    };
+}
+
+/** Provider that records every RunView / RunViews call and returns the given rows. */
+function recordingProvider(rows: Record<string, unknown>[] = []) {
+    const runViewCalls: RunViewParams[] = [];
+    const runViewsCalls: RunViewParams[][] = [];
+    const viewInfo = { ID: 'view-1', Name: 'Saved View', Entity: ENTITY_NAME, EntityID: ENTITY_ID };
+    const provider = {
+        Entities: [entityStub()],
+        EntityByName: (name: string) => (name === ENTITY_NAME ? entityStub() : undefined),
+        RunView: async (params: RunViewParams): Promise<RunViewResult> => {
+            // RunViewByNameGeneric looks the saved view up first — answer that lookup with the view row.
+            if (params.EntityName === 'MJ: User Views') {
+                return { Success: true, Results: [viewInfo], RowCount: 1, TotalRowCount: 1, ErrorMessage: '' } as RunViewResult;
+            }
+            runViewCalls.push(params);
+            return { Success: true, Results: rows, RowCount: rows.length, TotalRowCount: rows.length, ErrorMessage: '' } as RunViewResult;
+        },
+        RunViews: async (params: RunViewParams[]): Promise<RunViewResult[]> => {
+            runViewsCalls.push(params);
+            return params.map(() => ({ Success: true, Results: rows, RowCount: rows.length, TotalRowCount: rows.length, ErrorMessage: '' } as RunViewResult));
+        },
+        GetEntityObject: async () => ({ ...viewInfo, Load: async () => true }),
+    } as unknown as DatabaseProviderBase;
+    return { provider, runViewCalls, runViewsCalls };
+}
+
+/** Skips the encrypted-field filter (it needs live Metadata) — irrelevant to these assertions. */
+class Probe extends ResolverBase {
+    protected override async ArrayFilterEncryptedFieldsForAPI(
+        _entityName: string,
+        dataObjectArray: Record<string, unknown>[]
+    ): Promise<Record<string, unknown>[]> {
+        return dataObjectArray;
+    }
+
+    public MapOne(entityName: string, row: unknown, provider: IMetadataProvider) {
+        return this.MapFieldNamesToCodeNames(entityName, row, undefined, provider);
+    }
+}
+
+describe('IncludeBinaryFields forwarding — single-view resolver paths', () => {
+    it('RunDynamicViewGeneric forwards IncludeBinaryFields: true to provider.RunView', async () => {
+        const { provider, runViewCalls } = recordingProvider();
+        await new Probe().RunDynamicViewGeneric(
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', IncludeBinaryFields: true } as RunDynamicViewInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(runViewCalls).toHaveLength(1);
+        expect(runViewCalls[0].IncludeBinaryFields).toBe(true);
+    });
+
+    it('RunDynamicViewGeneric leaves IncludeBinaryFields undefined when the caller did not set it', async () => {
+        const { provider, runViewCalls } = recordingProvider();
+        await new Probe().RunDynamicViewGeneric(
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '' } as RunDynamicViewInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(runViewCalls).toHaveLength(1);
+        expect(runViewCalls[0].IncludeBinaryFields).toBeUndefined();
+    });
+
+    it('RunViewByNameGeneric forwards IncludeBinaryFields to provider.RunView', async () => {
+        const { provider, runViewCalls } = recordingProvider();
+        await new Probe().RunViewByNameGeneric(
+            { ViewName: 'Saved View', ExtraFilter: '', OrderBy: '', IncludeBinaryFields: true } as RunViewByNameInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(runViewCalls).toHaveLength(1);
+        expect(runViewCalls[0].EntityName).toBe(ENTITY_NAME);
+        expect(runViewCalls[0].IncludeBinaryFields).toBe(true);
+    });
+
+    it('RunViewByIDGeneric forwards IncludeBinaryFields to provider.RunView', async () => {
+        const { provider, runViewCalls } = recordingProvider();
+        await new Probe().RunViewByIDGeneric(
+            { ViewID: 'view-1', ExtraFilter: '', OrderBy: '', IncludeBinaryFields: false } as RunViewByIDInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect(runViewCalls).toHaveLength(1);
+        expect(runViewCalls[0].IncludeBinaryFields).toBe(false);
+    });
+
+    it('RunViewGenericInternal passes binary values through as the provider returned them (base64 strings)', async () => {
+        const { provider } = recordingProvider([{ ID: 'r1', Embedding: BYTES_BASE64 }]);
+        const result = await new Probe().RunDynamicViewGeneric(
+            { EntityName: ENTITY_NAME, ExtraFilter: '', OrderBy: '', IncludeBinaryFields: true } as RunDynamicViewInput,
+            provider, fakePayload(), undefined as never,
+        );
+
+        expect((result?.Results as Record<string, unknown>[])[0].Embedding).toBe(BYTES_BASE64);
+    });
+});
+
+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: '' },
+        ] as (RunViewByNameInput & RunViewByIDInput & RunDynamicViewInput)[];
+
+        await new Probe().RunViewsGeneric(inputs, provider, fakePayload());
+
+        expect(runViewsCalls).toHaveLength(1);
+        expect(runViewsCalls[0]).toHaveLength(2);
+        expect(runViewsCalls[0][0].IncludeBinaryFields).toBe(true);
+        expect(runViewsCalls[0][1].IncludeBinaryFields).toBeUndefined();
+    });
+});
+
+describe('MapFieldNamesToCodeNames — byte arrays become base64', () => {
+    const provider = {
+        EntityByName: (name: string) => (name === ENTITY_NAME ? (entityStub() as unknown as EntityInfo) : undefined),
+    } as unknown as IMetadataProvider;
+
+    it('converts a Buffer value to its base64 string', async () => {
+        const mapped = (await new Probe().MapOne(ENTITY_NAME, { ID: 'r1', Embedding: Buffer.from(BYTES) }, provider)) as Record<string, unknown>;
+
+        expect(mapped.Embedding).toBe(BYTES_BASE64);
+        expect(mapped.ID).toBe('r1');
+    });
+
+    it('converts a plain Uint8Array value too', async () => {
+        const mapped = (await new Probe().MapOne(ENTITY_NAME, { ID: 'r1', Embedding: new Uint8Array(BYTES) }, provider)) as Record<string, unknown>;
+
+        expect(mapped.Embedding).toBe(BYTES_BASE64);
+    });
+
+    it('leaves an already-base64 string untouched', async () => {
+        const mapped = (await new Probe().MapOne(ENTITY_NAME, { ID: 'r1', Embedding: BYTES_BASE64 }, provider)) as Record<string, unknown>;
+
+        expect(mapped.Embedding).toBe(BYTES_BASE64);
+    });
+
+    it('does not mutate the caller\'s row (it may be a frozen cache entry)', async () => {
+        const buffer = Buffer.from(BYTES);
+        const source = Object.freeze({ ID: 'r1', Embedding: buffer }) as Record<string, unknown>;
+
+        const mapped = (await new Probe().MapOne(ENTITY_NAME, source, provider)) as Record<string, unknown>;
+
+        expect(mapped.Embedding).toBe(BYTES_BASE64);
+        expect(source.Embedding).toBe(buffer);
+    });
+});
+
+/** Exposes the protected serializer. */
+class ResolverProbe extends RunViewResolver {
+    public Process(rows: Record<string, unknown>[]): RunViewResultRow[] {
+        return this.processRawData(rows, ENTITY_ID, entityStub() as unknown as EntityInfo);
+    }
+}
+
+describe('RunViewResolver.processRawData — Buffer → base64 in the Data JSON', () => {
+    it('serializes a Buffer value as base64, not {type:"Buffer",data:[...]}', () => {
+        const [row] = new ResolverProbe().Process([{ ID: 'r1', Embedding: Buffer.from(BYTES) }]);
+        const data = JSON.parse(row.Data) as Record<string, unknown>;
+
+        expect(data.Embedding).toBe(BYTES_BASE64);
+        expect(row.Data).not.toContain('"type":"Buffer"');
+        expect(row.PrimaryKey).toEqual([{ FieldName: 'ID', Value: 'r1' }]);
+        expect(row.EntityID).toBe(ENTITY_ID);
+    });
+
+    it('serializes a Uint8Array value as base64 (not an index-keyed object)', () => {
+        const [row] = new ResolverProbe().Process([{ ID: 'r1', Embedding: new Uint8Array(BYTES) }]);
+
+        expect((JSON.parse(row.Data) as Record<string, unknown>).Embedding).toBe(BYTES_BASE64);
+    });
+
+    it('leaves rows without byte arrays serialized exactly as before', () => {
+        const source = { ID: 'r1', Name: 'Plain', Embedding: BYTES_BASE64, Count: 3 };
+        const [row] = new ResolverProbe().Process([source]);
+
+        expect(row.Data).toBe(JSON.stringify(source));
+    });
+
+    it('does not mutate the source row', () => {
+        const buffer = Buffer.from(BYTES);
+        const source: Record<string, unknown> = { ID: 'r1', Embedding: buffer };
+
+        new ResolverProbe().Process([source]);
+
+        expect(source.Embedding).toBe(buffer);
+    });
+});
+
+describe('RunViewResolver.RunViewsWithCacheCheck — IncludeBinaryFields + Buffer serialization', () => {
+    function cacheCheckContext(rows: Record<string, unknown>[]) {
+        const received: RunViewWithCacheCheckParams[][] = [];
+        const provider = {
+            EntityByName: (name: string) => (name === ENTITY_NAME ? entityStub() : undefined),
+            RunViewsWithCacheCheck: async (params: RunViewWithCacheCheckParams[]): Promise<RunViewsWithCacheCheckResponse> => {
+                received.push(params);
+                return {
+                    success: true,
+                    results: params.map((_p, i) => ({ viewIndex: i, status: 'stale', results: rows, maxUpdatedAt: 'T', rowCount: rows.length })),
+                } as RunViewsWithCacheCheckResponse;
+            },
+        };
+        const ctx = { providers: [{ type: 'Read-Only', provider }], userPayload: fakePayload() } as unknown as AppContext;
+        return { ctx, received };
+    }
+
+    it('forwards IncludeBinaryFields into the core params (true, false and unset)', async () => {
+        const { ctx, received } = cacheCheckContext([]);
+        const input = [
+            { params: { EntityName: ENTITY_NAME, IncludeBinaryFields: true } },
+            { params: { EntityName: ENTITY_NAME, IncludeBinaryFields: false } },
+            { params: { EntityName: ENTITY_NAME } },
+        ] as RunViewWithCacheCheckInput[];
+
+        const out = await new RunViewResolver().RunViewsWithCacheCheck(input, ctx);
+
+        expect(out.success).toBe(true);
+        expect(received).toHaveLength(1);
+        expect(received[0].map(p => p.params.IncludeBinaryFields)).toEqual([true, false, undefined]);
+    });
+
+    it('serializes Buffers in stale results as base64', async () => {
+        const { ctx } = cacheCheckContext([{ ID: 'r1', Embedding: Buffer.from(BYTES) }]);
+        const input = [{ params: { EntityName: ENTITY_NAME, IncludeBinaryFields: true } }] as RunViewWithCacheCheckInput[];
+
+        const out = await new RunViewResolver().RunViewsWithCacheCheck(input, ctx);
+        const rows = out.results[0].Results as RunViewResultRow[];
+
+        expect((JSON.parse(rows[0].Data) as Record<string, unknown>).Embedding).toBe(BYTES_BASE64);
+    });
+});

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

@@ -183,6 +183,16 @@ describe('loadConversationHistoryWithAttachments — history 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();
@@ -199,20 +209,10 @@ describe('executeAIAgent — ConversationHistoryFrom', () => {
         return execute;
     }
 
-    function positional(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,
-        ];
-    }
-
     it('puts the floor on the run\'s params', async () => {
         const execute = wire();
         const floor = new Date(FLOOR_ISO);
-        await execute(...positional(floor));
+        await execute(...executeArgs(floor));
 
         const params = hoisted.runAgentInConversation.mock.calls[0][0] as Record<string, unknown>;
         expect(params.ConversationHistoryFrom).toBe(floor);
@@ -220,9 +220,179 @@ describe('executeAIAgent — ConversationHistoryFrom', () => {
 
     it('leaves it unset without a floor', async () => {
         const execute = wire();
-        await execute(...positional());
+        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 });