@memberjunction/ai-agents 5.20.0 → 5.22.0

package/dist/base-agent.js

@@ -81,6 +81,13 @@ export class BaseAgent {
          * @private
          */
         this._metadata = new Metadata();
+        /**
+         * Active per-request metadata provider, set at the start of Execute().
+         * Defaults to the global Metadata.Provider; overridden when a per-request
+         * provider is passed through ExecuteAgentParams.provider for server isolation.
+         * @private
+         */
+        this._activeProvider = Metadata.Provider;
         /**
          * This is state information that is specific to the agent type. BaseAgent doesn't know what
          * this contains or care, it is just responsible for keeping this, giving the Agent Type the
@@ -173,6 +180,17 @@ export class BaseAgent {
          * @since 2.123.0
          */
         this._effectiveActions = [];
+        /**
+         * Counts only prompt (LLM) executions, NOT all agent steps.
+         * Used for message expiration age calculations so that `expirationTurns`
+         * semantically means "number of LLM calls" rather than "number of steps"
+         * (which includes actions, loops, sub-agents, etc.).
+         *
+         * Without this, a ForEach loop over 100 items would bump the step counter
+         * by 100, causing messages to expire far too early even though only one
+         * prompt execution occurred after them.
+         */
+        this._promptTurnCount = 0;
         /**
          * Execution limits for dynamically added actions.
          * Maps action IDs to their MaxExecutionsPerRun limit.
@@ -808,6 +826,9 @@ export class BaseAgent {
      * ```
      */
     async Execute(params) {
+        // Capture per-request provider for the duration of this execution so all entity
+        // saves go through the isolated provider, never the global singleton's transaction.
+        this._activeProvider = params.provider || Metadata.Provider;
         try {
             this.logStatus(`🤖 Starting execution of agent '${params.agent.Name}'`, true, params);
             // Check permissions - user must have run permission or be the owner
@@ -1003,8 +1024,10 @@ export class BaseAgent {
             if (params.cancellationToken?.aborted) {
                 throw new Error('Cancelled during execution');
             }
-            // Prune and compact expired messages before executing the next step
-            await this.pruneAndCompactExpiredMessages(params, stepCount);
+            // Prune and compact expired messages before executing the next step.
+            // Uses _promptTurnCount (not stepCount) so expiration is measured in prompt
+            // executions, not all steps (which include actions, loops, sub-agents, etc.)
+            await this.pruneAndCompactExpiredMessages(params, this._promptTurnCount);
             // Execute the current step based on previous decision or initial prompt
             this.logStatus(`🔄 Executing step ${stepCount + 1} for agent '${params.agent.Name}'`, true, params);
             const nextStep = await this.executeNextStep(params, config, currentNextStep, stepCount);
@@ -1584,6 +1607,8 @@ export class BaseAgent {
             promptParams.apiKeys = params.apiKeys;
             this.logStatus(`🔑 Using ${params.apiKeys.length} API key(s) provided at runtime`, true, params);
         }
+        // Thread the per-request provider so prompt run records are saved through the isolated provider
+        promptParams.provider = params.provider || this._activeProvider;
         return promptParams;
     }
     /**
@@ -2815,13 +2840,13 @@ export class BaseAgent {
                 newPayload: payload
             };
         }
-        // Get current step count for age calculations
-        const currentStepCount = this._agentRun?.Steps?.length || 0;
+        // Use prompt turn count for age calculations (not step count)
+        const currentPromptTurn = this._promptTurnCount;
         // Try multiple recovery strategies in order
         const strategies = [
-            () => this.recoveryStrategy_RemoveOldestActionResults(params, tokensToSave, currentStepCount, 5),
-            () => this.recoveryStrategy_CompactOldActionResults(params, tokensToSave, currentStepCount, 3),
-            () => this.recoveryStrategy_RemoveOldestActionResults(params, tokensToSave, currentStepCount, 2),
+            () => this.recoveryStrategy_RemoveOldestActionResults(params, tokensToSave, currentPromptTurn, 5),
+            () => this.recoveryStrategy_CompactOldActionResults(params, tokensToSave, currentPromptTurn, 3),
+            () => this.recoveryStrategy_RemoveOldestActionResults(params, tokensToSave, currentPromptTurn, 2),
             () => this.recoveryStrategy_CompactAllActionResults(params, tokensToSave),
             () => Promise.resolve(this.recoveryStrategy_TrimLastUserMessage(params, tokensToSave))
         ];
@@ -3314,8 +3339,8 @@ The context is now within limits. Please retry your request with the recovered c
     async ExecuteSubAgent(params, subAgentRequest, subAgent, stepEntity, payload, contextMessage, stepCount = 0) {
         try {
             this.logStatus(`🤖 Executing sub-agent '${subAgentRequest.name}'`, true, params);
-            // Create a new AgentRunner instance
-            const runner = new AgentRunner();
+            // Create a new AgentRunner instance with the same isolated provider
+            const runner = new AgentRunner(params.provider || this._activeProvider);
             // Prepare messages for sub-agent using database-configured message mode
             const subAgentMessages = this.prepareSubAgentMessages(params, subAgentRequest, subAgent, contextMessage);
             // Set parent run ID in the sub-agent's execution
@@ -3561,18 +3586,15 @@ The context is now within limits. Please retry your request with the recovered c
         if (!result.success && result.agentRun?.ErrorMessage) {
             lines.push(`**Error:** ${result.agentRun.ErrorMessage}`);
         }
-        // Payload — the actual result data the parent agent cares about
+        // Payload — the actual result data the parent agent cares about.
+        // Not truncated by default — the expiration/compaction lifecycle handles
+        // context window management. Truncating here permanently discards data
+        // before the LLM ever sees it.
         if (result.payload != null) {
             const payloadStr = typeof result.payload === 'string'
                 ? result.payload
                 : JSON.stringify(result.payload);
-            // For very large payloads, truncate to keep context manageable
-            if (payloadStr.length > 4000) {
-                lines.push(`**Payload** (truncated):\n${payloadStr.substring(0, 4000)}…`);
-            }
-            else {
-                lines.push(`**Payload:**\n${payloadStr}`);
-            }
+            lines.push(`**Payload:**\n${payloadStr}`);
         }
         return lines.join('\n');
     }
@@ -3580,14 +3602,19 @@ The context is now within limits. Please retry your request with the recovered c
      * Formats a single output parameter value for inclusion in action result
      * markdown.  Scalars are shown inline with backtick formatting; objects and
      * arrays use compact (single-line) JSON to avoid the indentation overhead
-     * of pretty-printed JSON.  Very long values are truncated.
+     * of pretty-printed JSON.
+     *
+     * By default, values are **not truncated** — the expiration/compaction lifecycle
+     * handles context window management. Truncating at formatting time permanently
+     * discards data before the LLM ever sees it. Pass an explicit maxLength only
+     * when you have a specific reason to limit output size.
      *
      * @param value - The parameter value (any type)
-     * @param maxLength - Maximum character length before truncation (default 500)
+     * @param maxLength - Maximum character length before truncation (0 = no limit, default 0)
      * @returns Formatted string
      * @private
      */
-    formatParamValueForResult(value, maxLength = 500) {
+    formatParamValueForResult(value, maxLength = 0) {
         if (value === null || value === undefined) {
             return '`null`';
         }
@@ -3602,7 +3629,7 @@ The context is now within limits. Please retry your request with the recovered c
             // Compact JSON (no pretty-printing) for objects/arrays
             stringValue = JSON.stringify(value);
         }
-        if (stringValue.length > maxLength) {
+        if (maxLength > 0 && stringValue.length > maxLength) {
             return `${stringValue.substring(0, maxLength)}…`;
         }
         return stringValue;
@@ -3816,8 +3843,10 @@ The context is now within limits. Please retry your request with the recovered c
                 }
             }
         }
+        // Reset prompt turn counter for this execution
+        this._promptTurnCount = 0;
         // Create MJAIAgentRunEntity
-        this._agentRun = await this._metadata.GetEntityObject('MJ: AI Agent Runs', params.contextUser);
+        this._agentRun = await (params.provider || this._activeProvider).GetEntityObject('MJ: AI Agent Runs', params.contextUser);
         this._agentRun.AgentID = params.agent.ID;
         if (params.conversationDetailId) {
             this._agentRun.ConversationDetailID = params.conversationDetailId;
@@ -3970,7 +3999,7 @@ The context is now within limits. Please retry your request with the recovered c
      * @returns {Promise<MJAIAgentRunStepEntityExtended>} - The created step entity
      */
     async createStepEntity(params) {
-        const stepEntity = await this._metadata.GetEntityObject('MJ: AI Agent Run Steps', params.contextUser);
+        const stepEntity = await this._activeProvider.GetEntityObject('MJ: AI Agent Run Steps', params.contextUser);
         stepEntity.AgentRunID = this._agentRun.ID;
         // Step number is based on current count of steps + 1
         stepEntity.StepNumber = (this._agentRun.Steps?.length || 0) + 1;
@@ -4211,8 +4240,7 @@ The context is now within limits. Please retry your request with the recovered c
                 // Check if this is a message expansion request
                 if (previousDecision.messageIndex !== undefined) {
                     // Handle message expansion before retrying
-                    const currentStepCount = this._agentRun?.Steps?.length || 0;
-                    this.executeExpandMessageStep(previousDecision, params, currentStepCount);
+                    this.executeExpandMessageStep(previousDecision, params, this._promptTurnCount);
                 }
                 return await this.executePromptStep(params, config, previousDecision, stepCount);
             case 'Sub-Agent':
@@ -4420,12 +4448,11 @@ The context is now within limits. Please retry your request with the recovered c
             };
             // Execute the prompt
             const promptResult = await this.executePrompt(promptParams);
-            // Remove temporary messages before processing prompt results
-            // This includes loop results and sub-agent completion messages
-            params.conversationMessages = params.conversationMessages.filter(m => {
-                const metadata = m.metadata;
-                return !metadata?._loopResults && !metadata?._subAgentResult;
-            });
+            // Increment prompt-specific turn counter (used for expiration age calculations)
+            this._promptTurnCount++;
+            // Loop and sub-agent results now use the standard expiration/compaction lifecycle
+            // (messageType: 'loop-result' / 'sub-agent-result') instead of being deleted after
+            // one prompt turn. The processMessageExpiration() method handles their lifecycle.
             // Update step entity with AIPromptRun ID if available
             if (promptResult.promptRun?.ID) {
                 stepEntity.TargetLogID = promptResult.promptRun.ID;
@@ -4940,31 +4967,33 @@ The context is now within limits. Please retry your request with the recovered c
                 // This ensures parent agents can override child Chat steps
                 return await this.validateChatNextStep(params, chatStep, mergedPayload, this._agentRun, stepEntity);
             }
-            // Build a clean summary of sub-agent result
-            const subAgentSummary = {
-                agentName: params.agent.Name,
+            // Add user message with the sub-agent results using markdown format
+            // and expiration metadata so it persists across multiple prompt turns
+            const resultMessage = this.formatSubAgentResultAsMarkdown(subAgentRequest.name, subAgentResult);
+            const subAgentMetadata = {
+                turnAdded: this._promptTurnCount,
+                messageType: 'sub-agent-result',
                 subAgentName: subAgentRequest.name,
                 subAgentId: subAgentEntity.ID,
-                success: subAgentResult.success,
-                finalStep: subAgentResult.agentRun?.FinalStep,
-                errorMessage: subAgentResult.agentRun?.ErrorMessage || null
-                // do NOT include payload here as this goes to the LLM and
-                // we don't need that there, too many tokens and LLM already gets
-                // payload the normal way
+                // Default: keep sub-agent results for 3 turns then remove
+                expirationTurns: 3,
+                expirationMode: 'Remove'
             };
-            // Add user message with the sub-agent results
-            const resultMessage = subAgentResult.success
-                ? `Sub-agent completed successfully:\n${JSON.stringify(subAgentSummary, null, 2)}`
-                : `Sub-agent failed:\n${JSON.stringify(subAgentSummary, null, 2)}`;
+            // Apply global override if configured
+            if (params.messageExpirationOverride) {
+                const override = params.messageExpirationOverride;
+                if (override.expirationTurns != null) {
+                    subAgentMetadata.expirationTurns = override.expirationTurns;
+                    subAgentMetadata.expirationMode = override.expirationMode || 'Remove';
+                    subAgentMetadata.compactMode = override.compactMode;
+                    subAgentMetadata.compactLength = override.compactLength;
+                    subAgentMetadata.compactPromptId = override.compactPromptId;
+                }
+            }
             params.conversationMessages.push({
                 role: 'user',
                 content: resultMessage,
-                metadata: {
-                    _temporary: true,
-                    _subAgentResult: true,
-                    subAgentName: subAgentRequest.name,
-                    subAgentId: subAgentEntity.ID
-                }
+                metadata: subAgentMetadata
             });
             // Set PayloadAtEnd with the merged payload
             if (stepEntity) {
@@ -5217,17 +5246,31 @@ The context is now within limits. Please retry your request with the recovered c
                 // This ensures parent agents can override child Chat steps
                 return await this.validateChatNextStep(params, chatStep, mergedPayload, this._agentRun, stepEntity);
             }
-            // Add sub-agent result to conversation as user message
-            const subAgentSummary = {
-                agentName: params.agent.Name,
+            // Add sub-agent result to conversation as user message using markdown format
+            // and expiration metadata so it persists across multiple prompt turns
+            const relatedResultMessage = this.formatSubAgentResultAsMarkdown(subAgentRequest.name, subAgentResult);
+            const relatedMetadata = {
+                turnAdded: this._promptTurnCount,
+                messageType: 'sub-agent-result',
                 subAgentName: subAgentRequest.name,
-                success: subAgentResult.success,
-                payload: subAgentResult.payload,
-                errorMessage: subAgentResult.agentRun?.ErrorMessage
+                subAgentId: subAgentEntity.ID,
+                expirationTurns: 3,
+                expirationMode: 'Remove'
             };
+            if (params.messageExpirationOverride) {
+                const override = params.messageExpirationOverride;
+                if (override.expirationTurns != null) {
+                    relatedMetadata.expirationTurns = override.expirationTurns;
+                    relatedMetadata.expirationMode = override.expirationMode || 'Remove';
+                    relatedMetadata.compactMode = override.compactMode;
+                    relatedMetadata.compactLength = override.compactLength;
+                    relatedMetadata.compactPromptId = override.compactPromptId;
+                }
+            }
             params.conversationMessages.push({
                 role: 'user',
-                content: `Related sub-agent "${subAgentRequest.name}" completed:\n${JSON.stringify(subAgentSummary, null, 2)}`
+                content: relatedResultMessage,
+                metadata: relatedMetadata
             });
             // Update the agent run's current payload
             if (this._agentRun) {
@@ -5676,9 +5719,8 @@ The context is now within limits. Please retry your request with the recovered c
                 }
                 // Only add metadata if we have expiration settings
                 if (minExpirationTurns !== null && expirationMode !== 'None') {
-                    const currentStepCount = this._agentRun?.Steps?.length || 0;
                     metadata = {
-                        turnAdded: currentStepCount,
+                        turnAdded: this._promptTurnCount,
                         messageType: 'action-result',
                         expirationTurns: minExpirationTurns,
                         expirationMode: expirationMode,
@@ -5820,7 +5862,7 @@ The context is now within limits. Please retry your request with the recovered c
             const requestForUserId = this.resolveUserFromStrategy(resolvedStrategy, params);
             const priority = resolvedStrategy?.priority ?? 50;
             const expirationMinutes = resolvedStrategy?.expirationMinutes;
-            const request = await this._metadata.GetEntityObject('MJ: AI Agent Requests', params.contextUser);
+            const request = await (params.provider || this._activeProvider).GetEntityObject('MJ: AI Agent Requests', params.contextUser);
             request.NewRecord();
             request.AgentID = params.agent.ID;
             request.RequestedAt = new Date();
@@ -6297,6 +6339,8 @@ The context is now within limits. Please retry your request with the recovered c
             else if (forEach.subAgent) {
                 const subAgentStep = { step: 'Sub-Agent', subAgent: forEach.subAgent, newPayload: currentPayload, previousPayload: currentPayload };
                 result = await this.processSubAgentStep(params, subAgentStep, parentStepId, item);
+                // Attach formatted summary as priorStepResult so formatLoopResultsAsMarkdown can render it
+                result.priorStepResult = this.formatSubAgentResultAsMarkdown(forEach.subAgent.name, result);
             }
             else {
                 throw new Error('ForEach missing action/subAgent');
@@ -6318,7 +6362,7 @@ The context is now within limits. Please retry your request with the recovered c
         loopStepEntity.PayloadAtEnd = this.serializePayloadAtEnd(loopResults.finalPayload);
         await this.finalizeStepEntity(loopStepEntity, loopResults.errors.length === 0, loopResults.errors.join('\n\n'), loopResults);
         if (this.AgentTypeInstance.InjectLoopResultsAsMessage) {
-            this.injectLoopResultsMessage('ForEach', forEach.collectionPath, loopResults.results, loopResults.errors, params);
+            this.injectLoopResultsMessage('ForEach', forEach.collectionPath, loopResults.results, loopResults.errors, params, forEach.action?.name);
         }
         return {
             step: 'Retry',
@@ -6329,20 +6373,121 @@ The context is now within limits. Please retry your request with the recovered c
         };
     }
     /**
-     * Helper: Inject loop results as temporary message
+     * Helper: Inject loop results into conversation with expiration/compaction metadata.
+     * Uses the same lifecycle as non-loop action results so results persist for N turns
+     * rather than being deleted after a single prompt turn.
      */
-    injectLoopResultsMessage(loopType, collectionOrCondition, results, errors, params) {
-        // grab the priorStepResult from within each result item and put that into a new array
-        const extractedResults = results.map(r => r.priorStepResult);
+    injectLoopResultsMessage(loopType, collectionOrCondition, results, errors, params, actionName) {
         const label = loopType === 'ForEach' ? 'Collection' : 'Condition';
+        const content = `## Loop Completed\n**Type:** ${loopType}\n**${label}:** ${collectionOrCondition}\n` +
+            `**Processed:** ${results.length}, **Errors:** ${errors.length}\n\n` +
+            this.formatLoopResultsAsMarkdown(results, errors);
+        // Resolve expiration metadata from the loop's action config (most-restrictive-wins)
+        const metadata = this.resolveLoopExpirationMetadata(params, actionName);
         params.conversationMessages.push({
             role: 'user',
-            content: `## Loop Completed\n**Type:** ${loopType}\n**${label}:** ${collectionOrCondition}\n` +
-                `**Processed:** ${results.length}, **Errors:** ${errors.length}\n\n` +
-                `**Results:**\n\`\`\`json\n${JSON.stringify(extractedResults, null, 2)}\n\`\`\``,
-            metadata: { _temporary: true, _loopResults: true }
+            content,
+            metadata
         });
     }
+    /**
+     * Formats loop iteration results as markdown. Handles two distinct result shapes
+     * depending on whether the loop body executed actions or sub-agents:
+     *
+     * - **Action iterations**: `priorStepResult` is an `ActionResultSummary[]`, set by
+     *   `executeActionsStep()` (line ~7003). These are formatted via `formatActionResultsAsMarkdown()`.
+     *
+     * - **Sub-agent iterations**: `priorStepResult` is a **pre-formatted markdown string**,
+     *   set by the loop handlers (`executeSingleForEachIteration` / `executeSingleWhileIteration`)
+     *   which call `formatSubAgentResultAsMarkdown()` and assign the result to `priorStepResult`.
+     *   Since the markdown is already rendered upstream, this method simply includes it as-is.
+     *
+     * This two-path design means sub-agent formatting happens at assignment time (in the loop
+     * handler), while action formatting happens at render time (here). Both produce the same
+     * markdown style used by non-loop results, ensuring consistency across the codebase.
+     */
+    formatLoopResultsAsMarkdown(results, errors) {
+        const lines = [];
+        for (let i = 0; i < results.length; i++) {
+            const iterResult = results[i].priorStepResult;
+            // Action iterations: priorStepResult is ActionResultSummary[] — format via shared helper
+            if (Array.isArray(iterResult)) {
+                lines.push(`### Iteration ${i + 1}`);
+                lines.push(this.formatActionResultsAsMarkdown(iterResult));
+            }
+            else if (iterResult != null) {
+                // Sub-agent iterations: priorStepResult is already a markdown string from
+                // formatSubAgentResultAsMarkdown() called in the loop handler. Non-string
+                // results (edge cases) are JSON-stringified as a fallback.
+                lines.push(`### Iteration ${i + 1}`);
+                const text = typeof iterResult === 'string'
+                    ? iterResult
+                    : JSON.stringify(iterResult);
+                lines.push(text);
+            }
+            // null/undefined priorStepResult: iteration produced no output — skip silently
+        }
+        if (errors.length > 0) {
+            lines.push(`### Errors`);
+            for (const err of errors) {
+                const errMsg = typeof err === 'string' ? err : err?.message || JSON.stringify(err);
+                lines.push(`• ✗ ${errMsg}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Resolves expiration/compaction metadata for loop result messages by looking up
+     * the loop's action config. Uses the same most-restrictive-wins logic as
+     * non-loop action result metadata resolution.
+     */
+    resolveLoopExpirationMetadata(params, actionName) {
+        const baseMetadata = {
+            turnAdded: this._promptTurnCount,
+            messageType: 'loop-result'
+        };
+        // Check for global override first
+        if (params.messageExpirationOverride) {
+            const override = params.messageExpirationOverride;
+            if (override.expirationTurns != null && override.expirationMode !== 'None') {
+                return {
+                    ...baseMetadata,
+                    expirationTurns: override.expirationTurns,
+                    expirationMode: override.expirationMode || 'Remove',
+                    compactMode: override.compactMode,
+                    compactLength: override.compactLength,
+                    compactPromptId: override.compactPromptId
+                };
+            }
+        }
+        // Look up the loop's action config for expiration settings
+        if (actionName) {
+            const agentActions = AIEngine.Instance.AgentActions.filter(aa => UUIDsEqual(aa.AgentID, params.agent.ID));
+            const effectiveActions = this._effectiveActions.length > 0
+                ? this._effectiveActions
+                : ActionEngineServer.Instance.Actions.filter(a => agentActions.some(aa => UUIDsEqual(aa.ActionID, a.ID)));
+            const matchedAction = effectiveActions.find(a => a.Name.trim().toLowerCase() === actionName.trim().toLowerCase());
+            if (matchedAction) {
+                const agentAction = agentActions.find(aa => UUIDsEqual(aa.ActionID, matchedAction.ID));
+                if (agentAction?.ResultExpirationTurns != null && agentAction.ResultExpirationMode !== 'None') {
+                    return {
+                        ...baseMetadata,
+                        expirationTurns: agentAction.ResultExpirationTurns,
+                        expirationMode: agentAction.ResultExpirationMode,
+                        compactMode: agentAction.CompactMode,
+                        compactLength: agentAction.CompactLength ?? undefined,
+                        compactPromptId: agentAction.CompactPromptID ?? undefined
+                    };
+                }
+            }
+        }
+        // Default: keep for 3 turns then remove (safe fallback so results don't vanish after 1 turn)
+        return {
+            ...baseMetadata,
+            expirationTurns: 3,
+            expirationMode: 'Remove'
+        };
+    }
     /**
      * Helper: Find action with fuzzy matching for loops.
      * Uses effective actions which includes both database-configured and dynamically added actions.
@@ -6482,6 +6627,8 @@ The context is now within limits. Please retry your request with the recovered c
             else if (whileOp.subAgent) {
                 const subAgentStep = { step: 'Sub-Agent', subAgent: whileOp.subAgent, newPayload: currentPayload, previousPayload: currentPayload };
                 result = await this.processSubAgentStep(params, subAgentStep, parentStepId, attemptContext);
+                // Attach formatted summary as priorStepResult so formatLoopResultsAsMarkdown can render it
+                result.priorStepResult = this.formatSubAgentResultAsMarkdown(whileOp.subAgent.name, result);
             }
             else {
                 throw new Error('While missing action/subAgent');
@@ -6502,7 +6649,7 @@ The context is now within limits. Please retry your request with the recovered c
         loopStepEntity.PayloadAtEnd = this.serializePayloadAtEnd(loopResults.finalPayload);
         await this.finalizeStepEntity(loopStepEntity, loopResults.errors.length === 0, loopResults.errors.join('\n\n'), loopResults);
         if (this.AgentTypeInstance.InjectLoopResultsAsMessage) {
-            this.injectLoopResultsMessage('While', whileOp.condition, loopResults.results, loopResults.errors, params);
+            this.injectLoopResultsMessage('While', whileOp.condition, loopResults.results, loopResults.errors, params, whileOp.action?.name);
         }
         return {
             step: 'Retry',
@@ -6881,8 +7028,7 @@ The context is now within limits. Please retry your request with the recovered c
         if (!this._agentRun) {
             throw new Error('Cannot create compaction step: agent run not initialized');
         }
-        const md = new Metadata();
-        const step = await md.GetEntityObject('MJ: AI Agent Run Steps', params.contextUser);
+        const step = await (params.provider || this._activeProvider).GetEntityObject('MJ: AI Agent Run Steps', params.contextUser);
         step.NewRecord();
         step.AgentRunID = this._agentRun.ID;
         step.StepType = 'Prompt';