@memberjunction/server 6.2.0-edge.0 → 6.2.0-edge.2

package/dist/resolvers/RunAIAgentResolver.js

@@ -18,10 +18,11 @@ import { AgentRunner, ArtifactToolManager } from '@memberjunction/ai-agents';
 import { ConversationUtility } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
 import { ResolverBase } from '../generic/ResolverBase.js';
-import { startLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
+import { AgentRunStatusPublisher } from './AgentRunStatusPublisher.js';
+import { StartLivenessPulse } from '../generic/FireAndForgetHeartbeat.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadWriteProvider } from '../util.js';
-import { resolveWidgetGuestRunContext, elevateUserPayload } from '../realtimeWidget/widgetGuestElevation.js';
+import { ResolveWidgetGuestRunContext, ElevateUserPayload } from '../realtimeWidget/widgetGuestElevation.js';
 import { SafeJSONParse, UUIDsEqual } from '@memberjunction/global';
 import { GetAttachmentService } from '@memberjunction/aiengine';
 import { NotificationEngine } from '@memberjunction/notifications';
@@ -33,6 +34,10 @@ import { NotificationEngine } from '@memberjunction/notifications';
  * pre-existing per-call MAX_INLINE_ARTIFACT_CHARS / maxInlineChars constants.
  */
 const INLINE_SIZE_CAP = 100 * 1024;
+/** Progress metadata is an untyped bag. A run is an object that carries an ID field. */
+function isAgentRunEntity(value) {
+    return typeof value === 'object' && value !== null && 'ID' in value;
+}
 let AIAgentRunResult = class AIAgentRunResult {
 };
 __decorate([
@@ -277,101 +282,6 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
         }
         return agentEntity;
     }
-    /**
-     * Create streaming progress callback
-     */
-    createProgressCallback(pubSub, sessionId, userPayload, agentRunRef) {
-        return (progress) => {
-            // Capture the agent run into the ref as soon as any progress event carries it (even
-            // "noise" steps), so the fire-and-forget liveness pulse can read its id/status mid-run
-            // rather than only after RunAgentInConversation returns.
-            if (progress.metadata?.agentRun) {
-                agentRunRef.current = progress.metadata.agentRun;
-            }
-            // Only publish progress for significant steps (not initialization noise)
-            const significantSteps = ['prompt_execution', 'action_execution', 'subagent_execution', 'decision_processing'];
-            if (!significantSteps.includes(progress.step)) {
-                console.log(`🔇 Skipping noise progress: ${progress.step}`);
-                return;
-            }
-            // Get the agent run from the progress metadata or use the ref
-            const agentRun = progress.metadata?.agentRun || agentRunRef.current;
-            if (!agentRun) {
-                console.error('❌ No agent run available for progress callback');
-                return;
-            }
-            console.log('📡 Publishing progress update:', {
-                step: progress.step,
-                percentage: progress.percentage,
-                message: progress.message,
-                sessionId,
-                agentRunId: agentRun.ID
-            });
-            // Publish progress updates with the full serialized agent run
-            const progressMsg = {
-                sessionId,
-                agentRunId: agentRun.ID,
-                type: 'progress',
-                agentRun: agentRun.GetAll(), // Serialize the full agent run
-                progress: {
-                    currentStep: progress.step,
-                    percentage: progress.percentage,
-                    message: progress.message,
-                    agentName: progress.metadata?.agentName || undefined,
-                    agentType: progress.metadata?.agentType || undefined,
-                    stepCount: progress.metadata?.stepCount || undefined,
-                    hierarchicalStep: progress.metadata?.hierarchicalStep || undefined
-                },
-                timestamp: new Date()
-            };
-            this.PublishProgressUpdate(pubSub, progressMsg, userPayload);
-        };
-    }
-    PublishProgressUpdate(pubSub, data, userPayload) {
-        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
-            resolver: 'RunAIAgentResolver',
-            type: 'ExecutionProgress',
-            status: 'ok',
-            data,
-        }), userPayload);
-    }
-    PublishStreamingUpdate(pubSub, data, userPayload) {
-        this.PublishStatusUpdate(pubSub, userPayload.sessionId, JSON.stringify({
-            resolver: 'RunAIAgentResolver',
-            type: 'StreamingContent',
-            status: 'ok',
-            data,
-        }), userPayload);
-    }
-    /**
-     * Create streaming content callback
-     */
-    createStreamingCallback(pubSub, sessionId, userPayload, agentRunRef) {
-        return (chunk) => {
-            // Use the agent run from the ref
-            const agentRun = agentRunRef.current;
-            if (!agentRun) {
-                console.error('❌ No agent run available for streaming callback');
-                return;
-            }
-            // Publish streaming content with the full serialized agent run
-            const streamMsg = {
-                sessionId,
-                agentRunId: agentRun.ID,
-                type: 'streaming',
-                agentRun: agentRun.GetAll(), // Include the full serialized agent run
-                streaming: {
-                    content: chunk.content,
-                    isPartial: !chunk.isComplete,
-                    stepName: chunk.stepType,
-                    agentName: chunk.modelName,
-                    kind: chunk.kind
-                },
-                timestamp: new Date()
-            };
-            this.PublishStreamingUpdate(pubSub, streamMsg, userPayload);
-        };
-    }
     /**
      * Internal method that handles the core AI agent execution logic.
      * This method is called by both the regular and system user resolvers.
@@ -389,7 +299,10 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
      *  The framework intersects them with the agent's accepted skills AND the user's Run permission. */
     requestedSkillIDs, 
     /** JSON `{ paused?: boolean }` — seeds `$.debug` on a submitted task graph at insert. */
