@memberjunction/server 5.42.0 → 5.44.0

package/src/resolvers/QueryResolver.ts

@@ -1,5 +1,5 @@
 import { Arg, Ctx, ObjectType, Query, Resolver, Field, Int, InputType } from 'type-graphql';
-import { RunQuery, IRunQueryProvider, IMetadataProvider, RunQueryParams, LogError, RunQueryWithCacheCheckParams, RunQueriesWithCacheCheckResponse, RunQueryWithCacheCheckResult } from '@memberjunction/core';
+import { RunQuery, IRunQueryProvider, IMetadataProvider, RunQueryParams, LogError, RunQueryWithCacheCheckParams, RunQueriesWithCacheCheckResponse, RunQueryWithCacheCheckResult, RunQueryEnrichment } from '@memberjunction/core';
 import { AppContext } from '../types.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GraphQLJSONObject } from 'graphql-type-json';
@@ -40,6 +40,9 @@ export class RunQueryInput {
 
   @Field(() => String, { nullable: true, description: 'Description to use in audit log' })
   AuditLogDescription?: string;
+
+  @Field(() => GraphQLJSONObject, { nullable: true, description: 'Optional runtime-only directive to post-process result rows through a registered query result enricher ({ EnricherKey, Config })' })
+  Enrichment?: RunQueryEnrichment;
 }
 
 @ObjectType()
