@memberjunction/server 6.1.4 → 6.2.0-edge.1

package/src/__tests__/RESTEndpointHandler.test.ts

@@ -188,26 +188,26 @@ describe('RESTEndpointHandler.isEntityAllowed', () => {
     });
 
     it('blocks entities in excluded schemas (case-insensitive), with schema exclusion taking top precedence', () => {
-        const schemaOnly = makeHandler({ excludeSchemas: ['VAULT'] });
+        const schemaOnly = makeHandler({ ExcludeSchemas: ['VAULT'] });
         expect(schemaOnly.isEntityAllowed('Secrets')).toBe(false);
         expect(schemaOnly.isEntityAllowed('Users')).toBe(true); // other schemas unaffected
 
         // Even an explicit entity include cannot override a schema exclusion
-        const withInclude = makeHandler({ excludeSchemas: ['vault'], includeEntities: ['secrets'] });
+        const withInclude = makeHandler({ ExcludeSchemas: ['vault'], IncludeEntities: ['secrets'] });
         expect(withInclude.isEntityAllowed('Secrets')).toBe(false);
     });
 
     it('restricts to included schemas when includeSchemas is set', () => {
-        const handler = makeHandler({ includeSchemas: ['crm'] });
+        const handler = makeHandler({ IncludeSchemas: ['crm'] });
         expect(handler.isEntityAllowed('Users')).toBe(true);
         expect(handler.isEntityAllowed('Secrets')).toBe(false);
     });
 
     it('blocks lowercase exact-name exclusions and wildcard exclusions of any case', () => {
-        const lowercase = makeHandler({ excludeEntities: ['secrets'] });
+        const lowercase = makeHandler({ ExcludeEntities: ['secrets'] });
         expect(lowercase.isEntityAllowed('Secrets')).toBe(false);
 
-        const wildcard = makeHandler({ excludeEntities: ['Secret*'] });
+        const wildcard = makeHandler({ ExcludeEntities: ['Secret*'] });
         expect(wildcard.isEntityAllowed('Secrets')).toBe(false);
         expect(wildcard.isEntityAllowed('Users')).toBe(true);
     });
@@ -217,25 +217,25 @@ describe('RESTEndpointHandler.isEntityAllowed', () => {
         // the RAW configured pattern (only the wildcard branch lowercases patterns).
         // An operator writing excludeEntities: ['Secrets'] — the natural casing —
         // gets NO exclusion. Pinned so a normalization fix flips this test.
-        const handler = makeHandler({ excludeEntities: ['Secrets'] });
+        const handler = makeHandler({ ExcludeEntities: ['Secrets'] });
         expect(handler.isEntityAllowed('Secrets')).toBe(true); // exclusion ineffective!
     });
 
     it('exclusions override inclusions for the same entity', () => {
-        const handler = makeHandler({ includeEntities: ['user*'], excludeEntities: ['userroles'] });
+        const handler = makeHandler({ IncludeEntities: ['user*'], ExcludeEntities: ['userroles'] });
         expect(handler.isEntityAllowed('Users')).toBe(true);
         expect(handler.isEntityAllowed('UserRoles')).toBe(false);
     });
 
     it('an include list denies everything not on it, with wildcard support', () => {
-        const handler = makeHandler({ includeEntities: ['user*'] });
+        const handler = makeHandler({ IncludeEntities: ['user*'] });
         expect(handler.isEntityAllowed('Users')).toBe(true);
         expect(handler.isEntityAllowed('UserRoles')).toBe(true);
         expect(handler.isEntityAllowed('Secrets')).toBe(false);
     });
 
     it('SECURITY GAP: a mixed-case exact inclusion fails to include (same raw-pattern comparison)', () => {
-        const handler = makeHandler({ includeEntities: ['Users'] });
+        const handler = makeHandler({ IncludeEntities: ['Users'] });
         expect(handler.isEntityAllowed('Users')).toBe(false); // include list active, but never matches
     });
 });
