@memberjunction/server 6.1.0-edge.5 → 6.1.0-edge.7

package/src/resolvers/IntegrationDiscoveryResolver.ts

@@ -3,6 +3,7 @@ import { CompositeKey, DatabaseProviderBase, EntityInfo, LocalCacheManager, Meta
 import { GetReadOnlyProvider, GetReadWriteProvider } from "../util.js";
 import { NoLog } from "../logging/NoLog.js";
 import { UUIDsEqual } from "@memberjunction/global";
+import { DrainResponseBody } from "@memberjunction/network-utils";
 import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
 import {
     MJCompanyIntegrationEntity,
@@ -6472,6 +6473,7 @@ export class IntegrationDiscoveryResolver extends ResolverBase {
                 body: JSON.stringify(payload)
             });
             if (!response.ok) {
+                await DrainResponseBody(response);
                 console.error(`[Integration] Webhook POST to ${url} returned ${response.status}`);
             }
         } catch (e) {

package/src/resolvers/QuerySystemUserResolver.ts

@@ -590,7 +590,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
             }
 
             const provider = GetReadWriteProvider(context.providers);    
-            const key = new CompositeKey([{FieldName: 'ID', Value: ID}]);
+            const key = CompositeKey.FromID(ID); // first-pk-ok: deletes from MJ: Queries (core entity keyed by ID) — see DeleteRecord below
             
             // Provide default options if none provided
             const deleteOptions = options || {

package/src/resolvers/RealtimeClientSessionResolver.ts

@@ -49,6 +49,7 @@ import {
     ParseRealtimeTypeConfiguration,
     ResolveEffectiveRealtimeConfig,
     RealtimeAllowedAgent,
+    RealtimeDirectActionsConfig,
     REALTIME_ADVANCED_SESSION_CONTROLS_AUTHORIZATION,
     resolveRecordingStorageAccountID,
     storeRealtimeRecording,
@@ -181,6 +182,11 @@ interface RealtimeSessionConfig {
      * model-named colleague against it without re-resolving the cascade. Absent ⇒ single-target behavior.
      */
     allowedAgents?: RealtimeAllowedAgent[];
+    /**
+     * The session's effective direct actions configuration (derived from the full config cascade at start).
+     * Persisted so each relayed direct action call enforces against the exact same config used for projection.
+     */
+    directActions?: RealtimeDirectActionsConfig;
     /**
      * Per-session override for the agent's media kit — a `MJ: Collections` id that takes precedence
      * over the agent's `DefaultMediaCollectionID` when the server-side `MediaChannelServer` resolves
@@ -525,6 +531,10 @@ export class RealtimeClientSessionResolver extends ResolverBase {
                     'under the system user (scoped-anonymous caller).',
             );
         }
+        LogStatus(
+            `ExecuteRealtimeSessionTool: dispatching relayed tool '${toolName}' (callId: ${callId}) for session ${agentSessionId}...`,
+        );
+        const startTime = Date.now();
         const { ResultJson, PausedRunID, Artifacts } = await this.clientSessionService.ExecuteRelayedTool(
             {
                 AgentSessionID: agentSessionId,
@@ -532,6 +542,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
                 // Multi-target (Move 4): the session's persisted allowed-agent union — a model-named
                 // colleague in the call is validated against this; absent ⇒ single-target behavior.
                 AllowedAgents: await this.filterAllowedAgentsByCanRun(config.allowedAgents, contextUser),
+                DirectActions: config.directActions,
                 // Attribution follows the VISITOR even when `runUser` is elevated: the delegated run
                 // row and its context-memory scope must stay the person's, not the system user's.
                 AttributionUserID: contextUser.ID,
@@ -545,6 +556,23 @@ export class RealtimeClientSessionResolver extends ResolverBase {
             runUser,
             provider,
         );
+        const durationMs = Date.now() - startTime;
+        LogStatus(
+            `ExecuteRealtimeSessionTool: completed relayed tool '${toolName}' (callId: ${callId}) in ${durationMs}ms`,
+        );
+
+        if (toolName !== 'invoke-target-agent') {
+            await this.persistDirectActionTurn(
+                session,
+                callId,
+                toolName,
+                argsJson,
+                ResultJson,
+                durationMs,
+                contextUser,
+                provider,
+            );
+        }
 
         // Roll the paused-run id forward in the session config: clear the one we just consumed, and
         // store a new one only if the (resumed or fresh) run paused again awaiting feedback.
@@ -832,8 +860,9 @@ export class RealtimeClientSessionResolver extends ResolverBase {
 
     /**
      * Relays a co-agent CHANNEL tool-call (browser_ / Whiteboard_ etc.) onto the session's co-agent
-     * AIPromptRun.Messages — run-only observability so the run captures what the co-agent DID, not just
-     * what it said. Deliberately NOT a ConversationDetail turn (the chat thread stays speech-only).
+     * AIPromptRun.Messages and records the tool execution facts as a hidden ConversationDetail turn.
+     * HiddenToUser=true ensures chat components stay speech-only while allowing session review to
+     * reconstruct action cards dynamically on load (Option 1).
      * Ownership-gated; best-effort (a missing prompt run / save failure simply returns false).
      *
      * @returns `true` when the tool turn was recorded on the run.
@@ -848,6 +877,20 @@ export class RealtimeClientSessionResolver extends ResolverBase {
     ): Promise<boolean> {
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
         const session = await this.loadOwnedActiveSession(agentSessionId, contextUser, provider);
+
+        // Persist the tool turn facts into a hidden ConversationDetail turn so session review
+        // can reconstruct the tool card dynamically on load (Option 1). Best-effort.
+        await this.persistDirectActionTurn(
+            session,
+            undefined,
+            toolName,
+            argsJson,
+            resultJson,
+            undefined,
+            contextUser,
+            provider,
+        );
+
         const promptRunID = this.readPromptRunID(session);
         if (!promptRunID) {
             return false;
@@ -1701,6 +1744,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         await this.persistObservabilityRunIDs(
             session, targetAgentId, prep.CoAgentRunID, prep.PromptRunID, prep.CoAgentRunStepID,
             applicationId, prep.EffectiveConfig?.realtime?.allowedAgents,
+            prep.EffectiveConfig?.realtime?.directActions,
         );
 
         const cfg = prep.ClientConfig;
@@ -1734,6 +1778,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
         coAgentRunStepID?: string,
         applicationID?: string,
         allowedAgents?: RealtimeAllowedAgent[],
+        directActions?: RealtimeDirectActionsConfig,
     ): Promise<void> {
         // Preserve any server-authoritative voice deadline stamped at session start (this rebuilds the
         // full config, so read the existing value forward rather than dropping it).
@@ -1746,6 +1791,7 @@ export class RealtimeClientSessionResolver extends ResolverBase {
             maxSessionDeadlineIso: existing?.maxSessionDeadlineIso,
             applicationID,
             allowedAgents: allowedAgents && allowedAgents.length > 0 ? allowedAgents : undefined,
+            directActions,
         };
         session.Config_ = JSON.stringify(config);
         const saved = await session.Save();
@@ -2476,6 +2522,10 @@ export class RealtimeClientSessionResolver extends ResolverBase {
                             typeof parsed.maxSessionDeadlineIso === 'string' ? parsed.maxSessionDeadlineIso : undefined,
                         applicationID: typeof parsed.applicationID === 'string' ? parsed.applicationID : undefined,
                         allowedAgents: Array.isArray(parsed.allowedAgents) ? parsed.allowedAgents : undefined,
+                        directActions:
+                            parsed.directActions && typeof parsed.directActions === 'object' && typeof parsed.directActions.enabled === 'boolean'
+                                ? (parsed.directActions as RealtimeDirectActionsConfig)
+                                : undefined,
                     };
                 }
             } catch {
@@ -2686,4 +2736,80 @@ export class RealtimeClientSessionResolver extends ResolverBase {
     private mapTranscriptRole(role: string): 'AI' | 'Error' | 'User' {
         return role.trim().toLowerCase() === 'user' ? 'User' : 'AI';
     }
+
+    /**
+     * Persists a direct action or channel tool execution as a hidden ConversationDetail turn.
+     * Stored as stable facts (Role: 'AI', HiddenToUser: true, ExternalID: callId, CompletionTime: durationMs,
+     * Message: JSON-serialized tool facts) so that session review can reconstruct the action card dynamically
+     * on load (Option 1) without polluting user-facing speech chat bubbles.
+     */
+    private async persistDirectActionTurn(
+        session: MJAIAgentSessionEntity,
+        callId: string | undefined,
+        toolName: string,
+        argsJson: string | undefined | null,
+        resultJson: string | undefined | null,
+        durationMs: number | undefined,
+        contextUser: UserInfo,
+        provider: IMetadataProvider,
+    ): Promise<boolean> {
+        if (!session.ConversationID) {
+            return false;
+        }
+        try {
+            const writeUser = ResolveScopedAnonymousRunUser(contextUser);
+            const detail = await provider.GetEntityObject<MJConversationDetailEntity>(
+                CONVERSATION_DETAIL_ENTITY,
+                writeUser,
+            );
+            detail.NewRecord();
+            detail.ConversationID = session.ConversationID;
+            detail.Role = 'AI';
+            detail.HiddenToUser = true;
+            detail.AgentSessionID = session.ID;
+            detail.UserID = contextUser.ID;
+            if (callId) {
+                detail.ExternalID = callId;
+            }
+            if (typeof durationMs === 'number' && durationMs >= 0) {
+                detail.CompletionTime = durationMs;
+            }
+
+            let success = true;
+            if (resultJson) {
+                try {
+                    const parsed = JSON.parse(resultJson) as { success?: boolean; error?: string };
+                    if (parsed.success === false) {
+                        success = false;
+                    }
+                } catch {
+                    // Plain-text output treated as success
+                }
+            }
+            detail.Status = success ? 'Complete' : 'Error';
+
+            const factPayload = {
+                type: 'realtime_tool_execution',
+                callId: callId ?? null,
+                toolName,
+                argsJson: argsJson ?? null,
+                resultJson: resultJson ?? null,
+                success,
+                durationMs: durationMs ?? 0,
+            };
+            detail.Message = JSON.stringify(factPayload);
+
+            const saved = await detail.Save();
+            if (!saved) {
+                LogError(
+                    `RealtimeClientSessionResolver.persistDirectActionTurn save failed: ${detail.LatestResult?.CompleteMessage ?? 'unknown error'}`,
+                );
+            }
+            return saved;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            LogError(`RealtimeClientSessionResolver.persistDirectActionTurn unexpected error: ${message}`);
+            return false;
+        }
+    }
 }

package/src/resolvers/RemoteBrowserActionResolver.ts

@@ -230,6 +230,20 @@ interface VisualInterpreterPayload {
  * (the process-wide singleton) backs every request; ownership is enforced per call against the session's
  * `UserID`.
  */
+/**
+ * Safety cap on how long a {@link RemoteBrowserActionResolver.startedScreencasts} /
+ * {@link RemoteBrowserActionResolver.startedAudioStreams} entry is trusted without confirmation.
+ *
+ * `RemoteBrowserActionResolver` is instantiated once per process by type-graphql's default resolver
+ * container, so these idempotency maps live as long as the server does. `StopRemoteBrowserScreencast` /
+ * `StopRemoteBrowserAudioStream` are the only code paths that ever delete an entry — a session that
+ * crashes, disconnects, or times out before calling Stop (a normal occurrence: tab close, network drop,
+ * agent timeout) leaves its entry behind forever. This TTL bounds that growth the same way
+ * {@link RemoteBrowserGoalRegistry}'s own sweep bounds its run records, without requiring a dedicated
+ * session-end hook that doesn't otherwise exist for this resolver.
+ */
+const MAX_STREAM_ENTRY_AGE_MS = 4 * 60 * 60 * 1000; // 4 hours — generous vs. SessionJanitor's 15-minute idle threshold
+
 @Resolver()
 export class RemoteBrowserActionResolver extends ResolverBase {
   /**
@@ -237,20 +251,43 @@ export class RemoteBrowserActionResolver extends ResolverBase {
    * {@link RemoteBrowserActionResolver.streamKey} (agent session **plus** instance) so a re-issued
    * {@link RemoteBrowserActionResolver.StartRemoteBrowserScreencast} — the surface re-binding after a
    * tab collapse — is idempotent and never stacks two screencasts on the one browser. Entries are
-   * removed by {@link RemoteBrowserActionResolver.StopRemoteBrowserScreencast}.
+   * normally removed by {@link RemoteBrowserActionResolver.StopRemoteBrowserScreencast}; the value is
+   * the entry's start time (ms epoch) so {@link RemoteBrowserActionResolver.sweepStreamEntries} can
+   * reclaim ones whose session never called Stop.
    *
    * Keyed by agent session ALONE (#3531) this was the idempotency guard turning into a lockout: the
    * first surface's entry made the SECOND surface's bind a silent `Streaming: true` no-op, so a second
    * browser could be started and driven but never watched.
    */
-  private startedScreencasts = new Set<string>();
+  private startedScreencasts = new Map<string, number>();
 
   /**
    * Surfaces whose live tab-audio stream this resolver has already started, keyed by
-   * {@link RemoteBrowserActionResolver.streamKey} for the same reason the screencast set is. Entries
-   * are removed by {@link RemoteBrowserActionResolver.StopRemoteBrowserAudioStream}.
+   * {@link RemoteBrowserActionResolver.streamKey} for the same reason the screencast map is. Entries
+   * are normally removed by {@link RemoteBrowserActionResolver.StopRemoteBrowserAudioStream}; see
+   * {@link RemoteBrowserActionResolver.startedScreencasts} for why the value is a timestamp.
+   */
+  private startedAudioStreams = new Map<string, number>();
+
+  /**
+   * Drops any {@link startedScreencasts} / {@link startedAudioStreams} entry older than
+   * {@link MAX_STREAM_ENTRY_AGE_MS} — the reclaim path for sessions that never called
+   * `StopRemoteBrowserScreencast`/`StopRemoteBrowserAudioStream` (crash, disconnect, timeout). Called
+   * on every Start mutation, mirroring {@link RemoteBrowserGoalRegistry.Begin}'s sweep-on-access pattern.
    */
-  private startedAudioStreams = new Set<string>();
+  private sweepStreamEntries(): void {
+    const cutoff = Date.now() - MAX_STREAM_ENTRY_AGE_MS;
+    for (const [key, startedAt] of this.startedScreencasts) {
+      if (startedAt < cutoff) {
+        this.startedScreencasts.delete(key);
+      }
+    }
+    for (const [key, startedAt] of this.startedAudioStreams) {
+      if (startedAt < cutoff) {
+        this.startedAudioStreams.delete(key);
+      }
+    }
+  }
 
   /**
    * Execute ONE browser action relayed from the client-direct realtime session, returning the outcome +
@@ -569,6 +606,7 @@ export class RemoteBrowserActionResolver extends ResolverBase {
 
     // Idempotent PER SURFACE: a re-bind must not stack a second screencast on the one live browser,
     // but a SECOND surface binding for the first time is not a re-bind (#3531).
+    this.sweepStreamEntries();
     const streamKey = this.streamKey(agentSessionID, instanceKey);
     if (this.startedScreencasts.has(streamKey)) {
       return { Streaming: true };
@@ -580,7 +618,7 @@ export class RemoteBrowserActionResolver extends ResolverBase {
       await liveSession.StartScreencast((frame) =>
         this.publishFrame(pubSub, userPayload, agentSessionID, instanceKey, frame, liveSession.GetCurrentUrl()),
       );
-      this.startedScreencasts.add(streamKey);
+      this.startedScreencasts.set(streamKey, Date.now());
       return { Streaming: true };
     } catch (err) {
       if (err instanceof RemoteBrowserCapabilityNotSupportedError) {
@@ -647,7 +685,8 @@ export class RemoteBrowserActionResolver extends ResolverBase {
     const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
     const session = await this.loadOwnedSession(agentSessionID, contextUser, provider);
 
-    // Idempotent PER SURFACE — same reasoning as the screencast set (#3531).
+    // Idempotent PER SURFACE — same reasoning as the screencast map (#3531).
+    this.sweepStreamEntries();
     const streamKey = this.streamKey(agentSessionID, instanceKey);
     if (this.startedAudioStreams.has(streamKey)) {
       return { Streaming: true };
@@ -657,7 +696,7 @@ export class RemoteBrowserActionResolver extends ResolverBase {
     try {
       const liveSession = await RemoteBrowserEngine.Instance.StartSessionForAgentSession(agentSessionID, contextUser, providerName, instanceKey);
       await liveSession.StartAudioStream((chunk) => this.publishAudioChunk(pubSub, userPayload, agentSessionID, instanceKey, chunk));
-      this.startedAudioStreams.add(streamKey);
+      this.startedAudioStreams.set(streamKey, Date.now());
       return { Streaming: true };
     } catch (err) {
       if (err instanceof RemoteBrowserCapabilityNotSupportedError) {

package/src/resolvers/SyncRolesUsersResolver.ts

@@ -385,8 +385,17 @@ export class SyncRolesAndUsersResolver {
         if (await user.Delete()) {
             return;
         }
-        // FK constraint fallback: when the user has dependent records that block hard delete,
-        // we mark the user inactive instead. A failure to soft-delete IS a real error and rolls back.
+        // Fallback when the hard delete does not happen. TWO distinct causes reach here, and this
+        // path deliberately treats them the same way:
+        //   1. FK constraints — the user has dependent records that block a hard delete.
+        //   2. Authorization — `MJUserEntityServer` (issue #4260) refuses a delete outright for any
+        //      caller whose `Type` is not 'Owner'. This mutation carries `@RequireSystemUser()` and
+        //      `getSystemUser()` resolves the seeded Owner, so cause 2 does not arise on a default
+        //      install; it does on a deployment whose system user is not an Owner.
+        // Soft-deleting is the right response to (1) and an acceptable one to (2) — but note the
+        // subsequent Save() is subject to the SAME guard, so under cause 2 it fails too and the
+        // error below is what the operator sees. Read `LatestResult` rather than assuming FK.
+        // A failure to soft-delete IS a real error and rolls back.
         user.IsActive = false;
         if (!await user.Save()) {
             throw new Error(`Failed to delete or deactivate user '${user.Email}': ${user.LatestResult?.CompleteMessage ?? 'unknown error'}`);

package/src/resolvers/UserViewResolver.ts

@@ -4,7 +4,7 @@ import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@member
 import { MJUserView_, MJUserViewResolverBase } from '../generated/generated.js';
 import { UserResolver } from './UserResolver.js';
 import { MJUserViewEntity, MJUserViewEntityExtended } from '@memberjunction/core-entities';
-import { GetReadOnlyProvider } from '../util.js';
+import { GetReadOnlyProvider, GetReadWriteProvider } from '../util.js';
 
 @Resolver(MJUserView_)
 export class UserViewResolver extends MJUserViewResolverBase {
@@ -52,11 +52,15 @@ export class UserViewResolver extends MJUserViewResolverBase {
     // this should normally not be a factor but we have this exposed in the GraphQL API so that
     // a dev can force the update if desired from the client. The normal path is just to update
     // filter state which in turn will be used to update the where clause in the entity sub-class.
-    const p = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true});
+    // This endpoint WRITES (Save below), so it must use the read-write provider — on a read-replica
+    // deployment the read-only provider would route the save to the replica.
+    const p = GetReadWriteProvider(providers, {allowFallbackToReadOnly: true});
     const u = this.GetUserFromPayload(userPayload);
     const viewEntity = <MJUserViewEntityExtended>await p.GetEntityObject('MJ: User Views', u);
-    await viewEntity.Load(ID);
-    viewEntity.UpdateWhereClause();
+    if (!await viewEntity.Load(ID)) {
+      throw new Error(`User View ${ID} not found or access denied`);
+    }
+    await viewEntity.UpdateWhereClause(true); // force regeneration regardless of dirty state — that is the whole point of this endpoint
 
     if (await viewEntity.Save()) {
       return viewEntity.GetAll();

package/src/rest/EntityCRUDHandler.ts

@@ -254,26 +254,10 @@ export class EntityCRUDHandler {
     }
     
     /**
-     * Helper method to create a composite key from an ID
+     * Build the record key from the `:id` path segment. A single-column key (any column name) is
+     * the bare value; a composite key is the URL-encoded `Field1|Value1||Field2|Value2` segment.
      */
     private static createCompositeKeyFromId(entity: BaseEntity, id: string | number): CompositeKey {
-        if (entity.EntityInfo.PrimaryKeys.length === 1) {
-            // Single primary key
-            const primaryKeyField = entity.EntityInfo.PrimaryKeys[0].Name;
-            const compositeKey = new CompositeKey();
-            const strId = id.toString();
-            
-            // Use key-value pairs instead of SetValue
-            compositeKey.KeyValuePairs = [
-                { FieldName: primaryKeyField, Value: strId }
-            ];
-            
-            return compositeKey;
-        } else {
-            // Composite primary key - this is a simplification
-            // In a real implementation, you would need to parse a composite ID string
-            // or accept an object with all primary key values
-            throw new Error('Composite primary keys are not supported in this simplified implementation');
-        }
+        return CompositeKey.FromURLSegment(entity.EntityInfo, id.toString());
     }
 }

package/src/rest/RESTEndpointHandler.ts

@@ -794,25 +794,11 @@ export class RESTEndpointHandler {
     }
 
     /**
-     * Helper method to create a composite key from an ID
+     * Build the record key from the `:id` path segment. A single-column key (any column name) is
+     * the bare value; a composite key is the URL-encoded `Field1|Value1||Field2|Value2` segment.
      */
     private createCompositeKey(entityInfo: EntityInfo, id: string): CompositeKey {
-        if (entityInfo.PrimaryKeys.length === 1) {
-            // Single primary key
-            const primaryKeyField = entityInfo.PrimaryKeys[0].Name;
-            const compositeKey = new CompositeKey();
-            
-            // Use key-value pairs instead of SetValue
-            compositeKey.KeyValuePairs = [
-                { FieldName: primaryKeyField, Value: id }
-            ];
-            
-            return compositeKey;
-        } else {
-            // Composite primary key
-            // This is a simplification - in a real implementation, we would need to handle composite keys properly
-            throw new Error('Composite primary keys are not supported in this implementation');
-        }
+        return CompositeKey.FromURLSegment(entityInfo, id);
     }
 
     /**

package/src/rest/RealtimeSdpBrokerHandler.ts

@@ -0,0 +1,101 @@
+import express, { type Router, type Request, type Response, type NextFunction } from 'express';
+import { MJGlobal } from '@memberjunction/global';
+import { BaseRealtimeModel, RealtimeProxyRegistry, type RealtimeProxyTicketEntry } from '@memberjunction/ai';
+import { LogError, LogStatus } from '@memberjunction/core';
+
+/**
+ * Middleware that extracts and consumes the realtime ticket from query parameters
+ * BEFORE any request body parsing occurs. This prevents anonymous/unauthorized callers
+ * from causing body-parser memory allocations.
+ */
+export function requireTicket(req: Request, res: Response, next: NextFunction): void {
+    const ticketId = (req.query['ticket'] as string) || '';
+    if (!ticketId) {
+        res.status(401).json({ error: 'Unauthorized: missing ticket' });
+        return;
+    }
+
+    const entry = RealtimeProxyRegistry.Instance.Consume(ticketId);
+    if (!entry) {
+        res.status(401).json({ error: 'Unauthorized: invalid or expired ticket' });
+        return;
+    }
+
+    res.locals.ticketEntry = entry;
+    res.locals.ticketId = ticketId;
+    next();
+}
+
+/**
+ * Builds the Express router handling the Realtime WebRTC SDP exchange:
+ * `POST /realtime/sdp-exchange?ticket=<ticketId>`
+ *
+ * In the Realtime WebRTC topology (e.g. OpenAI Live), the browser never contacts the upstream
+ * API directly and holds no project API key. Instead, the browser sends its offer SDP here using a
+ * short-lived ticket minted by the provider driver. This broker validates and consumes the ticket
+ * BEFORE body parsing, delegates to `driver.ExchangeWebRtcSdp` to exchange the SDP offer for an
+ * answer with upstream using the server's API key, and returns the answer SDP.
+ */
+export function createRealtimeSdpBrokerRouter(): Router {
+    const router = express.Router();
+
+    router.post(
+        '/',
+        requireTicket,
+        express.json({ limit: '2mb' }),
+        async (req: Request, res: Response): Promise<void> => {
+            const entry = res.locals.ticketEntry as RealtimeProxyTicketEntry;
+            const ticketId = (res.locals.ticketId as string) || '';
+
+            LogStatus(
+                `RealtimeSdpBrokerHandler: processing ticket '${ticketId}' for user '${entry.UserID ?? 'anonymous'}', driver '${entry.DriverClass ?? 'OpenAILiveRealtime'}'`
+            );
+
+            const body = req.body as { sdp?: string } | undefined;
+            const sdp = body?.sdp;
+            if (!sdp || typeof sdp !== 'string') {
+                res.status(400).json({ error: 'Missing or invalid sdp in request body' });
+                return;
+            }
+
+            const apiKey = entry.UpstreamAuthHeader;
+            if (!apiKey) {
+                LogError(`RealtimeSdpBrokerHandler: ticket '${ticketId}' has no upstream auth credentials`);
+                res.status(500).json({ error: 'Server configuration error: missing upstream credentials' });
+                return;
+            }
+
+            try {
+                const driverClass = entry.DriverClass || 'OpenAILiveRealtime';
+                const driver = MJGlobal.Instance.ClassFactory.CreateInstance<BaseRealtimeModel>(
+                    BaseRealtimeModel,
+                    driverClass,
+                    apiKey,
+                    entry.UpstreamUrl
+                );
+
+                if (!driver || !driver.ExchangeWebRtcSdp) {
+                    LogError(`RealtimeSdpBrokerHandler: driver '${driverClass}' does not support ExchangeWebRtcSdp`);
+                    res.status(500).json({ error: `Driver '${driverClass}' does not support WebRTC SDP exchange` });
+                    return;
+                }
+
+                LogStatus(`RealtimeSdpBrokerHandler: exchanging WebRTC SDP offer via ${driverClass}`);
+                // Use authoritative session config recorded on ticket entry at mint time (prevents client tampering)
+                const result = await driver.ExchangeWebRtcSdp(sdp, entry.SessionConfig);
+                res.status(200).json(result);
+            } catch (err: unknown) {
+                const message = err instanceof Error ? err.message : String(err);
+                LogError(`RealtimeSdpBrokerHandler failed for ticket '${ticketId}': ${message}`);
+                res.status(502).json({ error: 'Realtime WebRTC handshake failed' });
+            }
+        }
+    );
+
+    return router;
+}
+
+/**
+ * @deprecated Use `createRealtimeSdpBrokerRouter` instead.
+ */
+export const createOpenAILiveBrokerRouter = createRealtimeSdpBrokerRouter;

package/src/serverExtensionReservedRoots.ts

@@ -20,6 +20,8 @@ export const CORE_STATIC_RESERVED_SERVER_EXTENSION_ROOTS: readonly string[] = [
     '/media',
     '/oauth',
     '/health',
+    '/realtime',
+    '/realtime-proxy',
 ];
 
 /**
@@ -30,9 +32,6 @@ export const CORE_CONSTANT_RESERVED_SERVER_EXTENSION_ROOTS: readonly string[] =
     '/auth',              // AUTH_CATALOG_MOUNT_PATH
     '/magic-link',        // MAGIC_LINK_MOUNT_PATH
     '/widget',            // WIDGET_MOUNT_PATH
-    '/telephony/twilio',  // TWILIO_TELEPHONY_MOUNT_PATH
-    '/telephony/vonage',  // VONAGE_TELEPHONY_MOUNT_PATH
-    '/meetings/teams',    // TEAMS_MEETINGS_MOUNT_PATH
 ];
 
 /**

package/dist/resolvers/RingCentralTelephonyResolver.d.ts

@@ -1,27 +0,0 @@
-/**
- * @fileoverview GraphQL surface for OUTBOUND RingCentral telephony: `PlaceRingCentralCall` rings a real
- * phone from an agent identity and connects the pinned agent. Thin — it authorizes the caller, then
- * delegates to the startup-constructed {@link RingCentralTelephonyService} (which owns the bridge
- * orchestration + the shared media registry). Inbound calls arrive via the public
- * `POST /telephony/ringcentral/webhook` notification, not GraphQL.
- *
- * @module @memberjunction/server
- */
-import { AppContext } from '../types.js';
-import { ResolverBase } from '../generic/ResolverBase.js';
-/** Result of an outbound RingCentral place-call attempt. */
-export declare class PlaceRingCentralCallResult {
-    Success: boolean;
-    ErrorMessage?: string;
-    /** The placed RingCentral telephony session id (the bridge's external connection id). */
-    SessionId: string;
-}
-export declare class RingCentralTelephonyResolver extends ResolverBase {
-    /**
-     * Places an outbound call from the given agent identity (its phone number is the caller-id) to a
-     * destination number, connecting the pinned agent over the realtime bridge. Returns the telephony
-     * session id.
-     */
-    PlaceRingCentralCall(agentIdentityId: string, toNumber: string, context?: AppContext): Promise<PlaceRingCentralCallResult>;
-}
-//# sourceMappingURL=RingCentralTelephonyResolver.d.ts.map

package/dist/resolvers/RingCentralTelephonyResolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RingCentralTelephonyResolver.d.ts","sourceRoot":"","sources":["../../src/resolvers/RingCentralTelephonyResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAI1D,4DAA4D;AAC5D,qBACa,0BAA0B;IAEnC,OAAO,EAAE,OAAO,CAAC;IAGjB,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,yFAAyF;IAEzF,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,qBACa,4BAA6B,SAAQ,YAAY;IAC1D;;;;OAIG;IAEG,oBAAoB,CACgB,eAAe,EAAE,MAAM,EAC9B,QAAQ,EAAE,MAAM,EACxC,OAAO,GAAE,UAA6B,GAC9C,OAAO,CAAC,0BAA0B,CAAC;CAoBzC"}