@@ -191,7 +194,8 @@ export class RunQueryResolver extends ResolverBase {
                      @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                      @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                      @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
-                     @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
+                     @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string,
+                     @Arg('Enrichment', () => GraphQLJSONObject, {nullable: true}) Enrichment?: RunQueryEnrichment): Promise<RunQueryResultType> {
     // Check API key scope authorization for query execution
     await this.CheckAPIKeyScopeAuthorization('query:run', QueryID, context.userPayload);
 
@@ -200,7 +204,7 @@ export class RunQueryResolver extends ResolverBase {
     const rq = new RunQuery(provider as unknown as IRunQueryProvider);
     console.log('GetQueryData called with:', { QueryID, Parameters, MaxRows, StartRow, ForceAuditLog, AuditLogDescription });
     const result = await rq.RunQuery(
-      { 
+      {
         QueryID: QueryID,
         CategoryID: CategoryID,
         CategoryPath: CategoryPath,
@@ -208,8 +212,9 @@ export class RunQueryResolver extends ResolverBase {
         MaxRows: MaxRows,
         StartRow: StartRow,
         ForceAuditLog: ForceAuditLog,
-        AuditLogDescription: AuditLogDescription
-      }, 
+        AuditLogDescription: AuditLogDescription,
+        Enrichment: Enrichment
+      },
       context.userPayload.userRecord);
     console.log('RunQuery result:', { 
       Success: result.Success, 
@@ -256,22 +261,24 @@ export class RunQueryResolver extends ResolverBase {
                            @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                            @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                            @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
-                           @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
+                           @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string,
+                           @Arg('Enrichment', () => GraphQLJSONObject, {nullable: true}) Enrichment?: RunQueryEnrichment): Promise<RunQueryResultType> {
     // Check API key scope authorization for query execution
     await this.CheckAPIKeyScopeAuthorization('query:run', QueryName, context.userPayload);
 
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
     const rq = new RunQuery(provider as unknown as IRunQueryProvider);
     const result = await rq.RunQuery(
-      { 
-        QueryName: QueryName, 
+      {
+        QueryName: QueryName,
         CategoryID: CategoryID,
         CategoryPath: CategoryPath,
         Parameters: Parameters,
         MaxRows: MaxRows,
         StartRow: StartRow,
         ForceAuditLog: ForceAuditLog,
-        AuditLogDescription: AuditLogDescription
+        AuditLogDescription: AuditLogDescription,
+        Enrichment: Enrichment
       },
       context.userPayload.userRecord);
       
@@ -302,13 +309,14 @@ export class RunQueryResolver extends ResolverBase {
                                @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                                @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                                @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
-                               @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
+                               @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string,
+                               @Arg('Enrichment', () => GraphQLJSONObject, {nullable: true}) Enrichment?: RunQueryEnrichment): Promise<RunQueryResultType> {
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
     const md = provider as unknown as IMetadataProvider;
     const rq = new RunQuery(provider as unknown as IRunQueryProvider);
 
     const result = await rq.RunQuery(
-      { 
+      {
         QueryID: QueryID,
         CategoryID: CategoryID,
         CategoryPath: CategoryPath,
@@ -316,8 +324,9 @@ export class RunQueryResolver extends ResolverBase {
         MaxRows: MaxRows,
         StartRow: StartRow,
         ForceAuditLog: ForceAuditLog,
-        AuditLogDescription: AuditLogDescription
-      }, 
+        AuditLogDescription: AuditLogDescription,
+        Enrichment: Enrichment
+      },
       context.userPayload.userRecord);
     
     // If QueryName is not populated by the provider, use efficient lookup
@@ -360,12 +369,13 @@ export class RunQueryResolver extends ResolverBase {
                                      @Arg('MaxRows', () => Int, {nullable: true}) MaxRows?: number,
                                      @Arg('StartRow', () => Int, {nullable: true}) StartRow?: number,
                                      @Arg('ForceAuditLog', () => Boolean, {nullable: true}) ForceAuditLog?: boolean,
-                                     @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string): Promise<RunQueryResultType> {
+                                     @Arg('AuditLogDescription', () => String, {nullable: true}) AuditLogDescription?: string,
+                                     @Arg('Enrichment', () => GraphQLJSONObject, {nullable: true}) Enrichment?: RunQueryEnrichment): Promise<RunQueryResultType> {
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true});
     const rq = new RunQuery(provider as unknown as IRunQueryProvider);
 
     const result = await rq.RunQuery(
-      { 
+      {
         QueryName: QueryName,
         CategoryID: CategoryID,
         CategoryPath: CategoryPath,
@@ -373,8 +383,9 @@ export class RunQueryResolver extends ResolverBase {
         MaxRows: MaxRows,
         StartRow: StartRow,
         ForceAuditLog: ForceAuditLog,
-        AuditLogDescription: AuditLogDescription
-      }, 
+        AuditLogDescription: AuditLogDescription,
+        Enrichment: Enrichment
+      },
       context.userPayload.userRecord);
     
     return {
@@ -420,7 +431,8 @@ export class RunQueryResolver extends ResolverBase {
       MaxRows: i.MaxRows,
       StartRow: i.StartRow,
       ForceAuditLog: i.ForceAuditLog,
-      AuditLogDescription: i.AuditLogDescription
+      AuditLogDescription: i.AuditLogDescription,
+      Enrichment: i.Enrichment
     }));
 
     // Execute all queries in parallel using the batch method
@@ -469,7 +481,8 @@ export class RunQueryResolver extends ResolverBase {
       MaxRows: i.MaxRows,
       StartRow: i.StartRow,
       ForceAuditLog: i.ForceAuditLog,
-      AuditLogDescription: i.AuditLogDescription
+      AuditLogDescription: i.AuditLogDescription,
+      Enrichment: i.Enrichment
     }));
 
     // Execute all queries in parallel using the batch method
@@ -532,6 +545,7 @@ export class RunQueryResolver extends ResolverBase {
           StartRow: item.params.StartRow,
           ForceAuditLog: item.params.ForceAuditLog,
           AuditLogDescription: item.params.AuditLogDescription,
+          Enrichment: item.params.Enrichment,
         },
         cacheStatus: item.cacheStatus ? {
           maxUpdatedAt: item.cacheStatus.maxUpdatedAt,

package/src/resolvers/RealtimeBridgeResolver.ts

@@ -1,14 +1,15 @@
 import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, InputType, Field } from 'type-graphql';
 import { randomUUID } from 'crypto';
-import { LogError, UserInfo, IMetadataProvider } from '@memberjunction/core';
+import { LogError, LogStatusEx, UserInfo, IMetadataProvider } from '@memberjunction/core';
 import { LiveKitTokenService, LiveKitAgentRoomCoordinator, LiveKitEgressService } from '@memberjunction/livekit-room-server';
 import { AppContext } from '../types.js';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadWriteProvider } from '../util.js';
-import { CreateBridgeRealtimeSession, FinalizeBridgeCoAgentRuns, GetRealtimeModelVoices, CreateBridgeRoomTranscriptSink } from '@memberjunction/ai-agents';
+import { CreateBridgeRealtimeSession, FinalizeBridgeCoAgentRuns, GetRealtimeModelVoices, CreateBridgeRoomTranscriptSink, RealtimeTurnModeratorDecision } from '@memberjunction/ai-agents';
 import { AIBridgeEngine } from '@memberjunction/ai-bridge-server';
 import { SessionManager } from '../agentSessions/SessionManager.js';
 import { NotificationEngine } from '@memberjunction/notifications';
+import { registerMeetingRecordingFile, correlateRecordingStart } from './meetingRecordingRegistration.js';
 
 /**
  * Binds the agent realtime-session factory onto the LiveKit room coordinator's model-session creation seam.
@@ -36,9 +37,25 @@ AIBridgeEngine.Instance.SetSessionRunFinalizer(FinalizeBridgeCoAgentRuns);
  * "Meeting Room"/scope choices live HERE (the Meet composition layer), keeping the engine generic.
  */
 AIBridgeEngine.Instance.SetTranscriptSink(
-  CreateBridgeRoomTranscriptSink({ ConversationType: 'Meeting Room', ApplicationScope: 'Application' }),
+  CreateBridgeRoomTranscriptSink({ ConversationType: 'Meeting Room', ApplicationScope: 'Application', ApplicationName: 'Meet' }),
 );
 
+/**
+ * Binds the room **turn moderator** onto the bridge engine — **OPT-IN, off by default**. When
+ * `MJ_REALTIME_MODERATOR_MODE=on`, a multi-agent room routes each turn through a fast LLM prompt that decides
+ * who speaks (see `RealtimeTurnModerator` in `@memberjunction/ai-agents`). By default it's OFF: agents run in
+ * plain auto-response, hear everything, and self-moderate (no STT-driven router in the loop) — the
+ * coordinator likewise skips meeting mode when the flag is off, so the two stay consistent. We keep the
+ * moderator wired-but-toggleable for controlled scenarios (webinars, large rooms, weaker models).
+ */
+if (process.env.MJ_REALTIME_MODERATOR_MODE === 'on') {
+  AIBridgeEngine.Instance.SetTurnModerator(RealtimeTurnModeratorDecision);
+  console.log('[RealtimeBridge] turn MODERATOR mode is ON (MJ_REALTIME_MODERATOR_MODE=on) — multi-agent rooms use the LLM router.');
+} else {
+  // Default mode — only surface this at startup when verbose (MJ_VERBOSE) is on; it's the expected state and otherwise just noise.
+  LogStatusEx({ message: '[RealtimeBridge] turn moderator mode is OFF (default) — multi-agent rooms run free-for-all: all agents auto-respond + hear everything.', verboseOnly: true });
+}
+
 /**
  * GraphQL surface for the MJ-native LiveKit room: mints scoped client access tokens and starts an
  * agent's presence in a room. The thin resolver delegates to `@memberjunction/livekit-room-server`
@@ -158,6 +175,10 @@ export class LiveKitRecordingResult {
 
   @Field(() => String)
   Status: string;
+
+  /** The `MJ: Files` row id of the registered recording (set on stop, once the egress MP4 is registered). */
+  @Field(() => String, { nullable: true })
+  RecordingFileID?: string;
 }
 
 /** A selectable provider-native voice for the dev voice picker. */
@@ -319,6 +340,33 @@ export class RealtimeBridgeResolver extends ResolverBase {
     }
   }
 
+  /**
+   * **Ends the meeting for everyone**: stops EVERY agent bot bridged into a room (by room name, via the
+   * coordinator's server-side roster). This is the "End meeting" half of the Zoom-style leave control —
+   * usable by any participant, including one who only *joined* the room and never tracked the bridge ids.
+   * Returns `true` when the teardown ran (even if the room held zero agents). Best-effort: any error → `false`.
+   *
+   * @param roomName The LiveKit room to end.
+   */
+  @Mutation(() => Boolean)
+  async EndLiveKitRoom(
+    @Arg('roomName', () => String) roomName: string,
+    @Ctx() context: AppContext = {} as AppContext,
+  ): Promise<boolean> {
+    try {
+      const user = this.GetUserFromPayload(context.userPayload);
+      if (!user) {
+        return false;
+      }
+      const provider = GetReadWriteProvider(context.providers) as unknown as IMetadataProvider;
+      await LiveKitAgentRoomCoordinator.Instance.StopAllAgentsInRoom(roomName, 'Explicit', user, provider);
+      return true;
+    } catch (error) {
+      LogError(`EndLiveKitRoom failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+
   /**
    * Lists active Realtime models with the voices each driver supports — the source for the dev model/voice
    * picker (gated client-side by the `Realtime: Advanced Session Controls` authorization). Read-only; returns
@@ -401,10 +449,17 @@ export class RealtimeBridgeResolver extends ResolverBase {
     @Ctx() context: AppContext = {} as AppContext,
   ): Promise<LiveKitRecordingResult> {
     try {
-      if (!this.GetUserFromPayload(context.userPayload)) {
+      const user = this.GetUserFromPayload(context.userPayload);
+      if (!user) {
         return { Success: false, ErrorMessage: 'Unable to determine current user.', EgressID: '', Status: '' };
       }
       const info = await new LiveKitEgressService().StartRoomRecording({ RoomName: input.RoomName, Layout: input.Layout });
+
+      // 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);
+
       return { Success: true, EgressID: info.EgressID, Status: info.Status };
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
@@ -413,15 +468,35 @@ export class RealtimeBridgeResolver extends ResolverBase {
     }
   }
 
-  /** Stops a recording by egress id. */
+  /**
+   * Stops a recording by egress id, then REGISTERS the completed egress MP4 into MJStorage as an
+   * `MJ: Files` row linked to the room's Meeting-Room Conversation (`Conversation.RecordingFileID`).
+   * Registration is best-effort: a missing storage config or any failure returns the stop result with no
+   * `RecordingFileID` (the recording still stopped) — it never throws.
+   */
   @Mutation(() => LiveKitRecordingResult)
   async StopLiveKitRecording(@Arg('egressID', () => String) egressID: string, @Ctx() context: AppContext = {} as AppContext): Promise<LiveKitRecordingResult> {
     try {
-      if (!this.GetUserFromPayload(context.userPayload)) {
+      const user = this.GetUserFromPayload(context.userPayload);
+      if (!user) {
         return { Success: false, ErrorMessage: 'Unable to determine current user.', EgressID: egressID, Status: '' };
       }
       const info = await new LiveKitEgressService().StopRecording(egressID);
-      return { Success: true, EgressID: info.EgressID, Status: info.Status };
+      const provider = GetReadWriteProvider(context.providers) as unknown as IMetadataProvider;
+
+      // 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(
+        { EgressID: info.EgressID, RoomName: info.RoomName, OutputLocation: info.OutputLocation, OutputSizeBytes: info.OutputSizeBytes },
+        user,
+        provider,
+      );
+      if (!registration.Success) {
+        LogError(`StopLiveKitRecording: recording stopped but registration did not complete: ${registration.ErrorMessage ?? 'unknown'}`);
+      }
+
+      return { Success: true, EgressID: info.EgressID, Status: info.Status, RecordingFileID: registration.RecordingFileID };
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
       LogError(`StopLiveKitRecording failed: ${msg}`);