@memberjunction/ai-agents 5.23.0 → 5.25.0

package/dist/base-agent.js

@@ -10,6 +10,7 @@
  * @author MemberJunction.com
  * @since 2.49.0
  */
+import { FileStorageEngineBase } from '@memberjunction/core-entities';
 import { Metadata, RunView, LogStatus, LogStatusEx, LogError, LogErrorEx, IsVerboseLoggingEnabled } from '@memberjunction/core';
 import { AIPromptRunner } from '@memberjunction/ai-prompts';
 import { BaseAgentType } from './agent-types/base-agent-type.js';
@@ -19,7 +20,7 @@ import { ActionEngineServer } from '@memberjunction/actions';
 import { AIAgentPermissionHelper } from '@memberjunction/ai-engine-base';
 import { AgentContextInjector } from './agent-context-injector.js';
 import { RerankerService } from '@memberjunction/ai-reranker';
-import { AIPromptParams, ChildPromptParam, ConversationUtility, parseAssignmentStrategy } from '@memberjunction/ai-core-plus';
+import { AIPromptParams, ChildPromptParam, ConversationUtility, ParseFileOutputRef, parseAssignmentStrategy } from '@memberjunction/ai-core-plus';
 import { AgentRunner } from './AgentRunner.js';
 import { PayloadManager } from './PayloadManager.js';
 import { ScratchpadManager } from './ScratchpadManager.js';
