@memberjunction/server 6.2.0-edge.4 → 6.2.0-edge.6

package/dist/resolvers/RealtimeClientSessionResolver.js

@@ -49,7 +49,7 @@ import { 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';
@@ -60,6 +60,8 @@ import { ResolveWidgetGuestRunContext, ResolveScopedAnonymousRunUser, ResolveRec
 import { RunWithTrustedSessionConfigWrites } from '@memberjunction/core-entities-server';
 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,7 +74,6 @@ const SIGNIFICANT_PROGRESS_STEPS = ['prompt_execution', 'action_execution', 'sub
  */
 const MAX_USAGE_DETAILS_JSON_LENGTH = 4096;
 /** 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';
@@ -247,7 +248,7 @@ export { CancelRealtimeSessionToolResult };
  * Result of {@link RealtimeClientSessionResolver.UploadRealtimeRecording} — a structured
  * success/failure envelope. A recording-storage failure must never throw to the browser (the
  * session it belongs to has already ended), so problems come back as `Success: false` with a
- * human-readable reason; only ownership/authn violations (from `loadOwnedSession`) still throw.
+ * human-readable reason; only ownership/authn violations (from `LoadOwnedRealtimeSession`) still throw.
  */
 let UploadRealtimeRecordingResult = class UploadRealtimeRecordingResult {
 };
@@ -402,7 +403,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-
@@ -452,10 +453,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) {
@@ -626,11 +634,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.
@@ -642,7 +653,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
@@ -658,7 +669,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      * the call and uploads the assembled blob (base64) once the session ends.
      *
      * Hard gates (in order):
-     * 1. Ownership — `loadOwnedSession` enforces `UserID === contextUser.ID` (throws on violation).
+     * 1. Ownership — `LoadOwnedRealtimeSession` enforces `UserID === contextUser.ID` (throws on violation).
      * 2. Consent — `consent !== true` is a hard refusal: no audio is ever stored without it.
      * 3. Storage configuration — the session's agent must resolve a recording storage account (the
      *    agent's `RecordingStorageProviderID`, else `AttachmentStorageProviderID`).
@@ -678,7 +689,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      */
     async UploadRealtimeRecording(agentSessionId, audioBase64, mimeType, ctx, durationMs, consent, peaks) {
         const { contextUser, provider } = this.requireUserAndProvider(ctx.userPayload, ctx.providers);
-        const session = await this.loadOwnedSession(agentSessionId, contextUser, provider);
+        const session = await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
         // HARD consent gate — no audio is ever stored without an explicit grant.
         if (consent !== true) {
             return { Success: false, ErrorMessage: 'Recording consent was not granted.' };
@@ -714,15 +725,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) {
@@ -751,7 +768,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
     async UploadRealtimeRecordingSegment(agentSessionId, segmentIndex, audioBase64, mimeType, ctx) {
         try {
             const { contextUser, provider } = this.requireUserAndProvider(ctx.userPayload, ctx.providers);
-            const session = await this.loadOwnedSession(agentSessionId, contextUser, provider);
+            const session = await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
             // The consolidated recording already landed and its upload deleted the shards; a shard
             // arriving now (one still on the wire at hang-up) would be an orphan nothing deletes.
             if (session.RecordingFileID) {
@@ -842,7 +859,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      */
     async CancelRealtimeSessionTool(agentSessionId, { userPayload, providers }, callId) {
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
-        await this.loadOwnedSession(agentSessionId, contextUser, provider);
+        await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
         try {
             const aborted = this.clientSessionService.CancelInFlightDelegations(agentSessionId, callId);
             return { AbortedCount: aborted, Success: true };
@@ -882,7 +899,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      */
     async RelayRealtimeUsage(agentSessionId, inputTokens, outputTokens, { userPayload, providers }, usageDetailsJson) {
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
-        const session = await this.loadOwnedSession(agentSessionId, contextUser, provider);
+        const session = await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
         const inputDelta = this.clampTokenDelta(inputTokens);
         const outputDelta = this.clampTokenDelta(outputTokens);
         const details = this.readUsageDetails(usageDetailsJson);
@@ -984,7 +1001,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      */
     async SaveSessionChannelState(agentSessionId, channelName, stateJson, { userPayload, providers }) {
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
-        const session = await this.loadOwnedSession(agentSessionId, contextUser, provider);
+        const session = await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
         if (!this.isChannelInSessionScope(session, channelName)) {
             LogError(`SaveSessionChannelState: channel '${channelName}' is not in session ${agentSessionId}'s resolved scope — state not saved.`);
             return false;
@@ -1050,7 +1067,7 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      */
     async SaveSessionChannelArtifact(agentSessionId, channelName, name, contentJson, { userPayload, providers }) {
         const { contextUser, provider } = this.requireUserAndProvider(userPayload, providers);
-        const session = await this.loadOwnedSession(agentSessionId, contextUser, provider);
+        const session = await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
         if (!this.isChannelInSessionScope(session, channelName)) {
             const message = `SaveSessionChannelArtifact: channel '${channelName}' is not in session ${agentSessionId}'s resolved scope — nothing saved.`;
             LogError(message);
@@ -1456,29 +1473,12 @@ let RealtimeClientSessionResolver = class RealtimeClientSessionResolver extends
      * `Closed`. Throws on any violation. Returns the loaded session for the caller to read from.
      */
     async loadOwnedActiveSession(agentSessionId, contextUser, provider) {
-        const session = await this.loadOwnedSession(agentSessionId, contextUser, provider);
+        const session = await LoadOwnedRealtimeSession(agentSessionId, contextUser, provider);
         if (session.Status === 'Closed') {
             throw new Error(`Realtime session ${agentSessionId} is closed`);
         }
         return session;
     }
-    /**
-     * Loads a session and enforces inbound ownership (`UserID === contextUser.ID`) WITHOUT
-     * rejecting `Closed` sessions — {@link SaveSessionChannelState}'s final on-end flush
-     * legitimately arrives after the session closed. Throws when not found / not owned.
-     */
-    async loadOwnedSession(agentSessionId, contextUser, provider) {
-        const session = await provider.GetEntityObject(SESSION_ENTITY, contextUser);
-        const loaded = await session.Load(agentSessionId);
-        if (!loaded) {
-            throw new Error(`Realtime session ${agentSessionId} not found`);
-        }
-        if (!UUIDsEqual(session.UserID, contextUser.ID)) {
-            LogError(`RealtimeClientSessionResolver: ownership check failed — user ${contextUser.ID} attempted to operate on session ${agentSessionId} owned by ${session.UserID}`);
-            throw new Error('Not authorized: you do not own this realtime session');
-        }
-        return session;
-    }
     /**
      * Resolves an ACTIVE channel definition (`MJ: AI Agent Channels`) by name from
      * {@link AIEngineBase}'s cached `AgentChannels` (provider-scoped engine instance, lazy
@@ -1555,13 +1555,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;
             }
@@ -1731,22 +1732,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;
     }
@@ -1965,6 +1967,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';
@@ -2196,14 +2199,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;
         }
@@ -2213,10 +2223,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
@@ -2228,6 +2244,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);
@@ -2302,6 +2321,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.`);
@@ -2336,6 +2356,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,
@@ -2360,12 +2397,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';