@memberjunction/server 6.1.4 → 6.2.0-edge.1

package/src/resolvers/MCPResolver.ts

@@ -19,7 +19,7 @@ import {
 } from '@memberjunction/ai-mcp-client';
 import { AppContext } from '../types.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { publishStatusUpdate } from '../generic/PushStatusResolver.js';
+import { PublishStatusUpdate } from '../generic/PushStatusResolver.js';
 import { GraphQLJSONObject } from 'graphql-type-json';
 import { configInfo } from '../config.js';
 
@@ -493,13 +493,13 @@ export class MCPToolSummary {
 @ObjectType()
 export class MCPToolPageResult {
     @Field(() => [MCPToolSummary])
-    items: MCPToolSummary[];
+    items: MCPToolSummary[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    totalCount: number;
+    totalCount: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    hasMore: boolean;
+    hasMore: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -508,13 +508,13 @@ export class MCPToolPageResult {
 @ObjectType()
 export class MCPToolServerCount {
     @Field()
-    serverID: string;
+    serverID: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field()
-    serverName: string;
+    serverName: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    count: number;
+    count: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -524,10 +524,10 @@ export class MCPToolServerCount {
 @ObjectType()
 export class MCPToolCategoryCount {
     @Field()
-    category: string;
+    category: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => Int)
-    count: number;
+    count: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -536,13 +536,13 @@ export class MCPToolCategoryCount {
 @ObjectType()
 export class MCPToolCountsResult {
     @Field(() => Int)
-    totalCount: number;
+    totalCount: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => [MCPToolServerCount])
-    countByServer: MCPToolServerCount[];
+    countByServer: MCPToolServerCount[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
     @Field(() => [MCPToolCategoryCount])
-    countByCategory: MCPToolCategoryCount[];
+    countByCategory: MCPToolCategoryCount[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 /**
@@ -1247,7 +1247,7 @@ export class MCPResolver extends ResolverBase {
      * @returns OAuth event notification
      */
     @Subscription(() => MCPOAuthEventNotification, { topics: MCP_OAUTH_EVENTS_TOPIC })
-    onMCPOAuthEvent(
+    onMCPOAuthEvent(  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
         @Root() payload: MCPOAuthEventPayload
     ): MCPOAuthEventNotification {
         return {
@@ -1361,7 +1361,7 @@ export class MCPResolver extends ResolverBase {
             result
         };
 
-        publishStatusUpdate(pubSub, { sessionId, ownerUserId, message: JSON.stringify(progressMessage) });
+        PublishStatusUpdate(pubSub, { sessionId, ownerUserId, message: JSON.stringify(progressMessage) });
     }
 
     /**
@@ -1653,7 +1653,7 @@ export class MCPResolver extends ResolverBase {
  * @param pubSub - PubSub engine
  * @param event - OAuth event details
  */
-export async function publishMCPOAuthEvent(
+export async function PublishMCPOAuthEvent(
     pubSub: PubSubEngine,
     event: {
         eventType: MCPOAuthEventType;
@@ -1676,3 +1676,18 @@ export async function publishMCPOAuthEvent(
 
     await pubSub.publish(MCP_OAUTH_EVENTS_TOPIC, payload);
 }
+
+/** @deprecated Use {@link PublishMCPOAuthEvent}. */
+export async function publishMCPOAuthEvent(
+    pubSub: PubSubEngine,
+    event: {
+        eventType: MCPOAuthEventType;
+        connectionId: string;
+        authorizationUrl?: string;
+        stateParameter?: string;
+        errorMessage?: string;
+        requiresReauthorization?: boolean;
+    }
+): Promise<void> {
+    return PublishMCPOAuthEvent(pubSub, event);
+}

package/src/resolvers/QueryResolver.ts

@@ -97,34 +97,34 @@ export class RunQueryResultType {
 @InputType()
 export class RunQueryCacheStatusInput {
   @Field(() => String, { description: 'The maximum __mj_UpdatedAt value from cached results' })
-  maxUpdatedAt: string;
+  maxUpdatedAt: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int, { description: 'The number of rows in cached results' })
-  rowCount: number;
+  rowCount: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @InputType()
 export class RunQueryWithCacheCheckInput {
   @Field(() => RunQueryInput, { description: 'The RunQuery parameters' })
-  params: RunQueryInput;
+  params: RunQueryInput;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => RunQueryCacheStatusInput, {
     nullable: true,
     description: 'Optional cache status - if provided, server will check if cache is current'
   })
-  cacheStatus?: RunQueryCacheStatusInput;
+  cacheStatus?: RunQueryCacheStatusInput;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class RunQueryWithCacheCheckResultOutput {
   @Field(() => Int, { description: 'The index of this query in the batch request' })
-  queryIndex: number;
+  queryIndex: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { description: 'The query ID' })
-  queryId: string;
+  queryId: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { description: "'current', 'stale', 'no_validation', or 'error'" })
-  status: string;
+  status: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, {
     nullable: true,
@@ -133,25 +133,25 @@ export class RunQueryWithCacheCheckResultOutput {
   Results?: string;
 
   @Field(() => String, { nullable: true, description: 'Max __mj_UpdatedAt from results when stale' })
-  maxUpdatedAt?: string;
+  maxUpdatedAt?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => Int, { nullable: true, description: 'Row count of results when stale' })
-  rowCount?: number;
+  rowCount?: number;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true, description: 'Error message if status is error' })
-  errorMessage?: string;
+  errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @ObjectType()
 export class RunQueriesWithCacheCheckOutput {
   @Field(() => Boolean, { description: 'Whether the overall operation succeeded' })
-  success: boolean;
+  success: boolean;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => [RunQueryWithCacheCheckResultOutput], { description: 'Results for each query in the batch' })
-  results: RunQueryWithCacheCheckResultOutput[];
+  results: RunQueryWithCacheCheckResultOutput[];  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 
   @Field(() => String, { nullable: true, description: 'Overall error message if success is false' })
-  errorMessage?: string;
+  errorMessage?: string;  // case-violation-ok-legacy-back-compat: the property name is the GraphQL schema field name — renaming it breaks every client query
 }
 
 @Resolver()

package/src/resolvers/QuerySystemUserResolver.ts

@@ -6,6 +6,7 @@ import { MJQueryResolver, MJQuery_, MJQueryField_, MJQueryParameter_, MJQueryEnt
 import { GetReadWriteProvider } from '../util.js';
 import { DeleteOptionsInput } from '../generic/DeleteOptionsInput.js';
 import { MJQueryEntityServer } from '@memberjunction/core-entities-server';
+import { EscapeSQLString } from '@memberjunction/global';
 
 /**
  * Minimal shape of a query row returned by RunView lookups (plain object, not entity instance).
@@ -493,7 +494,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             // now make sure there is NO existing query by the same name in the specified category
             const existingQueryResult = await provider.RunView({
                 EntityName: 'MJ: Queries',
-                ExtraFilter: `Name='${input.Name}' AND CategoryID='${finalCategoryID}'` 
+                ExtraFilter: `Name='${EscapeSQLString(input.Name)}' AND CategoryID='${EscapeSQLString(finalCategoryID)}'`
             }, context.userPayload.userRecord);
             if (existingQueryResult.Success && existingQueryResult.Results?.length > 0) {
                 // we have a match! Let's return an error

package/src/resolvers/RealtimeBridgeResolver.ts

@@ -9,7 +9,7 @@ import { CreateBridgeRealtimeSession, FinalizeBridgeCoAgentRuns, GetRealtimeMode
 import { AIBridgeEngine } from '@memberjunction/ai-bridge-server';
 import { SessionManager } from '../agentSessions/SessionManager.js';
 import { NotificationEngine } from '@memberjunction/notifications';
-import { registerMeetingRecordingFile, correlateRecordingStart } from './meetingRecordingRegistration.js';
+import { RegisterMeetingRecordingFile, CorrelateRecordingStart } from './meetingRecordingRegistration.js';
 
 /**
  * Binds the agent realtime-session factory onto the LiveKit room coordinator's model-session creation seam.
@@ -458,7 +458,7 @@ export class RealtimeBridgeResolver extends ResolverBase {
       // Best-effort: correlate the live recording with the room's Meeting-Room Conversation (if it exists
       // yet) by stamping its EgressID. Never fail the start on this — the stop-flow resolves/creates it.
       const provider = GetReadWriteProvider(context.providers) as unknown as IMetadataProvider;
-      void correlateRecordingStart(input.RoomName, info.EgressID, user, provider);
+      void CorrelateRecordingStart(input.RoomName, info.EgressID, user, provider);
 
       return { Success: true, EgressID: info.EgressID, Status: info.Status };
     } catch (error) {
@@ -487,7 +487,7 @@ export class RealtimeBridgeResolver extends ResolverBase {
       // Register the completed egress MP4 as a Files row on the Meeting-Room Conversation. Best-effort:
       // any failure (e.g. storage provider not configured) leaves RecordingFileID unset but still
       // returns the successful stop result.
-      const registration = await registerMeetingRecordingFile(
+      const registration = await RegisterMeetingRecordingFile(
         { EgressID: info.EgressID, RoomName: info.RoomName, OutputLocation: info.OutputLocation, OutputSizeBytes: info.OutputSizeBytes },
         user,
         provider,

package/src/resolvers/RealtimeClientSessionResolver.ts

@@ -57,12 +57,12 @@ import {
     deleteRealtimeRecordingSegments,
 } from '@memberjunction/ai-agents';
 import { AgentExecutionProgressCallback, MJAIAgentEntityExtended, AppContextSnapshot } from '@memberjunction/ai-core-plus';
-import { RealtimeToolDefinition } from '@memberjunction/ai';
+import { ChatMessage, RealtimeToolDefinition } from '@memberjunction/ai';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
 import { GetReadWriteProvider } from '../util.js';
 import { SessionManager } from '../agentSessions/index.js';
-import { resolveWidgetGuestRunContext, ResolveScopedAnonymousRunUser } from '../realtimeWidget/widgetGuestElevation.js';
+import { ResolveWidgetGuestRunContext, ResolveScopedAnonymousRunUser } from '../realtimeWidget/widgetGuestElevation.js';
 
 /**
  * Progress steps worth narrating to the realtime model — mirrors the normal agent-run path's filter
@@ -136,6 +136,11 @@ const MAX_PRIOR_TRANSCRIPT_CHARS = 8_000;
 /** Maximum prior-session chain legs walked when hydrating a resumed session's transcript. */
 const MAX_PRIOR_TRANSCRIPT_LEGS = 5;
 
+/** Maximum TEXT-conversation turns hydrated into a voice session's companion prompt (newest kept). */
+const MAX_CONVERSATION_HISTORY_TURNS = 30;
+/** Maximum TEXT-conversation CHARS hydrated into a voice session's companion prompt (oldest dropped). */
+const MAX_CONVERSATION_HISTORY_CHARS = 8_000;
+
 /**
  * Authoritative shape persisted in `AIAgentSession.Config_` for a client-direct voice session.
  * The target agent id is stored here at start and read back on every relay — the browser never
@@ -486,10 +491,17 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         // Best-effort model-context hydration: the PRIOR session chain's transcript (ownership-
         // checked, capped) is framed into the system prompt so the model REMEMBERS the last leg.
         // Strictly tolerant — any problem yields no hydration, never a failed start.
-        const priorTranscript = await this.loadPriorTranscript(lastSessionId, contextUser, provider);
+        const prior = await this.loadPriorTranscript(lastSessionId, contextUser, provider);
+        // ...and the TEXT conversation the call is being started from, so a voice session opened
+        // mid-thread knows what was already typed. The legs above are excluded: they are already
+        // framed as the resumed transcript, and injecting the same turns twice puts two accounts of
+        // the same exchange in one prompt.
+        const conversationMessages = await this.loadConversationHistory(
+            conversationId, prior?.LegIDs ?? [], contextUser, provider,
+        );
         const result = await this.prepareClientSessionOrClose(
-            session, coAgentID, effectiveTargetId, contextUser, provider, preferredModelId, clientTools, priorTranscript,
-            configOverridesJson, maxSessionSeconds, applicationId, this.parseAppContext(appContextJson),
+            session, coAgentID, effectiveTargetId, contextUser, provider, preferredModelId, clientTools, prior?.Text,
+            configOverridesJson, maxSessionSeconds, applicationId, this.parseAppContext(appContextJson), conversationMessages,
         );
         // Best-effort restore of the PRIOR session's persisted channel states (e.g. the whiteboard
         // board). Strictly tolerant — any problem yields a null field, never a failed start.
@@ -1684,6 +1696,8 @@ export class RealtimeClientSessionResolver extends ResolverBase {
      * @param priorTranscript Optional capped, role-tagged transcript of the PRIOR session chain
      *   (from {@link loadPriorTranscript}) — the service frames it into the system prompt so a
      *   resumed session remembers the previous leg(s).
+     * @param conversationMessages Optional capped history of the TEXT conversation this session is
+     *   starting from (from {@link loadConversationHistory}) — framed as "Conversation so far".
      */
     private async prepareClientSessionOrClose(
         session: MJAIAgentSessionEntity,
@@ -1698,6 +1712,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         maxSessionSeconds?: number,
         applicationId?: string,
         appContext?: AppContextSnapshot,
+        conversationMessages?: ChatMessage[],
     ): Promise<StartRealtimeClientSessionResult> {
         const prep = await this.clientSessionService.PrepareClientSession(
             {
@@ -1708,10 +1723,10 @@ export class RealtimeClientSessionResolver extends ResolverBase {
                 // Server-authoritative voice duration cap (widget guests) — bounds the driver session
                 // where supported; the janitor enforces the session deadline regardless.
                 MaxSessionSeconds: maxSessionSeconds,
-                // MVP: conversation history is not yet hydrated into ChatMessage[]; the co-agent
-                // companion prompt runs without prior turns. A later phase loads the session's
-                // Conversation into ChatMessage[] for richer context.
-                ConversationMessages: [],
+                // The TEXT conversation this call was started from, so the co-agent opens knowing
+                // what the user already typed rather than asking them to say it again. Hydrated by
+                // `loadConversationHistory`; empty when there is no conversation or the read failed.
+                ConversationMessages: conversationMessages ?? [],
                 UserID: contextUser.ID,
                 PreferredModelID: preferredModelId,
                 // Client-declared, CLIENT-EXECUTED UI tools (see the mutation's SECURITY NOTE) —
@@ -2005,7 +2020,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         lastSessionId: string | undefined,
         contextUser: UserInfo,
         provider: IMetadataProvider,
-    ): Promise<string | undefined> {
+    ): Promise<{ Text: string; LegIDs: string[] } | undefined> {
         if (!lastSessionId) {
             return undefined;
         }
@@ -2016,7 +2031,10 @@ export class RealtimeClientSessionResolver extends ResolverBase {
             }
             const turns = await this.loadChainTranscriptTurns(legIDs, contextUser, provider);
             const lines = this.capTranscriptLines(turns);
-            return lines.length > 0 ? lines.join('\n') : undefined;
+            // The leg ids travel with the text because the CONVERSATION history hydrated alongside
+            // this would otherwise re-inject the same turns: a voice turn is persisted as an
+            // ordinary Conversation Detail, so these legs are part of the conversation too.
+            return lines.length > 0 ? { Text: lines.join('\n'), LegIDs: legIDs } : undefined;
         } catch (error) {
             LogError(
                 `StartRealtimeClientSession: prior-transcript hydration failed for session ${lastSessionId}: ${(error as Error).message}`,
@@ -2025,6 +2043,101 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         }
     }
 
+    /**
+     * Loads the conversation this voice session is starting from, as `ChatMessage[]` for the
+     * co-agent's companion prompt.
+     *
+     * This is the half of the context flow that was missing. Voice turns have always been
+     * persisted as `MJ: Conversation Details`, so anything SAID reaches a later text turn — but
+     * nothing TYPED reached a voice session, which opened with no idea what the thread was about.
+     * The symptom is not an error; it is the agent asking the user to repeat something they just
+     * wrote, which is exactly when voice is least forgivable.
+     *
+     * Caps mirror the resume path (newest {@link MAX_CONVERSATION_HISTORY_TURNS} turns, then a
+     * {@link MAX_CONVERSATION_HISTORY_CHARS} budget with the oldest dropped first) so the freshest
+     * context always survives.
+     *
+     * Session-stamped rows are KEPT unless `coveredSessionIDs` names them: a call the user had last
+     * week is part of this conversation and the model should know it. Only the legs already framed
+     * as the resumed transcript are removed, so the prompt never carries two accounts of one
+     * exchange.
+     *
+     * Strictly tolerant — no conversation, a failed read, or any throw yields `[]`, never a failed
+     * session start. The call still works; it just starts cold.
+     *
+     * @param conversationId The conversation the session is bound to, when there is one.
+     * @param coveredSessionIDs Session ids already framed via `PriorTranscript`.
+     * @param contextUser The calling user (RunView scope — the read is row-level-secured).
+     * @param provider The request-scoped metadata provider.
+     * @returns The capped history, oldest first.
+     */
+    private async loadConversationHistory(
+        conversationId: string | undefined,
+        coveredSessionIDs: string[],
+        contextUser: UserInfo,
+        provider: IMetadataProvider,
+    ): Promise<ChatMessage[]> {
+        if (!conversationId) {
+            return [];
+        }
+        try {
+            const rv = RunView.FromMetadataProvider(provider);
+            const result = await rv.RunView<{
+                Role: string;
+                Message: string | null;
+                HiddenToUser: boolean;
+                AgentSessionID: string | null;
+            }>(
+                {
+                    EntityName: CONVERSATION_DETAIL_ENTITY,
+                    ExtraFilter: `ConversationID='${conversationId.replace(/'/g, "''")}'`,
+                    Fields: ['ID', 'Role', 'Message', 'HiddenToUser', 'AgentSessionID', '__mj_CreatedAt'],
+                    OrderBy: '__mj_CreatedAt ASC',
+                    ResultType: 'simple',
+                },
+                contextUser,
+            );
+            if (!result.Success) {
+                LogError(`StartRealtimeClientSession: conversation-history query failed: ${result.ErrorMessage}`);
+                return [];
+            }
+            const covered = new Set(coveredSessionIDs.map((id) => id.trim().toLowerCase()));
+            const turns = (result.Results ?? []).filter(
+                (row) =>
+                    !row.HiddenToUser &&
+                    (row.Role === 'User' || row.Role === 'AI') &&
+                    typeof row.Message === 'string' &&
+                    row.Message.trim().length > 0 &&
+                    !covered.has((row.AgentSessionID ?? '').trim().toLowerCase()),
+            );
+            return this.capConversationHistory(turns);
+        } catch (error) {
+            LogError(
+                `StartRealtimeClientSession: conversation-history hydration failed for conversation ${conversationId}: ${(error as Error).message}`,
+            );
+            return [];
+        }
+    }
+
+    /**
+     * Applies the history caps and maps to `ChatMessage[]`: the newest
+     * {@link MAX_CONVERSATION_HISTORY_TURNS} turns, then a total budget of
+     * {@link MAX_CONVERSATION_HISTORY_CHARS} characters with the oldest dropped first.
+     */
+    private capConversationHistory(turns: Array<{ Role: string; Message: string | null }>): ChatMessage[] {
+        const newest = turns.slice(-MAX_CONVERSATION_HISTORY_TURNS);
+        const messages: ChatMessage[] = newest.map((t) => ({
+            role: t.Role === 'AI' ? 'assistant' : 'user',
+            content: (t.Message ?? '').trim(),
+        }));
+        let total = messages.reduce((sum, m) => sum + String(m.content).length + 1, 0);
+        while (messages.length > 0 && total > MAX_CONVERSATION_HISTORY_CHARS) {
+            const dropped = messages.shift() as ChatMessage;
+            total -= String(dropped.content).length + 1;
+        }
+        return messages;
+    }
+
     /**
      * Walks the prior-session chain backwards from `lastSessionId`, returning the OWNED leg ids
      * (newest first). The first leg must exist and be owned by the caller, else `[]` (logged);
@@ -2555,8 +2668,8 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         userPayload: UserPayload,
         providers: AppContext['providers'],
     ): Promise<number | undefined> {
-        const elevation = await resolveWidgetGuestRunContext(userPayload, GetReadWriteProvider(providers));
-        const minutes = elevation?.widget.VoiceMaxSessionMinutes;
+        const elevation = await ResolveWidgetGuestRunContext(userPayload, GetReadWriteProvider(providers));
+        const minutes = elevation?.Widget.VoiceMaxSessionMinutes;
         return minutes && minutes > 0 ? minutes * 60 : undefined;
     }
 

package/src/resolvers/RemoteBrowserActionResolver.ts

@@ -22,7 +22,7 @@ import { UserInfo, IMetadataProvider, LogError } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
 import { MJAIAgentSessionEntity, MJAIAgentEntity } from '@memberjunction/core-entities';
 import { NormalizeInstanceKey, RemoteBrowserEngine } from '@memberjunction/remote-browser-server';
-import { beginBrowserGoalStep, finalizeBrowserGoalStep, extractCoAgentRunID } from '../agentSessions/remoteBrowserGoalEngine.js';
+import { BeginBrowserGoalStep, FinalizeBrowserGoalStep, ExtractCoAgentRunID } from '../agentSessions/remoteBrowserGoalEngine.js';
 import { RemoteBrowserGoalRegistry } from '../agentSessions/remoteBrowserGoalRegistry.js';
 import { randomUUID } from 'node:crypto';
 import {
@@ -400,8 +400,8 @@ export class RemoteBrowserActionResolver extends ResolverBase {
     const providerName = await this.resolveProviderName(session, contextUser, provider);
     // Observability: nest this goal's many prompt runs under ONE "Browser goal" step on the realtime
     // co-agent run (when the session has one). Best-effort — a null step just means the goal runs unlinked.
-    const coAgentRunID = extractCoAgentRunID(session.Config_);
-    const goalStep = await beginBrowserGoalStep(provider, contextUser, coAgentRunID, goal);
+    const coAgentRunID = ExtractCoAgentRunID(session.Config_);
+    const goalStep = await BeginBrowserGoalStep(provider, contextUser, coAgentRunID, goal);
 
     // ASYNC START: a goal loop can run for minutes; do NOT hold this request open for it (browser
     // fetch / proxy / janitor timeouts would kill the request while the loop runs on, and the agent
@@ -420,14 +420,14 @@ export class RemoteBrowserActionResolver extends ResolverBase {
       AgentRunStepID: goalStep?.ID,
     })
       .then(async (result) => {
-        await finalizeBrowserGoalStep(goalStep, result);
+        await FinalizeBrowserGoalStep(goalStep, result);
         RemoteBrowserGoalRegistry.Instance.Complete(agentSessionID, goalRunID, result);
       })
       .catch(async (err) => {
         const message = err instanceof Error ? err.message : String(err);
         LogError(`ExecuteRemoteBrowserGoal failed (provider='${providerName}'): ${message}`);
         const failure = { Success: false, Status: 'Error', Detail: `Remote browser error (${providerName}): ${message}` };
-        await finalizeBrowserGoalStep(goalStep, failure);
+        await FinalizeBrowserGoalStep(goalStep, failure);
         RemoteBrowserGoalRegistry.Instance.Complete(agentSessionID, goalRunID, failure);
       });