@@ -120,6 +121,7 @@ export class BaseAgent {
          * @private
          */
         this._feedbackRequestId = null;
+        this._resolvedStorageAccountId = null;
         /**
          * Agent hierarchy for display purposes (e.g., ["Marketing Agent", "Copywriter Agent"]).
          * Tracked separately as it's display-only and doesn't need persistence.
@@ -162,6 +164,14 @@ export class BaseAgent {
          * @since 3.1.0
          */
         this._mediaOutputs = [];
+        /**
+         * Accumulated file outputs (PDF, Excel, Word, etc.) produced by file-generation actions.
+         * Detected from the FileOutput output param after each action executes.
+         * Returned in ExecuteAgentResult.fileOutputs for processing by AgentRunner into MJ: Artifacts.
+         * @private
+         * @since 5.22.0
+         */
+        this._fileOutputs = [];
         /**
          * Payload manager for handling payload access control.
          * @private
@@ -226,12 +236,6 @@ export class BaseAgent {
          * Storage for injected notes and examples to include in result
          */
         this._injectedMemory = { notes: [], examples: [] };
-        /**
-         * Walks up the agent's category hierarchy looking for an AssignmentStrategy.
-         * Loads categories via RunView and caches them for the duration of this run.
-         * @private
-         */
-        this._categoryCache = null;
         /**
          * Determines the request type ID based on the Chat step's context.
          * - If the responseForm has only approve/reject-style buttons, uses "Approval"
@@ -267,6 +271,16 @@ export class BaseAgent {
     get AgentTypeInstance() {
         return this._agentTypeInstance;
     }
+    /**
+     * The resolved FileStorageAccount ID for this agent run. Set during Execute()
+     * via the hierarchical resolution chain (Runtime → Agent → Category → Type → fallback).
+     * Included in the ExecuteAgentResult so AgentRunner can route file artifact uploads.
+     *
+     * Subclasses can read this to customize storage behavior based on the resolved account.
+     */
+    get ResolvedStorageAccountId() {
+        return this._resolvedStorageAccountId;
+    }
     /**
      * Access the current run for the agent
      */
@@ -358,6 +372,29 @@ export class BaseAgent {
      * @private
      */
     static { this.LARGE_BINARY_THRESHOLD = 10000; }
+    /**
+     * Inspects a set of action output params for any value matching the FileOutputRef shape
+     * (an object with `fileName`, `mimeType`, and either `fileData` or `fileId`).
+     * Returns all matching FileOutputRef values found across all output params.
+     *
+     * Detection is shape-based, not name-based — actions can name their file output
+     * parameter anything and it will still be detected.
+     *
+     * @param outputParams - The output parameters from an action result
+     * @private
+     * @since 5.22.0
+     */
+    detectFileOutputs(outputParams) {
+        const results = [];
+        for (const param of outputParams) {
+            if (param.Value == null)
+                continue;
+            const ref = ParseFileOutputRef(param.Value);
+            if (ref)
+                results.push(ref);
+        }
+        return results;
+    }
     /**
      * Intercepts large media content in action results and replaces with placeholder references.
      * This prevents context overflow when action results contain large base64 data (images, audio, video).
@@ -832,13 +869,36 @@ export class BaseAgent {
         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
-            const canRun = await AIAgentPermissionHelper.HasPermission(params.agent.ID, params.contextUser, 'run');
-            if (!canRun) {
-                const errorMessage = `User ${params.contextUser.Email} does not have permission to run agent '${params.agent.Name}' (ID: ${params.agent.ID})`;
-                this.logStatus(`🚫 ${errorMessage}`, false, params);
-                throw new Error(errorMessage);
-            }
+            // =====================================================================================
+            // LATENCY OPTIMIZATION (Opt #4): Parallelized initialization sequence.
+            //
+            // The agent initialization pipeline was originally fully sequential: each operation
+            // awaited before the next began, even when there were no data dependencies between
+            // them. This added ~150-200ms of unnecessary serial wait time.
+            //
+            // The restructured pipeline uses 4 phases:
+            //
+            //   PRE-WORK (sync/fast): Parameter wrapping, markup conversion, payload init,
+            //     cancellation check, payload validation (may exit early).
+            //
+            //   PHASE 1 (parallel): Permission check + Engine init + AgentRun creation.
+            //     These three are mutually independent. If permission fails, we mark the
+            //     already-created AgentRun as failed and terminate — the wasted run record
+            //     is a negligible cost vs. the ~150ms saved by not serializing these.
+            //
+            //   PHASE 2 (parallel): Config load + Data preload + Context memory injection.
+            //     All three depend on Phase 1 completing (engines loaded, agentRun exists)
+            //     but NOT on each other. Config load reads from AIEngine's in-memory cache.
+            //     Data preload fetches agent data sources. Context memory loads notes/examples
+            //     and injects them into the conversation messages.
+            //
+            //   PHASE 3 (sequential): Agent type initialization — must wait for config from
+            //     Phase 2 because it needs the resolved agent type and prompt configuration.
+            //
+            // Original total init time: ~sum of all operations (~400-500ms)
+            // Optimized: ~max(Phase1) + max(Phase2) + Phase3 (~200-300ms)
+            // =====================================================================================
+            // --- PRE-WORK: Fast synchronous setup and early-exit checks ---
             // Wrap the progress callback to capture all events
             const wrappedParams = {
                 ...params,
@@ -850,12 +910,20 @@ export class BaseAgent {
             }
             // Reset scratchpad for each new execution (ephemeral per run)
             this._scratchpadManager.Clear();
+            // Initialize starting payload — must complete before AgentRun creation since the
+            // run record stores the starting payload snapshot.
             await this.initializeStartingPayload(wrappedParams);
             // Check for cancellation at start
             if (params.cancellationToken?.aborted) {
                 this.logStatus(`⚠️ Agent '${params.agent.Name}' execution cancelled before start`, true, params);
                 return await this.createCancelledResult('Cancelled before execution started', params.contextUser);
             }
+            // Handle starting payload validation if configured — may return early with a
+            // validation failure result, so we run this before launching expensive parallel work.
+            const startingValidationResult = await this.handleStartingPayloadValidation(wrappedParams);
+            if (startingValidationResult) {
+                return startingValidationResult;
+            }
             // Report initialization progress
             wrappedParams.onProgress?.({
                 step: 'initialization',
@@ -865,31 +933,46 @@ export class BaseAgent {
                     hierarchicalStep: this.buildHierarchicalStep(0, this._parentStepCounts)
                 }
             });
-            // Initialize execution tracking
-            await this.initializeAgentRun(wrappedParams);
-            // Reset validation retry counters for this run
+            // --- PHASE 1: Permission check + Engine init + AgentRun creation (parallel) ---
+            // These three operations have zero data dependencies on each other:
+            // - Permission check queries the AIAgentPermission entity
+            // - Engine init calls AIEngine.Instance.Config() and ActionEngineServer.Instance.Config()
+            // - AgentRun creation inserts a new AIAgentRun record
+            //
+            // If permission check fails, we mark the AgentRun as failed. This is acceptable:
+            // an orphaned "failed" run record is harmless and far cheaper than serializing these
+            // three operations (~150ms savings).
+            const [canRun] = await Promise.all([
+                AIAgentPermissionHelper.HasPermission(params.agent.ID, params.contextUser, 'run'),
+                this.initializeEngines(params.contextUser),
+                this.initializeAgentRun(wrappedParams)
+            ]);
+            if (!canRun) {
+                // Permission denied — mark the already-created AgentRun as failed so it doesn't
+                // appear as a phantom "running" record in the UI.
+                const errorMessage = `User ${params.contextUser.Email} does not have permission to run agent '${params.agent.Name}' (ID: ${params.agent.ID})`;
+                this.logStatus(`🚫 ${errorMessage}`, false, params);
+                if (this._agentRun) {
+                    this._agentRun.Status = 'Failed';
+                    this._agentRun.ErrorMessage = errorMessage;
+                    await this._agentRun.Save();
+                }
+                throw new Error(errorMessage);
+            }
+            // Reset per-run state (sync, instant — no parallelization needed)
             this._validationRetryCount = 0;
             this._generalValidationRetryCount = 0;
             this._contextRecoveryAttempts = 0;
-            // Reset effective actions and dynamic limits for this run
             this._effectiveActions = [];
             this._dynamicActionLimits = {};
-            // Reset media outputs accumulator for this run
-            // (unified array now includes both promoted media and intercepted binary with refIds)
             this._mediaOutputs = [];
-            // Store message lifecycle callback if provided
             this._messageLifecycleCallback = params.onMessageLifecycle;
-            // Initialize engines
-            await this.initializeEngines(params.contextUser);
-            // Check for cancellation after initialization
+            // Resolve storage account for file artifacts
+            this._resolvedStorageAccountId = await this.getStorageAccountID(wrappedParams);
+            // Check for cancellation after Phase 1
             if (params.cancellationToken?.aborted) {
                 return await this.createCancelledResult('Cancelled during initialization', params.contextUser);
             }
-            // Handle starting payload validation if configured
-            const startingValidationResult = await this.handleStartingPayloadValidation(wrappedParams);
-            if (startingValidationResult) {
-                return startingValidationResult;
-            }
             // Report validation progress
             wrappedParams.onProgress?.({
                 step: 'validation',
@@ -899,34 +982,26 @@ export class BaseAgent {
                     hierarchicalStep: this.buildHierarchicalStep(0, this._parentStepCounts)
                 }
             });
-            // Create and track validation step
+            // Validate agent — may return early with a failure result. Runs after engines are
+            // initialized (Phase 1) since validation may inspect AIEngine metadata.
             const validationResult = await this.validateAgentWithTracking(params.agent, params.contextUser);
             if (validationResult)
                 return validationResult;
-            // Load agent configuration
+            // --- PHASE 2: Config load + Data preload + Context memory injection (parallel) ---
+            // All three depend on Phase 1 completing (engines initialized, agentRun exists) but
+            // have no dependencies on each other:
+            // - Config load reads agent type, prompts, and agent prompts from AIEngine's in-memory
+            //   cache — typically < 5ms but async due to potential Config() refresh.
+            // - Data preload fetches agent data sources and creates a tracking step entity.
+            // - Context memory resolves scope configuration (pure computation), then loads notes
+            //   and examples from the DB and injects them into conversation messages.
             this.logStatus(`📋 Loading configuration for agent '${params.agent.Name}'`, true, params);
-            const config = await this.loadAgentConfiguration(params.agent);
-            if (!config.success) {
-                this.logError(`Failed to load agent configuration: ${config.errorMessage}`, {
-                    agent: params.agent,
-                    category: 'AgentConfiguration'
-                });
-                return await this.createFailureResult(config.errorMessage || 'Failed to load agent configuration', params.contextUser);
-            }
-            // Preload agent data sources unless disabled
-            await this.preloadAgentData(wrappedParams);
-            // now initialize the agent type which gets us the instance setup in our class plus also gets the agent type to initialize
-            // its state
-            await this.initializeAgentType(wrappedParams, config);
-            // Inject context memory (notes and examples) before execution
+            // Pre-compute scope configuration for context memory injection (pure computation,
+            // no I/O — safe to do before launching the parallel phase).
             const userId = params.userId || params.contextUser?.ID;
             const companyId = params.companyId;
-            // Extract input text from conversation messages (last user message)
-            const lastUserMessage = params.conversationMessages
-                .filter(m => m.role === 'user')
-                .pop();
+            const lastUserMessage = params.conversationMessages.filter(m => m.role === 'user').pop();
             const inputText = lastUserMessage?.content || '';
-            // Parse agent-level scope config for note/example filtering
             const scopeConfigJson = params.agent.ScopeConfig;
             let scopeConfig = null;
             if (scopeConfigJson) {
@@ -935,11 +1010,9 @@ export class BaseAgent {
                 }
                 catch { /* ignore bad JSON */ }
             }
