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

package/dist/resolvers/RealtimeClientSessionResolver.js

@@ -45,11 +45,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
  */
 import { Resolver, Mutation, Arg, Ctx, Int, Float, ObjectType, Field, PubSub, PubSubEngine } from 'type-graphql';
 import { AuthorizationEvaluator, LogError, LogErrorEx, LogStatus, RunView } from '@memberjunction/core';
-import { UUIDsEqual, IsValidUUID } from '@memberjunction/global';
+import { EscapeSQLString, UUIDsEqual, IsValidUUID } from '@memberjunction/global';
 import { ConversationEngine, } from '@memberjunction/core-entities';
 import { AIEngine } from '@memberjunction/aiengine';
 import { AIAgentPermissionHelper, AIEngineBase, HasRealtimeUsage, ParseRealtimeUsageRecord } from '@memberjunction/ai-engine-base';
-import { RealtimeClientSessionService, RealtimeChannelServerHost, EvaluateRuntimeOverrideAuthorization, FindIgnoredRealtimeConfigKeys, ParseRealtimeTypeConfiguration, ResolveEffectiveRealtimeConfig, ResolveRealtimeCoAgentID, FilterAllowedAgentsByCanRun, INVOKE_TARGET_AGENT_TOOL_NAME, REALTIME_ADVANCED_SESSION_CONTROLS_AUTHORIZATION, resolveRecordingStorageAccountID, storeRealtimeRecording, writeRealtimeRecordingSegment, deleteRealtimeRecordingSegments, } from '@memberjunction/ai-agents';
+import { RealtimeClientSessionService, RealtimeChannelServerHost, EvaluateRuntimeOverrideAuthorization, FindIgnoredRealtimeConfigKeys, ParseRealtimeTypeConfiguration, ResolveEffectiveRealtimeConfig, ResolveRealtimeCoAgentID, FilterAllowedAgentsByCanRun, INVOKE_TARGET_AGENT_TOOL_NAME, REALTIME_ADVANCED_SESSION_CONTROLS_AUTHORIZATION, SqlRealtimeRecordingLedger, resolveRecordingStorageAccountID, storeRealtimeRecording, writeRealtimeRecordingSegment, deleteRealtimeRecordingSegments, } from '@memberjunction/ai-agents';
 import { IsValidRealtimeToolDefinition, NormalizeChannelKey, ParseRealtimeChannelCandidates } from '@memberjunction/ai-core-plus';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { GetReadWriteProvider } from '../util.js';
@@ -61,6 +61,7 @@ import { RunWithTrustedSessionConfigWrites } from '@memberjunction/core-entities
 import { BuildMintConfigStamps, LoadInheritedVerifiedIdentity } from '../realtimeSessions/sessionConfigStamps.js';
 import { ParseConfigObject } from '../realtimeSessions/verificationCore.js';
 import { LoadOwnedRealtimeSession } from '../realtimeSessions/ownedRealtimeSession.js';
+import { AuthorizeSessionAccess, LoadSessionForAccess } from '../realtimeSessions/sessionAccess.js';
 /**
  * Progress steps worth narrating to the realtime model — mirrors the normal agent-run path's filter
  * in {@link import('./RunAIAgentResolver.js').RunAIAgentResolver}. Initialization/validation/finalization
@@ -72,8 +73,14 @@ const SIGNIFICANT_PROGRESS_STEPS = ['prompt_execution', 'action_execution', 'sub
  * characters, so anything longer is not a relay the browser runtime sends.
  */
 const MAX_USAGE_DETAILS_JSON_LENGTH = 4096;
+/**
+ * Sessions already logged as having no co-agent prompt run. Usage, transcript and tool-turn relays all read
+ * the id, many times per call, so the gap is logged once per session instead of once per relay. Bounded:
+ * past {@link MAX_LOGGED_MISSING_PROMPT_RUN_SESSIONS} entries the oldest is dropped (a Set keeps insertion order).
+ */
+const sessionsLoggedWithoutPromptRun = new Set();
+const MAX_LOGGED_MISSING_PROMPT_RUN_SESSIONS = 5000;
 /** Entity name — centralised so the `MJ:`-prefix convention is applied in exactly one place. */
-const SESSION_ENTITY = 'MJ: AI Agent Sessions';
 const CO_AGENT_ENTITY = 'MJ: AI Agent Co Agents';
 const CONVERSATION_DETAIL_ENTITY = 'MJ: Conversation Details';
 const CHANNEL_ENTITY = 'MJ: AI Agent Channels';