@@ -271,7 +271,7 @@ describe('RESTEndpointHandler middleware', () => {
 
     describe('checkEntityAccess', () => {
         it('rejects blocked entities with 403 before any handler runs', () => {
-            const handler = makeHandler({ excludeEntities: ['secrets'] });
+            const handler = makeHandler({ ExcludeEntities: ['secrets'] });
             const req = makeReq({ params: { entityName: 'Secrets' } });
             const { res, statusCode, jsonBody } = makeRes();
             const next = vi.fn();
@@ -286,7 +286,7 @@ describe('RESTEndpointHandler middleware', () => {
         });
 
         it('passes allowed entities through', () => {
-            const handler = makeHandler({ excludeEntities: ['secrets'] });
+            const handler = makeHandler({ ExcludeEntities: ['secrets'] });
             const next = vi.fn();
 
             handler.checkEntityAccess(makeReq({ params: { entityName: 'Users' } }), makeRes().res, next);
@@ -295,7 +295,7 @@ describe('RESTEndpointHandler middleware', () => {
         });
 
         it('passes through when no entityName param is present', () => {
-            const handler = makeHandler({ includeEntities: ['nothing'] });
+            const handler = makeHandler({ IncludeEntities: ['nothing'] });
             const next = vi.fn();
 
             handler.checkEntityAccess(makeReq({ params: {} }), makeRes().res, next);
@@ -565,7 +565,7 @@ describe('RESTEndpointHandler view routes', () => {
         });
 
         it('returns 403 WITHOUT invoking the view layer when every requested entity is blocked', async () => {
-            const handler = makeHandler({ includeEntities: ['users'] });
+            const handler = makeHandler({ IncludeEntities: ['users'] });
             const { res, statusCode } = makeRes();
 
             await handler.runViews(
@@ -579,7 +579,7 @@ describe('RESTEndpointHandler view routes', () => {
 
         it('silently drops blocked entities and executes only the allowed remainder', async () => {
             mockOpsRunViews.mockResolvedValue({ success: true, results: [{ Success: true, Results: [] }] });
-            const handler = makeHandler({ excludeEntities: ['secrets'] });
+            const handler = makeHandler({ ExcludeEntities: ['secrets'] });
             const req = makeReq({ body: { params: [{ EntityName: 'Users' }, { EntityName: 'Secrets' }] } });
             const { res, jsonBody } = makeRes();
 

package/src/__tests__/RealtimeBridgeResolver.test.ts

@@ -50,8 +50,10 @@ vi.mock('@memberjunction/ai-agents', () => ({
 // Mock the meeting-recording registration so the thin resolver is tested in isolation (no MJStorage /
 // core-entities graph). Its own behavior is covered by meetingRecordingRegistration.test.ts.
 vi.mock('../resolvers/meetingRecordingRegistration', () => ({
-  registerMeetingRecordingFile: vi.fn(async () => ({ Success: true, RecordingFileID: 'file-1', ConversationID: 'conv-1' })),
-  correlateRecordingStart: vi.fn(async () => true),
+  RegisterMeetingRecordingFile: vi.fn(async () => ({ Success: true, RecordingFileID: 'file-1', ConversationID: 'conv-1' })),
+    get registerMeetingRecordingFile() { return this.RegisterMeetingRecordingFile; },
+  CorrelateRecordingStart: vi.fn(async () => true),
+    get correlateRecordingStart() { return this.CorrelateRecordingStart; },
 }));
 
 import { RealtimeBridgeResolver, MintLiveKitClientTokenInput, LiveKitRecordingInput } from '../resolvers/RealtimeBridgeResolver';

package/src/__tests__/RealtimeClientSessionResolver.test.ts

@@ -3196,3 +3196,232 @@ describe('RealtimeClientSessionResolver — colleague authorization (allowedAgen
         expect(hasPermissionMock).not.toHaveBeenCalled();
     });
 });
+
+/**
+ * The other half of the voice/text context flow.
+ *
+ * Voice turns were always persisted as `MJ: Conversation Details`, so anything SAID reached a later
+ * typed turn. Nothing TYPED reached a voice session: `ConversationMessages` was a hardcoded `[]`
+ * with an MVP note. A call started mid-thread therefore opened with no idea what the thread was
+ * about — and the symptom is not an error, it is the agent asking the user to repeat something they
+ * just wrote.
+ */
+describe('RealtimeClientSessionResolver — conversation-history hydration', () => {
+    /** A `MJ: Conversation Details` row as the history query reads it. */
+    interface HistoryRow {
+        ID: string;
+        Role: string;
+        Message: string | null;
+        HiddenToUser: boolean;
+        AgentSessionID: string | null;
+    }
+
+    function row(
+        role: 'User' | 'AI' | 'Error',
+        message: string | null,
+        over: Partial<HistoryRow> = {},
+    ): HistoryRow {
+        return { ID: `h-${message ?? 'x'}`, Role: role, Message: message, HiddenToUser: false, AgentSessionID: null, ...over };
+    }
+
+    /**
+     * Provider that answers BOTH Conversation Details queries separately: the prior-leg transcript
+     * (filtered by `AgentSessionID IN (…)`) and the conversation history (`ConversationID=…`).
+     * Routing on the filter is what keeps the two from being confused for one another.
+     */
+    function makeProvider(opts: {
+        chain?: Record<string, { UserID: string; LastSessionID?: string | null }>;
+        legRows?: Array<{ ID: string; Role: string; Message: string | null; HiddenToUser: boolean }>;
+        historyRows?: HistoryRow[];
+        historyFails?: boolean;
+    }): { provider: unknown; runView: ReturnType<typeof vi.fn> } {
+        const runView = vi.fn(async (params: { EntityName: string; ExtraFilter?: string }) => {
+            if (params.EntityName === 'MJ: Conversation Details') {
+                if (params.ExtraFilter?.startsWith('AgentSessionID IN')) {
+                    return { Success: true, Results: opts.legRows ?? [] };
+                }
+                return opts.historyFails
+                    ? { Success: false, ErrorMessage: 'db down', Results: [] }
+                    : { Success: true, Results: opts.historyRows ?? [] };
+            }
+            return { Success: true, Results: [] };
+        });
+        const provider = {
+            GetEntityObject: vi.fn(async () => {
+                const entity = makeSessionEntity();
+                entity.Load = vi.fn(async (id: string) => {
+                    const r = opts.chain?.[id];
+                    if (!r) return false;
+                    entity.ID = id;
+                    entity.UserID = r.UserID;
+                    entity.LastSessionID = r.LastSessionID ?? null;
+                    return true;
+                });
+                return entity;
+            }),
+            RunView: runView,
+        };
+        return { provider, runView };
+    }
+
+    function historyArg(): Array<{ role: string; content: unknown }> {
+        return (prepareClientSessionMock.mock.calls[0][0] as { ConversationMessages: Array<{ role: string; content: unknown }> })
+            .ConversationMessages;
+    }
+
+    /** A successful prepare, so the start reaches the point where the history is threaded. */
+    const prepOk = {
+        Success: true,
+        ClientConfig: {
+            Provider: 'openai',
+            Model: 'gpt-realtime',
+            EphemeralToken: 'ek_abc',
+            ExpiresAt: '2026-01-01T00:00:00Z',
+            SessionConfig: {},
+        },
+    };
+
+    beforeEach(() => {
+        hasPermissionMock.mockResolvedValue(true);
+        createSessionMock.mockResolvedValue(makeSessionEntity({ ID: 'session-new' }));
+        prepareClientSessionMock.mockResolvedValue(prepOk);
+    });
+
+    it('hydrates the typed conversation as role-mapped chat messages', async () => {
+        const { provider } = makeProvider({
+            historyRows: [row('User', 'what does my pipeline look like'), row('AI', 'eleven open deals')],
+        });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1');
+
+        expect(historyArg()).toEqual([
+            { role: 'user', content: 'what does my pipeline look like' },
+            { role: 'assistant', content: 'eleven open deals' },
+        ]);
+    });
+
+    it('scopes the read to the session\'s conversation', async () => {
+        const { provider, runView } = makeProvider({ historyRows: [row('User', 'hi')] });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), "conv-o'brien");
+
+        const call = runView.mock.calls.find(
+            (c) => (c[0] as { ExtraFilter?: string }).ExtraFilter?.startsWith('ConversationID='),
+        );
+        // The apostrophe must be doubled, not passed through — this string is concatenated into SQL.
+        expect((call![0] as { ExtraFilter: string }).ExtraFilter).toBe("ConversationID='conv-o''brien'");
+    });
+
+    it('skips hidden rows, error rows, and empty messages', async () => {
+        const { provider } = makeProvider({
+            historyRows: [
+                row('User', 'kept'),
+                row('User', 'system anchor', { HiddenToUser: true }),
+                row('Error', 'the agent blew up'),
+                row('AI', '   '),
+                row('AI', null),
+            ],
+        });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1');
+
+        expect(historyArg()).toEqual([{ role: 'user', content: 'kept' }]);
+    });
+
+    it('KEEPS turns from an earlier voice call that is not being resumed', async () => {
+        // A call the user had last week is part of this conversation. The model should know it —
+        // only the legs framed as the resumed transcript are removed, and there are none here.
+        const { provider } = makeProvider({
+            historyRows: [row('User', 'said last week', { AgentSessionID: 'sess-old' }), row('User', 'typed today')],
+        });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1');
+
+        expect(historyArg().map((m) => m.content)).toEqual(['said last week', 'typed today']);
+    });
+
+    it('DROPS turns the resumed transcript already framed, so the prompt carries one account of them', async () => {
+        // The whole reason the leg ids travel with the prior transcript. A voice turn is an ordinary
+        // Conversation Detail, so without this the resumed leg arrives twice in one prompt.
+        const { provider } = makeProvider({
+            chain: { 'prior-1': { UserID: 'user-1' } },
+            legRows: [{ ID: 'l-1', Role: 'User', Message: 'said on the last call', HiddenToUser: false }],
+            historyRows: [
+                row('User', 'said on the last call', { AgentSessionID: 'prior-1' }),
+                row('User', 'typed afterwards'),
+            ],
+        });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1', 'prior-1');
+
+        expect(historyArg().map((m) => m.content)).toEqual(['typed afterwards']);
+        const prior = (prepareClientSessionMock.mock.calls[0][0] as { PriorTranscript?: string }).PriorTranscript;
+        expect(prior).toBe('User: said on the last call');
+    });
+
+    it('matches covered session ids case-insensitively', async () => {
+        // SQL Server returns uppercase ids and PostgreSQL lowercase; a case-sensitive compare would
+        // double-inject the resumed leg on one of the two.
+        const { provider } = makeProvider({
+            chain: { 'PRIOR-1': { UserID: 'user-1' } },
+            legRows: [{ ID: 'l-1', Role: 'User', Message: 'said on the last call', HiddenToUser: false }],
+            historyRows: [row('User', 'said on the last call', { AgentSessionID: 'prior-1' })],
+        });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1', 'PRIOR-1');
+
+        expect(historyArg()).toEqual([]);
+    });
+
+    it('keeps only the NEWEST turns when the conversation is long', async () => {
+        const many = Array.from({ length: 45 }, (_, i) => row('User', `turn ${i}`, { ID: `h-${i}` }));
+        const { provider } = makeProvider({ historyRows: many });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1');
+
+        const history = historyArg();
+        expect(history).toHaveLength(30);
+        expect(history[0].content).toBe('turn 15');
+        expect(history[29].content).toBe('turn 44');
+    });
+
+    it('drops the OLDEST turns first when the character budget is exceeded', async () => {
+        // 5 turns x 3000 chars = 15000, over the 8000 budget: the freshest context is what survives.
+        const big = Array.from({ length: 5 }, (_, i) => row('User', `${i}`.repeat(3000), { ID: `h-${i}` }));
+        const { provider } = makeProvider({ historyRows: big });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1');
+
+        const history = historyArg();
+        expect(history).toHaveLength(2);
+        expect(String(history[1].content).startsWith('4')).toBe(true);
+    });
+
+    it('starts the session COLD rather than failing when the history read fails', async () => {
+        const { provider } = makeProvider({ historyFails: true });
+        currentProvider = provider;
+
+        const result = await makeResolver().StartRealtimeClientSession('target-1', makeCtx(), 'conv-1');
+
+        expect(result.AgentSessionId).toBe('session-new');
+        expect(historyArg()).toEqual([]);
+    });
+
+    it('passes an empty history, and runs no query, when the session has no conversation', async () => {
+        const { provider, runView } = makeProvider({ historyRows: [row('User', 'should never be read')] });
+        currentProvider = provider;
+
+        await makeResolver().StartRealtimeClientSession('target-1', makeCtx());
+
+        expect(historyArg()).toEqual([]);
+        expect(runView.mock.calls.some((c) => (c[0] as { ExtraFilter?: string }).ExtraFilter?.startsWith('ConversationID='))).toBe(false);
+    });
+});

package/src/__tests__/RealtimeSdpBrokerHandler.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import type { Request, Response, NextFunction } from 'express';
 import { MJGlobal, RegisterClass } from '@memberjunction/global';
 import { BaseRealtimeModel, RealtimeProxyRegistry, IRealtimeSession, RealtimeSessionParams } from '@memberjunction/ai';
-import { createRealtimeSdpBrokerRouter, createOpenAILiveBrokerRouter, requireTicket } from '../rest/RealtimeSdpBrokerHandler.js';
+import { CreateRealtimeSdpBrokerRouter, createOpenAILiveBrokerRouter, RequireTicket } from '../rest/RealtimeSdpBrokerHandler.js';
 
 @RegisterClass(BaseRealtimeModel, 'MockOpenAILiveForBrokerTest', 10)
 class MockOpenAILiveForBrokerTest extends BaseRealtimeModel {
@@ -67,20 +67,20 @@ function makeMockReqRes(query: Record<string, string>, body: unknown): {
 }
 
 describe('RealtimeSdpBrokerHandler', () => {
-    let router: ReturnType<typeof createRealtimeSdpBrokerRouter>;
+    let router: ReturnType<typeof CreateRealtimeSdpBrokerRouter>;
 
     beforeEach(() => {
-        router = createRealtimeSdpBrokerRouter();
+        router = CreateRealtimeSdpBrokerRouter();
     });
 
     it('createOpenAILiveBrokerRouter is backwards-compatible alias', () => {
-        expect(createOpenAILiveBrokerRouter).toBe(createRealtimeSdpBrokerRouter);
+        expect(createOpenAILiveBrokerRouter).toBe(CreateRealtimeSdpBrokerRouter);
     });
 
     it('requireTicket middleware rejects missing ticket without calling next()', () => {
         const { req, res, getStatus, getJson } = makeMockReqRes({}, {});
         const next = vi.fn();
-        requireTicket(req, res, next as NextFunction);
+        RequireTicket(req, res, next as NextFunction);
         expect(getStatus()).toBe(401);
         expect(getJson().error).toContain('missing ticket');
         expect(next).not.toHaveBeenCalled();
@@ -89,7 +89,7 @@ describe('RealtimeSdpBrokerHandler', () => {
     it('requireTicket middleware rejects invalid ticket without calling next()', () => {
         const { req, res, getStatus, getJson } = makeMockReqRes({ ticket: 'non-existent-ticket' }, {});
         const next = vi.fn();
-        requireTicket(req, res, next as NextFunction);
+        RequireTicket(req, res, next as NextFunction);
         expect(getStatus()).toBe(401);
         expect(getJson().error).toContain('invalid or expired ticket');
         expect(next).not.toHaveBeenCalled();

package/src/__tests__/RefreshAdoptsNewColumns.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { decideFieldMapReconcile } from '../integration/EntityMapLifecycle.js';
+import { DecideFieldMapReconcile } from '../integration/EntityMapLifecycle.js';
 
 /**
  * A REFRESH adopts the source's current shape: new objects and new columns both arrive ENABLED.
@@ -17,20 +17,20 @@ const fm = (SourceFieldName: string, Status: string) => ({ SourceFieldName, Stat
 
 describe('decideFieldMapReconcile — a refresh adopts new columns', () => {
     it('creates a new column ENABLED on an enabled map, by default', () => {
-        const plan = decideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true);
+        const plan = DecideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true);
         expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Active' }]);
         expect(plan.Enable).toEqual([]);
         expect(plan.Disable).toEqual([]);
     });
 
     it('autoEnableNewColumns:false gates it for a connection that wants to review first', () => {
-        const plan = decideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true, false);
+        const plan = DecideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true, false);
         expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Inactive' }]);
     });
 
     it('a DISABLED map never gets an Active column — the map always bounds the column', () => {
         // Adopting new columns must not resurrect a map the user switched off.
-        const plan = decideFieldMapReconcile(['brand_new_col'], [], false, true);
+        const plan = DecideFieldMapReconcile(['brand_new_col'], [], false, true);
         expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Inactive' }]);
     });
 });
@@ -40,24 +40,24 @@ describe('decideFieldMapReconcile — retiring and restoring are both non-destru
         // That row is not new — it was disabled because the source stopped reporting the column, so
         // it returns to the state it had. Gating it would silently demote a column the user chose to
         // sync whenever the source flickered.
-        const plan = decideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], true, false);
+        const plan = DecideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], true, false);
         expect(plan.Enable).toEqual(['came_back']);
         expect(plan.Create).toEqual([]);   // reuses the row, never mints a second one
     });
 
     it('a column absent from the resolution is DISABLED, never deleted', () => {
-        const plan = decideFieldMapReconcile(['kept'], [fm('kept', 'Active'), fm('vanished', 'Active')], true);
+        const plan = DecideFieldMapReconcile(['kept'], [fm('kept', 'Active'), fm('vanished', 'Active')], true);
         expect(plan.Disable).toEqual(['vanished']);
         expect(plan.Enable).toEqual([]);   // survivor untouched
     });
 
     it('does not re-enable anything while the map itself is disabled', () => {
-        const plan = decideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], false);
+        const plan = DecideFieldMapReconcile(['came_back'], [fm('came_back', 'Inactive')], false);
         expect(plan.Enable).toEqual([]);
     });
 
     it('matches source field names case-insensitively on both sides', () => {
-        const plan = decideFieldMapReconcile(['ID', 'Name'], [fm('id', 'Active'), fm('name', 'Active')], true);
+        const plan = DecideFieldMapReconcile(['ID', 'Name'], [fm('id', 'Active'), fm('name', 'Active')], true);
         expect(plan.Create).toEqual([]);
         expect(plan.Disable).toEqual([]);
     });

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();
   });
 });