-            // Resolve scope params from top-level params or data fallback (for GraphQL callers)
             const primaryScopeEntityName = params.PrimaryScopeEntityName ?? params.data?.PrimaryScopeEntityName;
             const primaryScopeRecordId = params.PrimaryScopeRecordID ?? params.data?.PrimaryScopeRecordID;
             const secondaryScopes = params.SecondaryScopes ?? params.data?.SecondaryScopes;
-            // Resolve entity name to entity ID for scope filtering
             let primaryScopeEntityId;
             if (primaryScopeEntityName) {
                 const primaryEntity = this._metadata.Entities.find(e => e.Name === primaryScopeEntityName);
@@ -947,8 +1020,22 @@ export class BaseAgent {
                     primaryScopeEntityId = primaryEntity.ID;
                 }
             }
-            // Inject context memory (notes and examples) into conversation messages
-            await this.InjectContextMemory(typeof inputText === 'string' ? inputText : '', params.agent, userId, companyId, params.contextUser, wrappedParams.conversationMessages, primaryScopeEntityId, primaryScopeRecordId, secondaryScopes, scopeConfig);
+            const [config] = await Promise.all([
+                this.loadAgentConfiguration(params.agent),
+                this.preloadAgentData(wrappedParams),
+                this.InjectContextMemory(typeof inputText === 'string' ? inputText : '', params.agent, userId, companyId, params.contextUser, wrappedParams.conversationMessages, primaryScopeEntityId, primaryScopeRecordId, secondaryScopes, scopeConfig)
+            ]);
+            if (!config.success) {
+                this.logError(`Failed to load agent configuration: ${config.errorMessage}`, {
+                    agent: params.agent,
+                    category: 'AgentConfiguration'
+                });
+                return await this.createFailureResult(config.errorMessage || 'Failed to load agent configuration', params.contextUser);
+            }
+            // --- PHASE 3: Agent type initialization (sequential) ---
+            // Must wait for config from Phase 2 because it needs the resolved agent type and
+            // prompt configuration to initialize the type-specific state machine.
+            await this.initializeAgentType(wrappedParams, config);
             // Execute the agent's internal logic with wrapped parameters
             this.logStatus(`🚀 Executing agent '${params.agent.Name}' internal logic`, true, params);
             const executionResult = await this.executeAgentInternal(wrappedParams, config);