-    taskGraphDebug) {
+    taskGraphDebug, 
+    /** History floor for a conversation run — threaded into ExecuteAgentParams.ConversationHistoryFrom,
+     *  so the framework's own conversation reads (retrieval tools, artifacts, compaction) honour it too. */
+    conversationHistoryFrom) {
         const startTime = Date.now();
         // Best-effort handle for persistInFlightAgentFailure. Populated from a
         // progress event carrying metadata.agentRun, or from the successful
@@ -421,6 +334,10 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
             // singleton's transaction state with concurrent requests (e.g. conversation deletes).
             const agentRunner = new AgentRunner(p);
             console.log(`🚀 Starting agent execution with sessionId: ${sessionId}`);
+            // The publisher owns every status message. The resolver still copies the run into
+            // agentRunRef, including noise steps, for the fire-and-forget liveness pulse.
+            const statusPublisher = new AgentRunStatusPublisher(pubSub, userPayload, sessionId);
+            const publishProgress = statusPublisher.OnProgress;
             // Execute the agent in conversation context - handles conversation, artifacts, etc.
             const conversationResult = await agentRunner.RunAgentInConversation({
                 agent: agentEntity,
@@ -428,14 +345,21 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
                 payload: payload ? SafeJSONParse(payload) : undefined,
                 contextUser: currentUser,
                 sessionID: sessionId,
-                onProgress: this.createProgressCallback(pubSub, sessionId, userPayload, agentRunRef),
-                onStreaming: this.createStreamingCallback(pubSub, sessionId, userPayload, agentRunRef),
+                onProgress: (progress) => {
+                    const fromEvent = progress.metadata?.agentRun;
+                    if (isAgentRunEntity(fromEvent)) {
+                        agentRunRef.current = fromEvent;
+                    }
+                    publishProgress(progress);
+                },
+                onStreaming: statusPublisher.OnStreaming,
                 lastRunId: lastRunId,
                 autoPopulateLastRunPayload: autoPopulateLastRunPayload,
                 configurationId: configurationId,
                 planMode: planMode,
                 requestedSkillIDs: requestedSkillIDs,
                 taskGraphDebug: parseTaskGraphDebug(taskGraphDebug),
+                ConversationHistoryFrom: conversationHistoryFrom,
                 data: parsedData,
                 context: {
                     dataSource: dataSource
@@ -488,7 +412,7 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
             const sanitizedResult = this.sanitizeAgentResult(result);
             const returnResult = JSON.stringify(sanitizedResult);
             // Publish final events with enriched result data for fire-and-forget clients
-            this.publishFinalEvents(pubSub, sessionId, userPayload, result, returnResult);
+            statusPublisher.PublishFinal(result, result.agentRun?.ConversationDetailID, returnResult);
             // Log completion
             if (result.success) {
                 LogStatus(`=== AI AGENT RUN COMPLETED FOR: ${agentEntity.Name} (${executionTime}ms) ===`);
@@ -550,7 +474,8 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
                     detail.Message = errorMessage;
                     detail.Error = errorMessage;
                     if (!(await detail.Save())) {
-                        LogError(`Failed to persist Error on conversation detail ${conversationDetailId}`);
+                        LogError(`Failed to persist Error on conversation detail ${conversationDetailId}: ` +
+                            `${detail.LatestResult?.CompleteMessage?.trim() || 'no failure detail recorded'}`);
                     }
                 }
             }
@@ -559,48 +484,6 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
             LogError(`persistInFlightAgentFailure failed: ${persistError}`, undefined, persistError);
         }
     }
-    /**
-     * Publish final streaming events (partial result and completion).
-     * The completion event includes the full result JSON so clients using
-     * fire-and-forget mode can receive the result via WebSocket.
-     */
-    publishFinalEvents(pubSub, sessionId, userPayload, result, resultJson) {
-        if (result.agentRun) {
-            // Get the last step from agent run
-            let lastStep = 'Completed';
-            if (result.agentRun?.Steps && result.agentRun.Steps.length > 0) {
-                // Get the last step from the Steps array
-                const lastStepEntity = result.agentRun.Steps[result.agentRun.Steps.length - 1];
-                lastStep = lastStepEntity?.StepName || 'Completed';
-            }
-            // Publish partial result
-            const partialResult = {
-                currentStep: lastStep,
-                partialOutput: result.payload || undefined
-            };
-            const partialMsg = {
-                sessionId,
-                agentRunId: result.agentRun.ID,
-                type: 'partial_result',
-                partialResult,
-                timestamp: new Date()
-            };
-            this.PublishStreamingUpdate(pubSub, partialMsg, userPayload);
-        }
-        // Publish completion with conversationDetailId for client-side routing.
-        // Include result data so fire-and-forget clients can receive the full result via WebSocket.
-        const completionData = {
-            sessionId,
-            agentRunId: result.agentRun?.ID || 'unknown',
-            type: 'complete',
-            timestamp: new Date(),
-            conversationDetailId: result.agentRun?.ConversationDetailID,
-            success: result.success,
-            errorMessage: result.agentRun?.ErrorMessage || undefined,
-            result: resultJson || undefined
-        };
-        this.PublishStreamingUpdate(pubSub, completionData, userPayload);
-    }
     /**
      * Public mutation for regular users to run AI agents with authentication.
      * Supports fire-and-forget mode to avoid Azure proxy timeouts on long-running agent executions.
@@ -808,7 +691,7 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
      * @param agentId - The agent to execute
      * @param maxHistoryMessages - Maximum number of history messages to include (default: 20)
      */
-    async RunAIAgentFromConversationDetail(conversationDetailId, agentId, { userPayload, providers, dataSource }, sessionId, pubSub, maxHistoryMessages, data, payload, lastRunId, autoPopulateLastRunPayload, configurationId, createArtifacts, createNotification, sourceArtifactId, sourceArtifactVersionId, fireAndForget, planMode, requestedSkillIDs) {
+    async RunAIAgentFromConversationDetail(conversationDetailId, agentId, { userPayload, providers, dataSource }, sessionId, pubSub, maxHistoryMessages, data, payload, lastRunId, autoPopulateLastRunPayload, configurationId, createArtifacts, createNotification, sourceArtifactId, sourceArtifactVersionId, fireAndForget, planMode, requestedSkillIDs, agentHistoryFrom) {
         // Check API key scope authorization for agent execution
         await this.CheckAPIKeyScopeAuthorization('agent:execute', agentId, userPayload);
         const p = GetReadWriteProvider(providers);
@@ -827,10 +710,12 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
         // Conversation OWNERSHIP is still enforced under the guest principal below: the guest loads its
         // own ConversationDetail through the Widget Guest RLS filters, so a detail id from another
         // session resolves to "not found" before any elevated work happens.
-        const widgetElevation = await resolveWidgetGuestRunContext(userPayload, p);
-        const effectiveAgentId = widgetElevation ? widgetElevation.pinnedAgentId : agentId;
-        const effectiveUserPayload = widgetElevation ? elevateUserPayload(userPayload, widgetElevation.elevatedUser) : userPayload;
+        const widgetElevation = await ResolveWidgetGuestRunContext(userPayload, p);
+        const effectiveAgentId = widgetElevation ? widgetElevation.PinnedAgentId : agentId;
+        const effectiveUserPayload = widgetElevation ? ElevateUserPayload(userPayload, widgetElevation.ElevatedUser) : userPayload;
         try {
+            // Parsed before anything loads: a floor the caller asked for must never be dropped.
+            const historyFrom = parseAgentHistoryFrom(agentHistoryFrom);
             // LATENCY OPTIMIZATION (Opt #2 + #3): Load ConversationDetail once here to extract
             // conversationId, then pass it downstream. Previously this record was loaded multiple
             // times: once in loadConversationHistoryWithAttachments (just to get conversationId),
@@ -845,13 +730,14 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
             const messages = await this.loadConversationHistoryWithAttachments(conversationId, currentUser, maxHistoryMessages || 20, p, 
             // The UI creates the agent-response placeholder row ('⏳ ...') before invoking
             // this mutation — exclude it so the model never sees an empty assistant turn.
-            [conversationDetailId]);
+            [conversationDetailId], historyFrom);
             // Convert to JSON string for the existing executeAIAgent method
             const messagesJson = JSON.stringify(messages);
             if (fireAndForget) {
                 // Fire-and-forget mode: start execution in background, return immediately.
                 // The client will receive the result via WebSocket PubSub completion event.
-                this.executeAgentInBackground(p, dataSource, effectiveAgentId, effectiveUserPayload, messagesJson, sessionId, pubSub, data, payload, lastRunId, autoPopulateLastRunPayload, configurationId, conversationDetailId, createArtifacts || false, createNotification || false, sourceArtifactId, sourceArtifactVersionId, conversationId, planMode, requestedSkillIDs);
+                this.executeAgentInBackground(p, dataSource, effectiveAgentId, effectiveUserPayload, messagesJson, sessionId, pubSub, data, payload, lastRunId, autoPopulateLastRunPayload, configurationId, conversationDetailId, createArtifacts || false, createNotification || false, sourceArtifactId, sourceArtifactVersionId, conversationId, planMode, requestedSkillIDs, undefined, // taskGraphDebug
+                historyFrom);
                 LogStatus(`🔥 Fire-and-forget: Agent ${effectiveAgentId} execution started in background for session ${sessionId}`);
                 return {
                     success: true,
@@ -862,7 +748,8 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
             return this.executeAIAgent(p, dataSource, effectiveAgentId, effectiveUserPayload, messagesJson, sessionId, pubSub, data, payload, undefined, // templateData
             lastRunId, autoPopulateLastRunPayload, configurationId, conversationDetailId, createArtifacts || false, createNotification || false, sourceArtifactId, sourceArtifactVersionId, conversationId, // LATENCY OPT #2: pass pre-resolved conversationId
             undefined, // runRef
-            planMode, requestedSkillIDs);
+            planMode, requestedSkillIDs, undefined, // taskGraphDebug
+            historyFrom);
         }
         catch (error) {
             const errorMessage = error.message || 'Unknown error loading conversation history';
@@ -1028,10 +915,12 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
     /** Per-request Plan Mode toggle — threaded through to ExecuteAgentParams.planMode. */
     planMode, 
     /** Skill IDs the user requested — threaded through to ExecuteAgentParams.requestedSkillIDs. */
-    requestedSkillIDs, taskGraphDebug) {
+    requestedSkillIDs, taskGraphDebug, 
+    /** History floor — threaded through to ExecuteAgentParams.ConversationHistoryFrom. */
+    conversationHistoryFrom) {
         // Ref the liveness pulse reads to enrich heartbeats once the run is created.
         const runRef = { current: null };
-        const pulse = startLivenessPulse({
+        const pulse = StartLivenessPulse({
             pubSub,
             sessionId,
             ownerUserId: userPayload.userRecord.ID,
@@ -1041,24 +930,15 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
                 : undefined,
         });
         // Execute in background - errors are handled within, not propagated
-        this.executeAIAgent(p, dataSource, agentId, userPayload, messagesJson, sessionId, pubSub, data, payload, undefined, lastRunId, autoPopulateLastRunPayload, configurationId, conversationDetailId, createArtifacts, createNotification, sourceArtifactId, sourceArtifactVersionId, conversationId, runRef, planMode, requestedSkillIDs, taskGraphDebug).catch((error) => {
+        this.executeAIAgent(p, dataSource, agentId, userPayload, messagesJson, sessionId, pubSub, data, payload, undefined, lastRunId, autoPopulateLastRunPayload, configurationId, conversationDetailId, createArtifacts, createNotification, sourceArtifactId, sourceArtifactVersionId, conversationId, runRef, planMode, requestedSkillIDs, taskGraphDebug, conversationHistoryFrom).catch((error) => {
             // Background execution failed unexpectedly (executeAIAgent has its own try-catch,
             // so this would only fire for truly unexpected errors).
             const errorMessage = (error instanceof Error) ? error.message : 'Unknown background execution error';
             LogError(`🔥 Fire-and-forget background execution failed: ${errorMessage}`, undefined, error);
-            // Publish error completion event so the client knows the agent failed
-            const errorCompletionData = {
-                sessionId,
-                agentRunId: 'unknown',
-                type: 'complete',
-                timestamp: new Date(),
-                conversationDetailId,
-                success: false,
-                errorMessage,
-                result: JSON.stringify({ success: false, errorMessage })
-            };
-            this.PublishStreamingUpdate(pubSub, errorCompletionData, userPayload);
-        }).finally(() => pulse.stop());
+            // Publish error completion event so the client knows the agent failed.
+            // The publisher is created inside executeAIAgent, which rejected before returning one.
+            new AgentRunStatusPublisher(pubSub, userPayload, sessionId).PublishFailure(conversationDetailId, errorMessage);
+        }).finally(() => pulse.Stop());
     }
     /**
      * Load conversation history with attachments from database.
@@ -1074,18 +954,20 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
      *
      * Opt #8: Switched from ResultType 'entity_object' to 'simple' with explicit Fields.
      * The history query only needs the window-assembly fields (ConversationWindowFields:
-     * ID, Sequence, Role, Message, SummaryOfEarlierConversation) from each
+     * ID, Sequence, Role, Message, SummaryOfEarlierConversation, __mj_CreatedAt) from each
      * ConversationDetail record. Using 'entity_object' created full BaseEntity instances
      * with getters/setters, dirty tracking, and validation — none of which are needed for
      * read-only history assembly. The 'simple' result type returns plain JS objects,
      * reducing per-record overhead (~30ms total savings).
      */
-    async loadConversationHistoryWithAttachments(conversationId, contextUser, maxMessages, provider, excludeDetailIds) {
+    async loadConversationHistoryWithAttachments(conversationId, contextUser, maxMessages, provider, excludeDetailIds, 
+    /** History floor: only rows written at or after it are loaded, and no summary is used. */
+    historyFrom) {
         // Context windowing (summary boundary + raw tail, or legacy last-N when no
         // summary exists) shares ONE fold implementation with all other callers —
         // ConversationEngine.AssembleContextWindow — and the ROWS come from the
         // single-sourced fresh-per-request loader (same one the compaction pass uses).
-        // Three deliberate properties vs. the engine's cached GetAgentContextWindow:
+        // Four deliberate properties vs. the engine's cached GetAgentContextWindow:
         //   1. Entity RLS applies (the engine path loads via a stored query with no
         //      row-level security — wrong for guest/widget-scoped users), and the
         //      process-global per-conversation cache — keyed by conversation, not user —
@@ -1094,10 +976,13 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
         //      cross-server staleness (a warm cache misses rows written by other nodes).
         //   3. Load failure THROWS → the mutation fails, instead of silently running
         //      the agent against zero history.
-        const rows = await ConversationEngine.LoadWindowRowsFresh(conversationId, contextUser, provider);
+        //   4. A history floor (`historyFrom`) is applied in the query, so rows before it never
+        //      leave the database, and again in the assembly, which then skips the summary.
+        const rows = await ConversationEngine.LoadWindowRowsFresh(conversationId, contextUser, provider, historyFrom);
         const window = ConversationEngine.AssembleContextWindow(rows, {
             maxTailMessages: maxMessages,
-            excludeDetailIds
+            excludeDetailIds,
+            historyFrom
         });
         // Batch load input artifacts for the windowed messages. Since the backfill migration
         // (V202605271400__Backfill_Attachment_Artifacts) converted all legacy
@@ -1144,19 +1029,19 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
             const ext = fileName.includes('.') ? fileName.split('.').pop() : undefined;
             const artifactType = ArtifactMetadataEngine.Instance.GetArtifactTypeByMimeType(artifactMime, ext);
             const decision = RouteArtifact({
-                typeDefault: artifactType?.DefaultDeliveryMode ?? 'ToolsOnly',
-                forceToolsOnly: artifactVersion.ForceToolsOnly,
+                TypeDefault: artifactType?.DefaultDeliveryMode ?? 'ToolsOnly',
+                ForceToolsOnly: artifactVersion.ForceToolsOnly,
                 mimeType: artifactMime,
-                sizeBytes: artifactVersion.ContentSizeBytes ?? 0,
-                inlineSizeCap: INLINE_SIZE_CAP,
-                modelSupportsModality: () => true,
-                modelName: '<resolver>',
-                artifactTypeName: artifactType?.Name ?? artifactMime,
+                SizeBytes: artifactVersion.ContentSizeBytes ?? 0,
+                InlineSizeCap: INLINE_SIZE_CAP,
+                ModelSupportsModality: () => true,
+                ModelName: '<resolver>',
+                ArtifactTypeName: artifactType?.Name ?? artifactMime,
             });
             if (artifactVersion.ContentMode === 'File' && artifactVersion.FileID) {
                 if (decision.delivery !== 'inline') {
-                    if (decision.delivery === 'tools' && decision.annotation) {
-                        LogStatus(`[RunAIAgentResolver] ${decision.annotation}`);
+                    if (decision.delivery === 'tools' && decision.Annotation) {
+                        LogStatus(`[RunAIAgentResolver] ${decision.Annotation}`);
                     }
                     continue;
                 }
@@ -1175,8 +1060,8 @@ let RunAIAgentResolver = class RunAIAgentResolver extends ResolverBase {
                 // Text-mode artifact (ContentMode = 'Text'). Honor the
                 // routing decision the same way as for file-mode.
                 if (decision.delivery !== 'inline') {
-                    if (decision.delivery === 'tools' && decision.annotation) {
-                        LogStatus(`[RunAIAgentResolver] ${decision.annotation}`);
+                    if (decision.delivery === 'tools' && decision.Annotation) {
+                        LogStatus(`[RunAIAgentResolver] ${decision.Annotation}`);
                     }
                     continue;
                 }
@@ -1365,8 +1250,9 @@ __decorate([
     __param(15, Arg('fireAndForget', { nullable: true })),
     __param(16, Arg('planMode', { nullable: true })),
     __param(17, Arg('requestedSkillIDs', () => [String], { nullable: true })),
+    __param(18, Arg('agentHistoryFrom', { nullable: true })),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, Object, String, PubSubEngine, Number, String, String, String, Boolean, String, Boolean, Boolean, String, String, Boolean, Boolean, Array]),
+    __metadata("design:paramtypes", [String, String, Object, String, PubSubEngine, Number, String, String, String, Boolean, String, Boolean, Boolean, String, String, Boolean, Boolean, Array, String]),
     __metadata("design:returntype", Promise)
 ], RunAIAgentResolver.prototype, "RunAIAgentFromConversationDetail", null);
 __decorate([
@@ -1395,6 +1281,21 @@ RunAIAgentResolver = __decorate([
     Resolver()
 ], RunAIAgentResolver);
 export { RunAIAgentResolver };
+/**
+ * Reads the `agentHistoryFrom` argument of `RunAIAgentFromConversationDetail`: an ISO-8601
+ * timestamp. Absent means no floor. A value that is present but not a timestamp throws — a
+ * floor the caller asked for must fail the request, never be dropped, since dropping it lets
+ * the run read the history it was meant to keep out.
+ */
+function parseAgentHistoryFrom(raw) {
+    if (raw == null)
+        return undefined;
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`agentHistoryFrom must be an ISO-8601 timestamp; received "${raw}"`);
+    }
+    return parsed;
+}
 function parseTaskGraphDebug(raw) {
     if (!raw)
         return undefined;