@@ -403,7 +410,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             config: JSON.stringify(config),
         }, contextUser, provider));
         // Best-effort: stamp recording-start metadata when the browser captured (with consent) at start.
-        await this.stampRecordingStart(session, recordingConsent, recordingStartedAt);
+        await this.stampRecordingStart(session, recordingConsent, recordingStartedAt, contextUser, provider);
         const clientTools = this.parseClientTools(clientToolsJson);
         const channelCandidates = this.parseChannelCandidates(channelCandidatesJson);
         // Best-effort model-context hydration: the PRIOR session chain's transcript (ownership-
@@ -453,10 +460,17 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      * start fails rather than proceeding without its limits.
      */
     async stampVerificationPolicy(session, effectiveConfigJson, lastSessionId, contextUser, provider) {
+        let inheritedVerified = undefined;
+        try {
+            inheritedVerified = await LoadInheritedVerifiedIdentity(lastSessionId, contextUser, provider);
+        }
+        catch (error) {
+            LogError(`StartRealtimeClientSession: failed to load inherited verified identity for prior session ${lastSessionId}: ${error.message}`);
+        }
         const plan = BuildMintConfigStamps({
             EffectiveRealtime: this.readEffectiveRealtime(effectiveConfigJson),
             ExistingConfigRaw: session.Config_,
-            InheritedVerified: await LoadInheritedVerifiedIdentity(lastSessionId, contextUser, provider),
+            InheritedVerified: inheritedVerified,
             NowMs: Date.now(),
         });
         if (!plan) {
@@ -627,11 +641,14 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
     async RelayRealtimeTranscript(agentSessionId, role, text, { userPayload, providers }, replacesPrevious, utteranceStartMs, utteranceEndMs) {
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
         const session = await this.loadOwnedActiveSession(agentSessionId, contextUser, provider);
-        const saved = replacesPrevious
-            ? await this.replacePreviousTranscriptTurn(session, role, text, contextUser, provider, utteranceStartMs, utteranceEndMs)
-            : await this.persistTranscriptTurn(session, role, text, contextUser, provider, utteranceStartMs, utteranceEndMs);
-        if (!saved) {
-            return false;
+        const persistDetail = this.mapTranscriptRole(role) === 'User' || (await this.callerOwnsConversation(session, contextUser, provider));
+        if (persistDetail) {
+            const saved = replacesPrevious
+                ? await this.replacePreviousTranscriptTurn(session, role, text, contextUser, provider, utteranceStartMs, utteranceEndMs)
+                : await this.persistTranscriptTurn(session, role, text, contextUser, provider, utteranceStartMs, utteranceEndMs);
+            if (!saved) {
+                return false;
+            }
         }
         // Mirror the turn onto the co-agent's long-lived prompt run so its Messages capture the full
         // conversation (run-viewer observability parity). Best-effort — never fails the transcript relay.
@@ -643,7 +660,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             await this.clientSessionService.AppendPromptRunMessage(promptRunID, this.mapTranscriptRoleToChatRole(role), text, replacesPrevious ?? false, runUser, provider);
         }
         await this.sessionManager.Heartbeat(agentSessionId, contextUser, provider);
-        return true;
+        return persistDetail;
     }
     /**
      * Maps the relayed transcript role (`'User'`/`'AI'`/`'Assistant'`, case-insensitive) to the
@@ -715,15 +732,21 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
                 Peaks: this.sanitizePeaks(peaks),
             });
             // Canonical consolidated file written — drop the crash-recovery shards (best-effort).
-            if (stored.FileID) {
+            // A FileID with an ErrorMessage is an uploaded file the session was not stamped with: the
+            // shards are then the only recording the janitor could still recover, so keep them.
+            const storedAndStamped = !!stored.FileID && !stored.ErrorMessage;
+            if (storedAndStamped) {
                 await deleteRealtimeRecordingSegments(agentSessionId, accountID, runUser);
             }
+            else if (stored.FileID) {
+                LogError(`RealtimeClientSessionResolver.UploadRealtimeRecording: session ${agentSessionId} has file ${stored.FileID} but it is not stamped (${stored.ErrorMessage}); shards kept`);
+            }
             return {
-                Success: !!stored.FileID,
+                Success: storedAndStamped,
                 FileID: stored.FileID ?? undefined,
                 // Report the reason the storage layer knew (e.g. Drive's "Service Accounts do not have
                 // storage quota"); the generic sentence is only for when no layer supplied one.
-                ErrorMessage: stored.FileID ? undefined : (stored.ErrorMessage ?? 'Storage upload failed.'),
+                ErrorMessage: storedAndStamped ? undefined : (stored.ErrorMessage ?? 'Storage upload failed.'),
             };
         }
         catch (error) {
@@ -951,8 +974,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             return null;
         }
         if (!config.promptRunID) {
-            LogStatus(`RelayRealtimeUsage: session ${session.ID} has no co-agent promptRunID (observability run ` +
-                'creation was skipped or failed) — usage delta dropped.');
+            this.logMissingPromptRunOnce(session.ID);
             return null;
         }
         const verified = await this.runIDVerifier.Verify(session.ID, { CoAgentRunID: config.coAgentRunID, PromptRunID: config.promptRunID }, runUser, provider);
@@ -962,6 +984,26 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
         }
         return verified.PromptRunID;
     }
+    /**
+     * Logs, once per session, that the session has no co-agent prompt run, so its usage, cost, transcript and
+     * tool turns are not recorded on one. The reason (no active co-agent prompt, or a failed run save) was
+     * logged when the session was prepared.
+     */
+    logMissingPromptRunOnce(sessionID) {
+        if (sessionsLoggedWithoutPromptRun.has(sessionID)) {
+            return;
+        }
+        sessionsLoggedWithoutPromptRun.add(sessionID);
+        if (sessionsLoggedWithoutPromptRun.size > MAX_LOGGED_MISSING_PROMPT_RUN_SESSIONS) {
+            const oldest = sessionsLoggedWithoutPromptRun.values().next().value;
+            if (oldest !== undefined) {
+                sessionsLoggedWithoutPromptRun.delete(oldest);
+            }
+        }
+        LogError(`RealtimeClientSessionResolver: session ${sessionID} has no co-agent promptRunID, so its usage, cost, ` +
+            'transcript and tool turns are not recorded on a prompt run (the reason was logged when the session ' +
+            'was prepared). Logged once per session.');
+    }
     /**
      * Persist an interactive channel's state of record (e.g. the live whiteboard's serialized
      * scene) onto the session's `MJ: AI Agent Session Channels` row.
@@ -1499,9 +1541,10 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
         const rv = RunView.FromMetadataProvider(provider);
         const existing = await rv.RunView({
             EntityName: SESSION_CHANNEL_ENTITY,
-            ExtraFilter: `AgentSessionID='${agentSessionID}' AND ChannelID='${channelID}'`,
+            ExtraFilter: `AgentSessionID='${EscapeSQLString(agentSessionID)}' AND ChannelID='${EscapeSQLString(channelID)}'`,
             ResultType: 'entity_object',
             MaxRows: 1,
+            SkipTotalRowCount: true,
         }, contextUser);
         let row = existing.Success ? existing.Results?.[0] : undefined;
         if (!row) {
@@ -1539,13 +1582,14 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             return null;
         }
         try {
-            const prior = await provider.GetEntityObject(SESSION_ENTITY, contextUser);
-            if (!(await prior.Load(lastSessionId))) {
+            const loaded = await LoadSessionForAccess(lastSessionId, contextUser, provider);
+            if (!loaded) {
                 LogError(`StartRealtimeClientSession: prior session ${lastSessionId} not found — skipping channel-state restore.`);
                 return null;
             }
-            if (!UUIDsEqual(prior.UserID, contextUser.ID)) {
-                LogError(`StartRealtimeClientSession: prior session ${lastSessionId} is not owned by user ${contextUser.ID} — ` +
+            const access = AuthorizeSessionAccess({ SessionUserID: loaded.Session.UserID, ConversationExternalID: loaded.ConversationExternalID, ConversationReadable: loaded.ConversationReadable }, contextUser);
+            if (!access.Allowed) {
+                LogError(`StartRealtimeClientSession: prior session ${lastSessionId} is not owned by user ${contextUser.ID} (${access.Reason}) — ` +
                     'skipping channel-state restore.');
                 return null;
             }
@@ -1715,22 +1759,23 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
                 break;
             }
             visited.add(key);
-            const leg = await provider.GetEntityObject(SESSION_ENTITY, contextUser);
-            if (!(await leg.Load(cursor))) {
+            const loaded = await LoadSessionForAccess(cursor, contextUser, provider);
+            if (!loaded) {
                 if (legIDs.length === 0) {
                     LogError(`StartRealtimeClientSession: prior session ${cursor} not found — skipping transcript hydration.`);
                 }
                 break;
             }
-            if (!UUIDsEqual(leg.UserID, contextUser.ID)) {
+            const access = AuthorizeSessionAccess({ SessionUserID: loaded.Session.UserID, ConversationExternalID: loaded.ConversationExternalID, ConversationReadable: loaded.ConversationReadable }, contextUser);
+            if (!access.Allowed) {
                 if (legIDs.length === 0) {
-                    LogError(`StartRealtimeClientSession: prior session ${cursor} is not owned by user ${contextUser.ID} — ` +
+                    LogError(`StartRealtimeClientSession: prior session ${cursor} is not owned by user ${contextUser.ID} (${access.Reason}) — ` +
                         'skipping transcript hydration.');
                 }
                 break;
             }
-            legIDs.push(leg.ID);
-            cursor = leg.LastSessionID ?? null;
+            legIDs.push(loaded.Session.ID);
+            cursor = loaded.Session.LastSessionID ?? null;
         }
         return legIDs;
     }
@@ -1808,6 +1853,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             Fields: ['ID', 'IsEnabled'],
             ResultType: 'simple',
             MaxRows: 1,
+            SkipTotalRowCount: true,
         }, contextUser);
         const row = result.Success ? result.Results?.[0] : undefined;
         if (!row || !row.IsEnabled) {
@@ -1936,6 +1982,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             OrderBy: '__mj_CreatedAt DESC',
             ResultType: 'simple',
             MaxRows: 1,
+            SkipTotalRowCount: true,
         }, contextUser);
         const detail = result.Success ? result.Results?.[0] : undefined;
         return detail?.ID ?? null;
@@ -1949,6 +1996,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
     async createHiddenSessionAnchorDetail(session, callerUser, provider) {
         const detail = await provider.GetEntityObject(CONVERSATION_DETAIL_ENTITY, callerUser);
         detail.NewRecord();
+        detail.MarkServerAuthoredReply(); // a server-written system anchor, not the caller's words
         detail.ConversationID = session.ConversationID;
         detail.BranchID = this.sessionBranchIdOf(session);
         detail.Role = 'AI';
@@ -1996,9 +2044,10 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             const rv = RunView.FromMetadataProvider(provider);
             const existing = await rv.RunView({
                 EntityName: SESSION_CHANNEL_ENTITY,
-                ExtraFilter: `AgentSessionID='${agentSessionID}' AND ChannelID='${channelID}'`,
+                ExtraFilter: `AgentSessionID='${EscapeSQLString(agentSessionID)}' AND ChannelID='${EscapeSQLString(channelID)}'`,
                 ResultType: 'entity_object',
                 MaxRows: 1,
+                SkipTotalRowCount: true,
             }, contextUser);
             const row = existing.Success ? existing.Results?.[0] : undefined;
             if (!row) {
@@ -2180,14 +2229,21 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
     }
     /**
      * Stamps `RecordingStartedAt` (the recording `t0` alignment origin) + `RecordingMedia` on a
-     * just-started session when the browser captured WITH consent. Best-effort: a parse/save failure
-     * is logged and swallowed — a recording-metadata problem must never fail the session start.
+     * just-started session when the browser captured WITH consent. `RecordingStartedAt` goes through
+     * the entity save (and stays set on the in-memory session, so a later save of it cannot clear it);
+     * `RecordingMedia` is a recording-ledger column that an entity save cannot write (#6010), so it goes
+     * through the ledger's `spStampAIAgentSessionRecordingFile` proc. The proc stamps `t0` as well, so it
+     * lands even when the entity save fails: the janitor recovers only sessions that carry a
+     * `RecordingStartedAt`. Best-effort: a parse/save/stamp failure is logged and swallowed — a
+     * recording-metadata problem must never fail the session start.
      *
      * @param session The freshly created/loaded session.
      * @param recordingConsent Whether the user consented to recording — only `true` stamps anything.
      * @param recordingStartedAt ISO-8601 recording start timestamp from the browser.
+     * @param contextUser The caller, on whose behalf the proc runs.
+     * @param provider The server-side database provider the proc runs through.
      */
-    async stampRecordingStart(session, recordingConsent, recordingStartedAt) {
+    async stampRecordingStart(session, recordingConsent, recordingStartedAt, contextUser, provider) {
         if (recordingConsent !== true || !recordingStartedAt) {
             return;
         }
@@ -2197,10 +2253,16 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             return;
         }
         session.RecordingStartedAt = startedAt;
-        session.RecordingMedia = 'Audio';
         if (!(await session.Save())) {
             LogError(`RealtimeClientSessionResolver.stampRecordingStart save failed for session ${session.ID}: ${this.describeSaveFailure(session)}`);
         }
+        try {
+            await new SqlRealtimeRecordingLedger(provider, contextUser).StampFile(session.ID, { media: 'Audio', startedAt });
+        }
+        catch (error) {
+            LogError(`RealtimeClientSessionResolver.stampRecordingStart media stamp failed for session ${session.ID}: ` +
+                `${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     /**
      * Persists a single transcript turn as a `Conversation Detail` stamped with the session's
@@ -2212,6 +2274,9 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
     async persistTranscriptTurn(session, role, text, contextUser, provider, utteranceStartMs, utteranceEndMs) {
         const detail = await provider.GetEntityObject(CONVERSATION_DETAIL_ENTITY, contextUser);
         detail.NewRecord();
+        // The agent's side of the session's transcript is written here, on the server, for the session's owner
+        // (the user's side is theirs and the marker does not touch it).
+        detail.MarkServerAuthoredReply();
         detail.ConversationID = session.ConversationID;
         detail.BranchID = this.sessionBranchIdOf(session);
         detail.Role = this.mapTranscriptRole(role);
@@ -2271,6 +2336,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
             ExtraFilter: `AgentSessionID='${session.ID}' AND Role='${mappedRole}'`,
             OrderBy: '__mj_CreatedAt DESC',
             MaxRows: 1,
+            SkipTotalRowCount: true,
             ResultType: 'entity_object',
         }, writeUser);
         const found = result.Success ? (result.Results?.[0] ?? null) : null;
@@ -2286,6 +2352,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
         // always used `GetEntityObject`; this now matches it, which is also why they now succeed
         // and fail for the same reasons.
         const previous = await provider.GetEntityObject(CONVERSATION_DETAIL_ENTITY, writeUser);
+        previous.MarkServerAuthoredReply(); // as persistTranscriptTurn: the session's own transcript turn
         if (!(await previous.Load(found.ID))) {
             LogError(`RealtimeClientSessionResolver.replacePreviousTranscriptTurn could not re-load turn `
                 + `${found.ID} for session ${session.ID}; the transcript keeps its shorter text.`);
@@ -2320,6 +2387,23 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
     mapTranscriptRole(role) {
         return role.trim().toLowerCase() === 'user' ? 'User' : 'AI';
     }
+    /**
+     * True when the session's conversation belongs to the caller. In client-direct mode the agent's
+     * words and tool facts reach the server only from the browser, so the server can't vouch for them:
+     * they are stored as the agent's reply only in the caller's own conversation (A19). In a
+     * conversation shared with the caller, only the caller's own side of the session is kept.
+     */
+    async callerOwnsConversation(session, contextUser, provider) {
+        if (!session.ConversationID) {
+            return false;
+        }
+        const conversation = await provider.GetEntityObject('MJ: Conversations', contextUser);
+        const owned = (await conversation.Load(session.ConversationID)) && UUIDsEqual(conversation.UserID, contextUser.ID);
+        if (!owned) {
+            LogStatus(`RealtimeClientSessionResolver: session ${session.ID} relays the agent's side only into the caller's own conversation; conversation ${session.ConversationID} is not the caller's, so the agent's turn is not stored.`);
+        }
+        return owned;
+    }
     /**
      * 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,
@@ -2344,12 +2428,13 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      * runs, the relayed dispatch itself) — never this one.
      */
     async persistDirectActionTurn(session, callId, toolName, argsJson, resultJson, durationMs, contextUser, provider) {
-        if (!session.ConversationID) {
+        if (!(await this.callerOwnsConversation(session, contextUser, provider))) {
             return false;
         }
         try {
             const detail = await provider.GetEntityObject(CONVERSATION_DETAIL_ENTITY, contextUser);
             detail.NewRecord();
+            detail.MarkServerAuthoredReply(); // the tool's facts are recorded by the server, as the session's owner
             detail.ConversationID = session.ConversationID;
             detail.BranchID = this.sessionBranchIdOf(session);
             detail.Role = 'AI';