@@ -3207,6 +3294,10 @@ The context is now within limits. Please retry your request with the recovered c
                 Value: value,
                 Type: 'Input'
             }));
+            // Build action context: preserve the agent's context and inject resolved storage account ID
+            const actionContext = this._resolvedStorageAccountId
+                ? { ...(typeof params.context === 'object' && params.context ? params.context : {}), __resolvedStorageAccountId: this._resolvedStorageAccountId }
+                : params.context;
             // Execute the action and return the full ActionResult
             const result = await actionEngine.RunAction({
                 Action: actionEntity,
@@ -3214,7 +3305,7 @@ The context is now within limits. Please retry your request with the recovered c
                 ContextUser: contextUser,
                 Filters: [],
                 SkipActionLog: false,
-                Context: params.context // pass along our context to actions so they can use it however they need
+                Context: actionContext
             });
             if (result.Success) {
                 this.logStatus(`   ✅ Action '${action.name}' completed successfully`, true, params);
@@ -3618,6 +3709,18 @@ The context is now within limits. Please retry your request with the recovered c
             lines.push('');
             lines.push(`**User:** ${user.Name}${user.Roles?.length ? ` (Roles: ${user.Roles.join(', ')})` : ''}`);
         }
+        // Additional context reported by the active view/component
+        const dashboardCtx = ctx['AdditionalContext'];
+        if (dashboardCtx && Object.keys(dashboardCtx).length > 0) {
+            lines.push('');
+            lines.push('**Dashboard state:**');
+            for (const [key, value] of Object.entries(dashboardCtx)) {
+                if (value === null || value === undefined)
+                    continue;
+                const displayValue = typeof value === 'object' ? JSON.stringify(value) : String(value);
+                lines.push(`- ${key}: ${displayValue}`);
+            }
+        }
         return lines.join('\n');
     }
     /**
@@ -5060,6 +5163,11 @@ The context is now within limits. Please retry your request with the recovered c
                     this.logStatus(`📦 Collected ${refCount} media reference(s) from sub-agent '${subAgentRequest.name}'`, true);
                 }
             }
+            // Merge sub-agent's file outputs into parent's array for unified artifact creation.
+            if (subAgentResult.fileOutputs?.length) {
+                this._fileOutputs.push(...subAgentResult.fileOutputs);
+                this.logStatus(`📄 Collected ${subAgentResult.fileOutputs.length} file output(s) from sub-agent '${subAgentRequest.name}'`, true);
+            }
             // Determine if we should terminate after sub-agent
             const shouldTerminate = subAgentRequest.terminateAfter;
             // Prepare output data
@@ -5316,6 +5424,11 @@ The context is now within limits. Please retry your request with the recovered c
                     this.logStatus(`📦 Collected ${refCount} media reference(s) from related sub-agent '${subAgentRequest.name}'`, true);
                 }
             }
+            // Merge sub-agent's file outputs into parent's array for unified artifact creation.
+            if (subAgentResult.fileOutputs?.length) {
+                this._fileOutputs.push(...subAgentResult.fileOutputs);
+                this.logStatus(`📄 Collected ${subAgentResult.fileOutputs.length} file output(s) from related sub-agent '${subAgentRequest.name}'`, true);
+            }
             let mergedPayload = previousDecision.newPayload; // Start with parent's payload
             let currentStepPayloadChangeResult = undefined;
             if (subAgentResult.success && relationship.SubAgentOutputMapping) {
@@ -5810,6 +5923,9 @@ The context is now within limits. Please retry your request with the recovered c
                 // This prevents context overflow from base64 data (~700K tokens per 1024x1024 image)
                 // Pass actionEntity for generic ValueType=MediaOutput detection from metadata
                 const sanitizedParams = this.interceptLargeBinaryContent(outputParams, result.actionEntity);
+                // Collect file outputs (PDF, Excel, Word, etc.) for post-run artifact processing
+                const fileOutputs = this.detectFileOutputs(outputParams);
+                this._fileOutputs.push(...fileOutputs);
                 return {
                     actionName: result.action.name,
                     success: result.success,
@@ -6188,27 +6304,22 @@ The context is now within limits. Please retry your request with the recovered c
         }
         return null;
     }
+    /**
+     * Walks up the agent's category hierarchy looking for an AssignmentStrategy.
+     * Uses AIEngine.Instance.AgentCategories (cached during engine Config).
+     */
     async resolveCategoryAssignmentStrategy(params) {
         const categoryId = params.agent.CategoryID;
         if (!categoryId)
             return null;
         try {
-            // Load all categories if not cached
-            if (!this._categoryCache) {
-                const rv = new RunView();
-                const result = await rv.RunView({
-                    EntityName: 'MJ: AI Agent Categories',
-                    Fields: ['ID', 'ParentID', 'AssignmentStrategy'],
-                    ResultType: 'simple'
-                }, params.contextUser);
-                this._categoryCache = result.Success ? result.Results : [];
-            }
+            const categories = AIEngine.Instance.AgentCategories;
             // Walk up the tree from the agent's category to the root
             let currentId = categoryId;
             const visited = new Set(); // prevent infinite loops
             while (currentId && !visited.has(currentId)) {
                 visited.add(currentId);
-                const cat = this._categoryCache.find(c => UUIDsEqual(c.ID, currentId));
+                const cat = categories.find(c => UUIDsEqual(c.ID, currentId));
                 if (!cat)
                     break;
                 const strategy = parseAssignmentStrategy(cat.AssignmentStrategy);
@@ -6222,6 +6333,86 @@ The context is now within limits. Please retry your request with the recovered c
         }
         return null;
     }
+    /**
+     * Resolves the file storage account ID for this agent's file artifacts.
+     *
+     * Resolution chain (first non-null wins):
+     * 1. Runtime override (`params.override?.storageAccountId`)
+     * 2. Agent-level (`params.agent.DefaultStorageAccountID`)
+     * 3. Category hierarchy — walks up the agent's category tree via `ParentID`
+     * 4. Agent Type-level (`agentType.DefaultStorageAccountID`)
+     * 5. System fallback — single active storage account, if only one exists
+     *
+     * This method is `protected` so subclasses can override the resolution logic
+     * for custom storage routing (e.g., routing by file type or tenant).
+     *
+     * @param params - The current agent execution parameters
+     * @returns The resolved FileStorageAccount ID, or null if none configured
+     */
+    async getStorageAccountID(params) {
+        // 1. Runtime override — highest priority
+        if (params.override?.storageAccountId) {
+            return params.override.storageAccountId;
+        }
+        // 2. Agent-level override
+        if (params.agent.DefaultStorageAccountID) {
+            return params.agent.DefaultStorageAccountID;
+        }
+        // 3. Category tree walk
+        const categoryId = params.agent.CategoryID;
+        if (categoryId) {
+            try {
+                const categories = AIEngine.Instance.AgentCategories;
+                let currentId = categoryId;
+                const visited = new Set();
+                while (currentId && !visited.has(currentId)) {
+                    visited.add(currentId);
+                    const cat = categories.find(c => UUIDsEqual(c.ID, currentId));
+                    if (!cat)
+                        break;
+                    if (cat.DefaultStorageAccountID)
+                        return cat.DefaultStorageAccountID;
+                    currentId = cat.ParentID;
+                }
+            }
+            catch (error) {
+                LogError(`Error resolving category storage account: ${error.message}`);
+            }
+        }
+        // 4. Agent Type-level default
+        const agentTypeId = params.agent.TypeID;
+        if (agentTypeId) {
+            const agentType = AIEngine.Instance.AgentTypes.find(at => UUIDsEqual(at.ID, agentTypeId));
+            if (agentType?.DefaultStorageAccountID) {
+                return agentType.DefaultStorageAccountID;
+            }
+        }
+        // 5. System fallback — use cached metadata (already loaded during engine Config)
+        const activeAccounts = FileStorageEngineBase.Instance.AccountsWithProviders
+            .filter(a => a.provider.IsActive);
+        if (activeAccounts.length === 0) {
+            // No storage configured — return null, inline base64 fallback handles it downstream
+            return null;
+        }
+        if (activeAccounts.length === 1) {
+            return activeAccounts[0].account.ID;
+        }
+        // 2+ active accounts but nothing configured at any level
+        const agentName = params.agent.Name || params.agent.ID;
+        const typeName = params.agent.TypeID
+            ? AIEngine.Instance.AgentTypes.find(at => UUIDsEqual(at.ID, params.agent.TypeID))?.Name || params.agent.TypeID
+            : 'unknown';
+        const categoryName = params.agent.CategoryID
+            ? AIEngine.Instance.AgentCategories.find(c => UUIDsEqual(c.ID, params.agent.CategoryID))?.Name || params.agent.CategoryID
+            : 'none';
+        const accountNames = activeAccounts.map(a => `'${a.account.Name}' (${a.provider.Name})`).join(', ');
+        throw new Error(`Multiple active file storage accounts detected (${accountNames}) but no DefaultStorageAccountID is configured ` +
+            `for agent '${agentName}', category '${categoryName}', or agent type '${typeName}'.\n` +
+            `To fix: Set DefaultStorageAccountID on one of the following (in order of priority):\n` +
+            `  1. Agent '${agentName}' — for this specific agent\n` +
+            `  2. Agent Category '${categoryName}' — for all agents in this category\n` +
+            `  3. Agent Type '${typeName}' — for all agents of this type`);
+    }
     /**
      * Resolves the target user ID from a resolved assignment strategy.
      * For simple strategies (RunUser, AgentOwner, SpecificUser), resolves immediately.
@@ -7049,7 +7240,9 @@ The context is now within limits. Please retry your request with the recovered c
                 ? this._injectedMemory
                 : undefined,
             mediaOutputs: this._mediaOutputs.length > 0 ? this._mediaOutputs : undefined,
-            feedbackRequestId: this._feedbackRequestId || undefined
+            fileOutputs: this._fileOutputs.length > 0 ? this._fileOutputs : undefined,
+            feedbackRequestId: this._feedbackRequestId || undefined,
+            resolvedStorageAccountId: this._resolvedStorageAccountId || undefined
         };
     }
     /**