@memberjunction/ai-agents 2.59.0 → 2.61.0

package/dist/base-agent.js

@@ -9,15 +9,51 @@ const aiengine_1 = require("@memberjunction/aiengine");
 const actions_1 = require("@memberjunction/actions");
 const ai_core_plus_1 = require("@memberjunction/ai-core-plus");
 const AgentRunner_1 = require("./AgentRunner");
+const PayloadManager_1 = require("./PayloadManager");
 class BaseAgent {
     constructor() {
         this._promptRunner = new ai_prompts_1.AIPromptRunner();
         this._metadata = new core_1.Metadata();
-        this._runContext = null;
         this._agentRun = null;
-        this._executionChain = [];
+        this._agentHierarchy = [];
+        this._depth = 0;
         this._allProgressSteps = [];
         this._subAgentRuns = [];
+        this._payloadManager = new PayloadManager_1.PayloadManager();
+    }
+    logStatus(message, verboseOnly = false, params) {
+        if (verboseOnly) {
+            (0, core_1.LogStatusEx)({
+                message,
+                verboseOnly: true,
+                isVerboseEnabled: () => params?.verbose === true || (0, core_1.IsVerboseLoggingEnabled)()
+            });
+        }
+        else {
+            (0, core_1.LogStatus)(message);
+        }
+    }
+    logError(error, options) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        const errorObj = error instanceof Error ? error : undefined;
+        const metadata = {
+            ...options?.metadata
+        };
+        if (options?.agent) {
+            metadata.agentId = options.agent.ID;
+            metadata.agentName = options.agent.Name;
+        }
+        if (options?.agentType) {
+            metadata.agentTypeId = options.agentType.ID;
+            metadata.agentTypeName = options.agentType.Name;
+        }
+        (0, core_1.LogErrorEx)({
+            message: errorMessage,
+            error: errorObj,
+            category: options?.category || 'BaseAgent',
+            severity: options?.severity || 'error',
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined
+        });
     }
     wrapProgressCallback(originalCallback) {
         if (!originalCallback)
@@ -26,19 +62,40 @@ class BaseAgent {
             this._allProgressSteps.push({
                 ...progress,
                 timestamp: new Date(),
-                agentHierarchy: this._runContext?.agentHierarchy || [],
-                depth: this._runContext?.depth || 0
+                agentHierarchy: this._agentHierarchy || [],
+                depth: this._depth || 0
             });
-            originalCallback(progress);
+            try {
+                const enhancedProgress = {
+                    ...progress,
+                    metadata: {
+                        ...progress.metadata,
+                        agentRun: this._agentRun
+                    }
+                };
+                originalCallback(enhancedProgress);
+            }
+            catch (e) {
+                this.logError(`Failed to enhance progress with agent run: ${e instanceof Error ? e.message : e}`, {
+                    category: 'ProgressEnhancement',
+                    metadata: {
+                        progress: progress,
+                        agentRunId: this._agentRun?.ID || 'N/A'
+                    }
+                });
+                originalCallback(progress);
+            }
         };
     }
     async Execute(params) {
         try {
+            this.logStatus(`🤖 Starting execution of agent '${params.agent.Name}'`, true, params);
             const wrappedParams = {
                 ...params,
                 onProgress: this.wrapProgressCallback(params.onProgress)
             };
             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);
             }
             wrappedParams.onProgress?.({
@@ -59,22 +116,36 @@ class BaseAgent {
             const validationResult = await this.validateAgentWithTracking(params.agent, params.contextUser);
             if (validationResult)
                 return validationResult;
+            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);
             }
+            this.logStatus(`🚀 Executing agent '${params.agent.Name}' internal logic`, true, params);
             const executionResult = await this.executeAgentInternal(wrappedParams, config);
             wrappedParams.onProgress?.({
                 step: 'finalization',
                 percentage: 95,
+                metadata: { result: executionResult },
                 message: this.formatHierarchicalMessage('Finalizing agent execution')
             });
-            return await this.finalizeAgentRun(executionResult.finalStep.step, executionResult.finalStep.returnValue, params.contextUser);
+            this.logStatus(`✅ Finalizing execution for agent '${params.agent.Name}'`, true, params);
+            return await this.finalizeAgentRun(executionResult.finalStep, executionResult.finalStep.previousPayload, params.contextUser);
         }
         catch (error) {
             if (params.cancellationToken?.aborted || error.message === 'Cancelled during execution') {
+                this.logStatus(`⚠️ Agent '${params.agent.Name}' execution cancelled: ${error.message}`, true, params);
                 return await this.createCancelledResult(error.message || 'Cancelled due to error during execution', params.contextUser);
             }
+            this.logError(error, {
+                agent: params.agent,
+                category: 'AgentExecution',
+                severity: 'critical'
+            });
             return await this.createFailureResult(error.message, params.contextUser);
         }
     }
@@ -86,14 +157,17 @@ class BaseAgent {
             if (params.cancellationToken?.aborted) {
                 throw new Error('Cancelled during execution');
             }
+            this.logStatus(`🔄 Executing step ${stepCount + 1} for agent '${params.agent.Name}'`, true, params);
             const nextStep = await this.executeNextStep(params, config, currentNextStep);
             stepCount++;
             if (nextStep.terminate) {
                 continueExecution = false;
                 currentNextStep = nextStep;
+                this.logStatus(`🏁 Agent '${params.agent.Name}' terminating after ${stepCount} steps with result: ${nextStep.step}`, true, params);
             }
             else {
                 currentNextStep = nextStep;
+                this.logStatus(`➡️ Agent '${params.agent.Name}' continuing to next step: ${nextStep.step}`, true, params);
             }
         }
         return { finalStep: currentNextStep, stepCount };
@@ -104,12 +178,15 @@ class BaseAgent {
     }
     async validateAgent(agent) {
         if (agent.Status !== 'Active') {
+            if (this._agentRun) {
+                this._agentRun.ErrorMessage = `Agent '${agent.Name}' is not active. Current status: ${agent.Status}`;
+                this._agentRun.Status = 'Failed';
+                this._agentRun.Success = false;
+                this._agentRun.FinalStep = 'Failed';
+            }
             return {
                 success: false,
-                finalStep: 'failed',
-                errorMessage: `Agent '${agent.Name}' is not active. Current status: ${agent.Status}`,
-                agentRun: this._agentRun,
-                executionTree: []
+                agentRun: this._agentRun
             };
         }
         return null;
@@ -159,7 +236,10 @@ class BaseAgent {
             childPrompt
         };
     }
-    async preparePromptParams(agentType, systemPrompt, childPrompt, params) {
+    async preparePromptParams(config, payload, params) {
+        const agentType = config.agentType;
+        const systemPrompt = config.systemPrompt;
+        const childPrompt = config.childPrompt;
         const promptTemplateData = await this.gatherPromptTemplateData(params.agent, params.contextUser, params.data);
         const promptParams = new ai_core_plus_1.AIPromptParams();
         promptParams.prompt = systemPrompt;
@@ -167,22 +247,26 @@ class BaseAgent {
         promptParams.contextUser = params.contextUser;
         promptParams.conversationMessages = params.conversationMessages;
         promptParams.templateMessageRole = 'system';
+        promptParams.verbose = params.verbose;
+        const atInstance = await base_agent_type_1.BaseAgentType.GetAgentTypeInstance(config.agentType);
+        await atInstance.InjectPayload(payload, promptParams);
         promptParams.childPrompts = [
             new ai_core_plus_1.ChildPromptParam({
                 prompt: childPrompt,
                 data: promptTemplateData,
                 contextUser: params.contextUser,
                 conversationMessages: params.conversationMessages,
-                templateMessageRole: 'user'
+                templateMessageRole: 'user',
+                verbose: params.verbose
             }, agentType.AgentPromptPlaceholder)
         ];
         if (params.agent.ModelSelectionMode === 'Agent') {
             promptParams.modelSelectionPrompt = childPrompt;
-            (0, core_1.LogStatus)(`🎯 Agent '${params.agent.Name}' configured to use its own prompt for model selection`);
+            this.logStatus(`🎯 Agent '${params.agent.Name}' configured to use its own prompt for model selection`, true, params);
         }
         if (params.override) {
             promptParams.override = params.override;
-            (0, core_1.LogStatus)(`🎯 Using runtime override: ${params.override.modelId || 'model'} ${params.override.vendorId ? `from vendor ${params.override.vendorId}` : ''}`);
+            this.logStatus(`🎯 Using runtime override: ${params.override.modelId || 'model'} ${params.override.vendorId ? `from vendor ${params.override.vendorId}` : ''}`, true, params);
         }
         return promptParams;
     }
@@ -190,18 +274,11 @@ class BaseAgent {
         return await this._promptRunner.ExecutePrompt(promptParams);
     }
     async processNextStep(params, agentType, promptResult) {
-        let agentTypeInstance;
-        try {
-            agentTypeInstance = await this.getAgentTypeInstance(agentType);
-        }
-        catch (error) {
-            return {
-                terminate: false,
-                step: 'failed',
-                errorMessage: error.message
-            };
-        }
+        this.logStatus(`🤔 Processing next step for agent '${params.agent.Name}' with agent type '${agentType.Name}'`, true, params);
+        const agentTypeInstance = await base_agent_type_1.BaseAgentType.GetAgentTypeInstance(agentType);
+        this.logStatus(`🎯 Agent type '${agentType.Name}' determining next step`, true, params);
         const nextStep = await agentTypeInstance.DetermineNextStep(promptResult);
+        this.logStatus(`📌 Next step determined: ${nextStep.step}${nextStep.terminate ? ' (terminating)' : ''}`, true, params);
         return nextStep;
     }
     createActionResultMessage(actions, results) {
@@ -261,37 +338,16 @@ class BaseAgent {
             throw new Error(`Error gathering context data: ${error.message}`);
         }
     }
-    async getAgentTypeInstance(agentType) {
-        return this.getAgentInstanceWithDriverClass(agentType.DriverClass || agentType.Name);
-    }
-    async getAgentInstanceWithDriverClass(driverClass) {
-        const instance = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(base_agent_type_1.BaseAgentType, driverClass);
-        if (!instance) {
-            throw new Error(`No implementation found for agent with DriverClass '${driverClass}'. Please ensure the class is registered with the ClassFactory.`);
-        }
-        return instance;
-    }
-    async ExecuteSingleAction(params, action, contextUser) {
+    async ExecuteSingleAction(params, action, actionEntity, contextUser) {
         try {
+            this.logStatus(`⚡ Executing action '${action.name}'`, true, params);
             const actionEngine = actions_1.ActionEngineServer.Instance;
-            if (!action.id) {
-                throw new Error(`Action ID is required for action: ${action.name || 'unknown'}`);
-            }
-            const actionEntity = actionEngine.Actions.find(a => a.ID === action.id);
-            if (!actionEntity) {
-                const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-                if (!uuidRegex.test(action.id)) {
-                    throw new Error(`${action.id} is not a valid UUID and must be a UUID representing the Action ID`);
-                }
-                else {
-                    throw new Error(`Action with ID ${action.id} not found in the action table`);
-                }
-            }
             const actionParams = Object.entries(action.params || {}).map(([key, value]) => ({
                 Name: key,
                 Value: value,
                 Type: 'Input'
             }));
+            this.logStatus(`📥 Action parameters: ${JSON.stringify(action.params)}`, true, params);
             const result = await actionEngine.RunAction({
                 Action: actionEntity,
                 Params: actionParams,
@@ -303,28 +359,23 @@ class BaseAgent {
             if (!result.Success) {
                 throw new Error(`Action '${action.name}' failed: ${result.Message || 'Unknown error'}`);
             }
+            this.logStatus(`✅ Action '${action.name}' completed successfully`, true, params);
             return result;
         }
         catch (error) {
+            this.logError(error, {
+                category: 'ActionExecution',
+                metadata: {
+                    actionName: action.name,
+                    actionParams: action.params
+                }
+            });
             throw new Error(`Error executing actions: ${error.message}`);
         }
     }
-    async ExecuteSubAgent(params, subAgentRequest) {
+    async ExecuteSubAgent(params, subAgentRequest, subAgent, stepEntity, payload) {
         try {
-            const engine = aiengine_1.AIEngine.Instance;
-            if (!subAgentRequest.id) {
-                throw new Error('Sub-agent ID is required');
-            }
-            const subAgent = engine.Agents.find(a => a.ID === subAgentRequest.id);
-            if (!subAgent) {
-                const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-                if (!uuidRegex.test(subAgentRequest.id)) {
-                    throw new Error(`${subAgentRequest.id} is not a valid UUID and must be a UUID representing the Agent ID`);
-                }
-                else {
-                    throw new Error(`Sub-agent with ID ${subAgentRequest.id} not found in the agent table`);
-                }
-            }
+            this.logStatus(`🤖 Executing sub-agent '${subAgentRequest.name}'`, true, params);
             const runner = new AgentRunner_1.AgentRunner();
             const subAgentMessages = [
                 {
@@ -332,6 +383,10 @@ class BaseAgent {
                     content: subAgentRequest.message
                 }
             ];
+            this.logStatus(`📨 Sub-agent message: "${subAgentRequest.message}"`, true, params);
+            if (subAgentRequest.templateParameters) {
+                this.logStatus(`📎 Template parameters: ${JSON.stringify(subAgentRequest.templateParameters)}`, true, params);
+            }
             const result = await runner.RunAgent({
                 agent: subAgent,
                 conversationMessages: subAgentMessages,
@@ -339,24 +394,34 @@ class BaseAgent {
                 cancellationToken: params.cancellationToken,
                 onProgress: params.onProgress,
                 onStreaming: params.onStreaming,
-                parentAgentHierarchy: this._runContext?.agentHierarchy,
-                parentDepth: this._runContext?.depth,
+                parentAgentHierarchy: this._agentHierarchy,
+                parentDepth: this._depth,
                 parentRun: this._agentRun,
+                payload: payload,
                 data: subAgentRequest.templateParameters,
-                context: params.context
+                context: params.context,
+                verbose: params.verbose
             });
             if (!result.success) {
-                throw new Error(`Sub-agent '${subAgentRequest.name}' failed: ${result.errorMessage || 'Unknown error'}`);
+                throw new Error(`Sub-agent '${subAgentRequest.name}' failed: ${result.agentRun?.ErrorMessage || 'Unknown error'}`);
             }
+            this.logStatus(`✅ Sub-agent '${subAgentRequest.name}' completed successfully`, true, params);
             return result;
         }
         catch (error) {
+            this.logError(error, {
+                category: 'SubAgentExecution',
+                metadata: {
+                    agentName: params.agent.Name,
+                    subAgentName: subAgentRequest.name,
+                    message: subAgentRequest.message
+                }
+            });
             throw new Error(`Error executing sub-agent: ${error.message}`);
         }
     }
     formatSubAgentDetails(subAgents) {
         return JSON.stringify(subAgents.map(sa => ({
-            ID: sa.ID,
             Name: sa.Name,
             Description: sa.Description,
             Type: sa.TypeID ? this.getAgentTypeName(sa.TypeID) : 'Unknown',
@@ -390,7 +455,6 @@ class BaseAgent {
     }
     formatActionDetails(actions) {
         return JSON.stringify(actions.map(action => ({
-            ID: action.ID,
             Name: action.Name,
             Description: action.Description,
             Parameters: {
@@ -405,7 +469,6 @@ class BaseAgent {
                 Code: rc.ResultCode,
                 IsSuccess: rc.IsSuccess,
                 Description: rc.Description || 'No description provided',
-                Usage: this.inferResultCodeUsage(rc.ResultCode, rc.IsSuccess)
             })),
             Category: action.CategoryID ? this.getActionCategoryName(action.CategoryID) : null,
             Status: action.Status
@@ -432,34 +495,6 @@ class BaseAgent {
     getActionCategoryName(categoryID) {
         return 'General';
     }
-    inferResultCodeUsage(resultCode, isSuccess) {
-        if (resultCode === 'SUCCESS') {
-            return 'Returned when the action completes successfully';
-        }
-        else if (resultCode === 'FAILED') {
-            return 'Generic failure - check error message for details';
-        }
-        else if (resultCode.includes('MISSING_PARAMETERS')) {
-            return 'Returned when required parameters are not provided';
-        }
-        else if (resultCode.includes('INVALID')) {
-            return 'Returned when input validation fails';
-        }
-        else if (resultCode.includes('NOT_FOUND')) {
-            return 'Returned when the requested resource cannot be found';
-        }
-        else if (resultCode.includes('TIMEOUT')) {
-            return 'Returned when the operation times out';
-        }
-        else if (resultCode.includes('PERMISSION') || resultCode.includes('UNAUTHORIZED')) {
-            return 'Returned when permission is denied';
-        }
-        else {
-            return isSuccess
-                ? 'Specific success condition - see description'
-                : 'Specific error condition - see description';
-        }
-    }
     async initializeAgentRun(params) {
         this._agentRun = await this._metadata.GetEntityObject('MJ: AI Agent Runs', params.contextUser);
         this._agentRun.AgentID = params.agent.ID;
@@ -471,68 +506,21 @@ class BaseAgent {
             const errorMessage = JSON.stringify((0, global_1.CopyScalarsAndArrays)(this._agentRun.LatestResult));
             throw new Error(`Failed to create agent run record: Details: ${errorMessage}`);
         }
-        this._runContext = {
-            currentStepIndex: 0,
-            parentRunStack: [],
-            agentHierarchy: params.parentAgentHierarchy
-                ? [...params.parentAgentHierarchy, params.agent.Name || 'Unknown Agent']
-                : [params.agent.Name || 'Unknown Agent'],
-            depth: params.parentDepth !== undefined ? params.parentDepth + 1 : 0,
-            conversationId: undefined,
-            userId: params.contextUser?.ID,
-            agentState: {}
-        };
-        this._executionChain = [];
+        this._agentHierarchy = params.parentAgentHierarchy
+            ? [...params.parentAgentHierarchy, params.agent.Name || 'Unknown Agent']
+            : [params.agent.Name || 'Unknown Agent'];
+        this._depth = params.parentDepth !== undefined ? params.parentDepth + 1 : 0;
         this._allProgressSteps = [];
     }
     async validateAgentWithTracking(agent, contextUser) {
-        const startTime = new Date();
         try {
             const validationResult = await this.validateAgent(agent);
             if (validationResult) {
-                const stepEntity = await this.createStepEntity('validation', 'Agent Validation', contextUser);
-                const executionResult = {
-                    type: 'validation',
-                    validationTarget: 'agent configuration',
-                    result: { valid: false, errors: [validationResult.errorMessage || 'Validation failed'] }
-                };
-                const nextStepDecision = {
-                    decision: 'failed',
-                    reasoning: 'Agent validation failed',
-                    nextStepDetails: { type: 'complete' }
-                };
-                this._executionChain.push({
-                    stepEntity,
-                    executionType: 'validation',
-                    executionResult,
-                    nextStepDecision,
-                    startTime,
-                    endTime: new Date(),
-                    durationMs: new Date().getTime() - startTime.getTime()
-                });
-                await this.finalizeStepEntity(stepEntity, false, validationResult.errorMessage);
-                return await this.createFailureResult(validationResult.errorMessage || 'Validation failed', contextUser);
+                const stepEntity = await this.createStepEntity('Validation', 'Agent Validation', contextUser);
+                await this.finalizeStepEntity(stepEntity, false, validationResult.agentRun?.ErrorMessage);
+                return await this.createFailureResult(validationResult.agentRun?.ErrorMessage || 'Validation failed', contextUser);
             }
-            const stepEntity = await this.createStepEntity('validation', 'Agent Validation', contextUser);
-            const executionResult = {
-                type: 'validation',
-                validationTarget: 'agent configuration',
-                result: { valid: true }
-            };
-            const nextStepDecision = {
-                decision: 'success',
-                reasoning: 'Agent validation passed',
-                nextStepDetails: { type: 'prompt', promptId: agent.ID, promptName: 'Initial Prompt' }
-            };
-            this._executionChain.push({
-                stepEntity,
-                executionType: 'validation',
-                executionResult,
-                nextStepDecision,
-                startTime,
-                endTime: new Date(),
-                durationMs: new Date().getTime() - startTime.getTime()
-            });
+            const stepEntity = await this.createStepEntity('Validation', 'Agent Validation', contextUser);
             await this.finalizeStepEntity(stepEntity, true);
             return null;
         }
@@ -543,7 +531,7 @@ class BaseAgent {
     async createStepEntity(stepType, stepName, contextUser, targetId, inputData, targetLogId) {
         const stepEntity = await this._metadata.GetEntityObject('MJ: AI Agent Run Steps', contextUser);
         stepEntity.AgentRunID = this._agentRun.ID;
-        stepEntity.StepNumber = this._runContext.currentStepIndex + 1;
+        stepEntity.StepNumber = (this._agentRun.Steps?.length || 0) + 1;
         stepEntity.StepType = stepType;
         stepEntity.StepName = this.formatHierarchicalMessage(stepName);
         if (targetId && !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(targetId)) {
@@ -559,8 +547,8 @@ class BaseAgent {
             stepEntity.InputData = JSON.stringify({
                 ...inputData,
                 context: {
-                    agentHierarchy: this._runContext.agentHierarchy,
-                    depth: this._runContext.depth,
+                    agentHierarchy: this._agentHierarchy,
+                    depth: this._depth,
                     stepNumber: stepEntity.StepNumber
                 }
             });
@@ -568,7 +556,9 @@ class BaseAgent {
         if (!await stepEntity.Save()) {
             throw new Error(`Failed to create agent run step record: ${JSON.stringify(stepEntity.LatestResult)}`);
         }
-        this._runContext.currentStepIndex++;
+        if (this._agentRun) {
+            this._agentRun.Steps.push(stepEntity);
+        }
         return stepEntity;
     }
     async finalizeStepEntity(stepEntity, success, errorMessage, outputData) {
@@ -591,45 +581,64 @@ class BaseAgent {
         }
     }
     formatHierarchicalMessage(baseMessage) {
-        if (this._runContext && this._runContext.depth > 0) {
-            const breadcrumb = this._runContext.agentHierarchy
+        if (this._depth > 0) {
+            const breadcrumb = this._agentHierarchy
                 .slice(1)
                 .join(' → ');
             return breadcrumb ? `${breadcrumb}: ${baseMessage}` : baseMessage;
         }
         return baseMessage;
     }
+    getNextStepReasoning(nextStep) {
+        switch (nextStep.step) {
+            case 'Success':
+                return 'Agent completed task successfully';
+            case 'Failed':
+                return nextStep.errorMessage || 'Agent execution failed';
+            case 'Retry':
+                return nextStep.retryReason || 'Retrying with updated context';
+            case 'Sub-Agent':
+                return `Delegating to sub-agent: ${nextStep.subAgent?.name || 'Unknown'}`;
+            case 'Actions':
+                const actionCount = nextStep.actions?.length || 0;
+                return `Executing ${actionCount} action${actionCount !== 1 ? 's' : ''}`;
+            case 'Chat':
+                return 'Requesting user input';
+            default:
+                return 'Unknown decision';
+        }
+    }
     async executeNextStep(params, config, previousDecision) {
         if (!previousDecision) {
             return await this.executePromptStep(params, config);
         }
         switch (previousDecision.step) {
-            case 'retry':
+            case 'Retry':
                 return await this.executePromptStep(params, config, previousDecision);
-            case 'sub-agent':
-                return await this.executeSubAgentStep(params, previousDecision.subAgent);
-            case 'actions':
-                return await this.executeActionsStep(params, previousDecision.actions);
-            case 'chat':
-                return await this.executeChatStep(params, previousDecision.userMessage);
-            case 'success':
+            case 'Sub-Agent':
+                return await this.executeSubAgentStep(params, previousDecision);
+            case 'Actions':
+                return await this.executeActionsStep(params, previousDecision);
+            case 'Chat':
+                return await this.executeChatStep(params, previousDecision);
+            case 'Success':
                 const pd = previousDecision;
-                if (pd.returnValue?.taskComplete === true && previousDecision.terminate) {
+                if (pd.previousPayload?.taskComplete === true && previousDecision.terminate) {
                     return {
                         terminate: true,
-                        step: 'success',
-                        returnValue: previousDecision.returnValue
+                        step: 'Success',
+                        previousPayload: previousDecision.previousPayload
                     };
                 }
                 else {
                     return await this.executePromptStep(params, config, previousDecision);
                 }
-            case 'failed':
+            case 'Failed':
                 if (previousDecision.terminate) {
                     return {
                         terminate: true,
-                        step: 'failed',
-                        returnValue: previousDecision.returnValue
+                        step: 'Failed',
+                        previousPayload: previousDecision.previousPayload
                     };
                 }
                 else {
@@ -639,24 +648,22 @@ class BaseAgent {
                 throw new Error(`Unsupported next step: ${previousDecision.step}`);
         }
     }
-    async executePromptStep(params, config, retryContext) {
-        const startTime = new Date();
+    async executePromptStep(params, config, previousDecision) {
         const inputData = {
             promptId: config.childPrompt?.ID,
             promptName: config.childPrompt?.Name,
-            isRetry: !!retryContext,
-            retryContext: retryContext ? {
-                reason: retryContext.retryReason,
-                instructions: retryContext.retryInstructions
+            isRetry: !!previousDecision,
+            retryContext: previousDecision ? {
+                reason: previousDecision.retryReason,
+                instructions: previousDecision.retryInstructions
             } : undefined,
             conversationMessages: params.conversationMessages,
-            agentState: this._runContext?.agentState
         };
-        const stepEntity = await this.createStepEntity('prompt', 'Execute Agent Prompt', params.contextUser, config.childPrompt?.ID, inputData);
+        const stepEntity = await this.createStepEntity('Prompt', 'Execute Agent Prompt', params.contextUser, config.childPrompt?.ID, inputData);
         try {
-            const isRetry = !!retryContext;
+            const isRetry = !!previousDecision;
             const promptMessage = isRetry
-                ? `Running ${params.agent.Name} with context from ${retryContext.retryReason || 'previous actions'}`
+                ? `Running ${params.agent.Name} with context from ${previousDecision.retryReason || 'previous actions'}`
                 : `Running ${params.agent.Name}'s initial prompt...`;
             params.onProgress?.({
                 step: 'prompt_execution',
@@ -669,7 +676,11 @@ class BaseAgent {
                 },
                 displayMode: 'live'
             });
-            const promptParams = await this.preparePromptParams(config.agentType, config.systemPrompt, config.childPrompt, params);
+            const payload = previousDecision?.previousPayload || params.payload;
+            if (stepEntity && payload) {
+                stepEntity.PayloadAtStart = JSON.stringify(payload);
+            }
+            const promptParams = await this.preparePromptParams(config, payload, params);
             promptParams.cancellationToken = params.cancellationToken;
             promptParams.onStreaming = params.onStreaming ? (chunk) => {
                 params.onStreaming({
@@ -681,7 +692,7 @@ class BaseAgent {
             const promptResult = await this.executePrompt(promptParams);
             if (promptResult.promptRun?.ID) {
                 stepEntity.TargetLogID = promptResult.promptRun.ID;
-                await stepEntity.Save();
+                stepEntity.PromptRun = promptResult.promptRun;
             }
             if (params.cancellationToken?.aborted) {
                 await this.finalizeStepEntity(stepEntity, false, 'Cancelled during prompt execution');
@@ -689,16 +700,10 @@ class BaseAgent {
                 return {
                     ...cancelledResult,
                     terminate: true,
-                    step: cancelledResult.finalStep,
-                    returnValue: cancelledResult.returnValue,
+                    step: 'Failed',
+                    previousPayload: cancelledResult.payload,
                 };
             }
-            const executionResult = {
-                type: 'prompt',
-                promptId: config.childPrompt.ID,
-                promptName: config.childPrompt.Name,
-                result: promptResult
-            };
             params.onProgress?.({
                 step: 'decision_processing',
                 percentage: 70,
@@ -706,20 +711,18 @@ class BaseAgent {
                 displayMode: 'both'
             });
             const nextStep = await this.processNextStep(params, config.agentType, promptResult);
-            const nextStepDecision = {
-                decision: nextStep.step,
-                reasoning: this.getNextStepReasoning(nextStep),
-                nextStepDetails: this.getNextStepDetails(nextStep)
-            };
-            this._executionChain.push({
-                stepEntity,
-                executionType: 'prompt',
-                executionResult,
-                nextStepDecision,
-                startTime,
-                endTime: new Date(),
-                durationMs: new Date().getTime() - startTime.getTime()
-            });
+            let finalPayload = payload;
+            if (nextStep.payloadChangeRequest) {
+                const changeResult = this._payloadManager.applyAgentChangeRequest(payload, nextStep.payloadChangeRequest, {
+                    validateChanges: true,
+                    logChanges: true,
+                    agentName: params.agent.Name
+                });
+                if (changeResult.warnings.length > 0) {
+                    (0, core_1.LogStatus)(`Payload warnings: ${changeResult.warnings.join('; ')}`);
+                }
+                finalPayload = changeResult.result;
+            }
             const outputData = {
                 promptResult: {
                     success: promptResult.success,
@@ -730,14 +733,22 @@ class BaseAgent {
                 },
                 nextStep: {
                     decision: nextStep.step,
-                    reasoning: nextStepDecision.reasoning
+                    reasoning: this.getNextStepReasoning(nextStep),
+                    payload: finalPayload
                 }
             };
+            if (stepEntity && finalPayload) {
+                stepEntity.PayloadAtEnd = JSON.stringify(finalPayload);
+            }
+            if (this._agentRun && finalPayload) {
+                this._agentRun.FinalPayloadObject = finalPayload;
+            }
+            nextStep.previousPayload = finalPayload;
             await this.finalizeStepEntity(stepEntity, promptResult.success, promptResult.success ? undefined : promptResult.errorMessage, outputData);
-            if (nextStep.step === 'chat') {
+            if (nextStep.step === 'Chat') {
                 return { ...nextStep, terminate: true };
             }
-            else if (nextStep.step === 'success' || nextStep.step === 'failed') {
+            else if (nextStep.step === 'Success' || nextStep.step === 'Failed') {
                 return { ...nextStep, terminate: true };
             }
             else {
@@ -749,12 +760,13 @@ class BaseAgent {
             const errString = error?.message || error || 'Unknown error';
             return {
                 errorMessage: `Prompt execution failed: ${errString}`,
-                step: 'failed',
+                step: 'Failed',
                 terminate: false,
             };
         }
     }
-    async executeSubAgentStep(params, subAgentRequest) {
+    async executeSubAgentStep(params, previousDecision) {
+        const subAgentRequest = previousDecision.subAgent;
         if (params.cancellationToken?.aborted) {
             throw new Error('Cancelled before sub-agent execution');
         }
@@ -763,7 +775,7 @@ class BaseAgent {
             percentage: 60,
             message: this.formatHierarchicalMessage(`Delegating to ${subAgentRequest.name} agent`),
             metadata: {
-                subAgentId: subAgentRequest.id,
+                agentName: params.agent.Name,
                 subAgentName: subAgentRequest.name,
                 reason: subAgentRequest.message
             }
@@ -772,69 +784,79 @@ class BaseAgent {
             role: 'assistant',
             content: `I'm delegating this task to the "${subAgentRequest.name}" agent.\n\nReason: ${subAgentRequest.message}`
         });
-        const startTime = new Date();
         const inputData = {
-            subAgentId: subAgentRequest.id,
+            agentName: params.agent.Name,
             subAgentName: subAgentRequest.name,
             message: subAgentRequest.message,
             terminateAfter: subAgentRequest.terminateAfter,
             conversationMessages: params.conversationMessages,
-            parentAgentHierarchy: this._runContext?.agentHierarchy
+            parentAgentHierarchy: this._agentHierarchy
         };
-        const stepEntity = await this.createStepEntity('subagent', `Execute Sub-Agent: ${subAgentRequest.name}`, params.contextUser, subAgentRequest.id, inputData);
+        const subAgentEntity = aiengine_1.AIEngine.Instance.Agents.find(a => a.Name === subAgentRequest.name &&
+            a.ParentID === params.agent.ID);
+        if (!subAgentEntity) {
+            throw new Error(`Sub-agent '${subAgentRequest.name}' not found`);
+        }
+        const stepEntity = await this.createStepEntity('Sub-Agent', `Execute Sub-Agent: ${subAgentRequest.name}`, params.contextUser, subAgentEntity.ID, inputData);
         try {
-            const subAgentResult = await this.ExecuteSubAgent(params, subAgentRequest);
+            let downstreamPaths = ['*'];
+            let upstreamPaths = ['*'];
+            try {
+                if (subAgentEntity.PayloadDownstreamPaths) {
+                    downstreamPaths = JSON.parse(subAgentEntity.PayloadDownstreamPaths);
+                }
+                if (subAgentEntity.PayloadUpstreamPaths) {
+                    upstreamPaths = JSON.parse(subAgentEntity.PayloadUpstreamPaths);
+                }
+            }
+            catch (parseError) {
+                this.logError(`Failed to parse payload paths for sub-agent ${subAgentRequest.name}: ${parseError.message}`, {
+                    category: 'SubAgentExecution',
+                    metadata: {
+                        agentName: params.agent.Name,
+                        subAgentName: subAgentRequest.name,
+                        subAgentId: subAgentEntity.ID,
+                        downstreamPaths: subAgentEntity.PayloadDownstreamPaths,
+                        upstreamPaths: subAgentEntity.PayloadUpstreamPaths
+                    }
+                });
+            }
+            const downstreamPayload = this._payloadManager.extractDownstreamPayload(subAgentRequest.name, previousDecision.previousPayload, downstreamPaths);
+            stepEntity.PayloadAtStart = JSON.stringify(previousDecision.previousPayload);
+            const subAgentResult = await this.ExecuteSubAgent(params, subAgentRequest, subAgentEntity, stepEntity, downstreamPayload);
+            const mergedPayload = this._payloadManager.mergeUpstreamPayload(subAgentRequest.name, previousDecision.previousPayload, subAgentResult.payload, upstreamPaths);
             if (subAgentResult.agentRun?.ID) {
                 stepEntity.TargetLogID = subAgentResult.agentRun.ID;
-                await stepEntity.Save();
+                stepEntity.SubAgentRun = subAgentResult.agentRun;
+                stepEntity.PayloadAtEnd = JSON.stringify(mergedPayload);
             }
             if (params.cancellationToken?.aborted) {
                 await this.finalizeStepEntity(stepEntity, false, 'Cancelled during sub-agent execution');
                 throw new Error('Cancelled during sub-agent execution');
             }
-            const executionResult = {
-                type: 'sub-agent',
-                subAgentId: subAgentRequest.id,
-                subAgentName: subAgentRequest.name,
-                result: subAgentResult
-            };
             this._subAgentRuns.push(subAgentResult);
             const shouldTerminate = subAgentRequest.terminateAfter;
-            const nextStepType = subAgentResult.returnValue?.step || 'retry';
-            const nextStepDecision = {
-                decision: shouldTerminate ? 'success' : 'retry',
-                reasoning: shouldTerminate ? 'Sub-agent execution completed, terminating as requested' : 'Sub-agent completed, continuing execution',
-                nextStepDetails: { type: nextStepType, returnValue: subAgentResult.returnValue }
-            };
-            this._executionChain.push({
-                stepEntity,
-                executionType: 'sub-agent',
-                executionResult,
-                nextStepDecision,
-                startTime,
-                endTime: new Date(),
-                durationMs: new Date().getTime() - startTime.getTime()
-            });
             const outputData = {
                 subAgentResult: {
                     success: subAgentResult.success,
-                    finalStep: subAgentResult.finalStep,
-                    returnValue: subAgentResult.returnValue,
-                    errorMessage: subAgentResult.errorMessage,
+                    finalStep: subAgentResult.agentRun?.FinalStep,
+                    payload: subAgentResult.payload,
+                    errorMessage: subAgentResult.agentRun?.ErrorMessage,
                     agentRunId: subAgentResult.agentRun?.ID,
-                    stepCount: this.countStepsInTree(subAgentResult.executionTree)
+                    stepCount: subAgentResult.agentRun?.Steps?.length || 0
                 },
                 shouldTerminate: shouldTerminate,
-                nextStep: nextStepDecision.decision
+                nextStep: shouldTerminate ? 'success' : 'retry'
             };
-            await this.finalizeStepEntity(stepEntity, subAgentResult.success, subAgentResult.errorMessage, outputData);
+            await this.finalizeStepEntity(stepEntity, subAgentResult.success, subAgentResult.agentRun?.ErrorMessage, outputData);
             const subAgentSummary = {
+                agentName: params.agent.Name,
                 subAgentName: subAgentRequest.name,
-                subAgentId: subAgentRequest.id,
+                subAgentId: subAgentEntity.ID,
                 success: subAgentResult.success,
-                finalStep: subAgentResult.finalStep,
-                returnValue: subAgentResult.returnValue,
-                errorMessage: subAgentResult.errorMessage || null
+                finalStep: subAgentResult.agentRun?.FinalStep,
+                payload: subAgentResult.payload,
+                errorMessage: subAgentResult.agentRun?.ErrorMessage || null
             };
             const resultMessage = subAgentResult.success
                 ? `Sub-agent completed successfully:\n${JSON.stringify(subAgentSummary, null, 2)}`
@@ -843,42 +865,40 @@ class BaseAgent {
                 role: 'user',
                 content: resultMessage
             });
+            if (stepEntity) {
+                stepEntity.PayloadAtEnd = JSON.stringify(mergedPayload);
+            }
+            if (this._agentRun) {
+                this._agentRun.FinalPayloadObject = mergedPayload;
+            }
             return {
                 ...subAgentResult,
-                step: subAgentResult.success ? 'success' : 'failed',
-                terminate: shouldTerminate
+                step: subAgentResult.success ? 'Success' : 'Failed',
+                terminate: shouldTerminate,
+                previousPayload: mergedPayload
             };
         }
         catch (error) {
             await this.finalizeStepEntity(stepEntity, false, error.message);
             return {
                 errorMessage: `Sub-agent execution failed: ${error.message}`,
-                step: 'failed',
+                step: 'Failed',
                 terminate: false,
             };
         }
     }
-    async executeActionsStep(params, actions) {
+    async executeActionsStep(params, previousDecision) {
         try {
+            const actions = previousDecision.actions || [];
             if (params.cancellationToken?.aborted) {
                 throw new Error('Cancelled before action execution');
             }
-            const actionEntities = actions.map(action => {
-                const actionEntity = actions_1.ActionEngineServer.Instance.Actions.find(a => a.ID.trim().toLowerCase() === action.id.trim().toLowerCase());
-                if (!actionEntity) {
-                    throw new Error(`Action with ID ${action.id} and Name "${action.name}" not found`);
-                }
-                if (actionEntity.Name.trim().toLowerCase() !== action.name.trim().toLowerCase()) {
-                    throw new Error(`Action with ID ${action.id} has a different name "${actionEntity.Name}" than provided "${action.name}"`);
-                }
-                return actionEntity;
-            });
             let progressMessage;
             if (actions.length === 1) {
-                const action = actions[0];
-                progressMessage = `Executing action: **${action.name}**`;
-                if (action.params && Object.keys(action.params).length > 0) {
-                    const paramsList = Object.entries(action.params)
+                const aa = actions[0];
+                progressMessage = `Executing action: **${aa.name}**`;
+                if (aa.params && Object.keys(aa.params).length > 0) {
+                    const paramsList = Object.entries(aa.params)
                         .map(([key, value]) => {
                         const displayValue = typeof value === 'object'
                             ? JSON.stringify(value, null, 2)
@@ -891,10 +911,10 @@ class BaseAgent {
             }
             else {
                 progressMessage = `Executing ${actions.length} actions:`;
-                actions.forEach(action => {
-                    progressMessage += `\n\n• **${action.name}**`;
-                    if (action.params && Object.keys(action.params).length > 0) {
-                        const paramsList = Object.entries(action.params)
+                actions.forEach(aa => {
+                    progressMessage += `\n\n• **${aa.name}**`;
+                    if (aa.params && Object.keys(aa.params).length > 0) {
+                        const paramsList = Object.entries(aa.params)
                             .map(([key, value]) => {
                             const displayValue = typeof value === 'object'
                                 ? JSON.stringify(value, null, 2)
@@ -923,36 +943,21 @@ class BaseAgent {
                 role: 'assistant',
                 content: actionMessage
             });
-            const actionPromises = actions.map(async (action) => {
-                const startTime = new Date();
-                const stepEntity = await this.createStepEntity('action', `Execute Action: ${action.name}`, params.contextUser, action.id);
+            const actionEngine = actions_1.ActionEngineServer.Instance;
+            const agentActions = aiengine_1.AIEngine.Instance.AgentActions.filter(aa => aa.AgentID === params.agent.ID);
+            const actionPromises = actions.map(async (aa) => {
+                const actionEntity = actionEngine.Actions.find(a => a.Name === aa.name && agentActions.some(aa => aa.ActionID === a.ID));
+                if (!actionEntity) {
+                    throw new Error(`Action "${aa.name}" Not Found for Agent "${params.agent.Name}"`);
+                }
+                const stepEntity = await this.createStepEntity('Actions', `Execute Action: ${aa.name}`, params.contextUser, actionEntity.ID);
                 let actionResult;
                 try {
-                    actionResult = await this.ExecuteSingleAction(params, action, params.contextUser);
+                    actionResult = await this.ExecuteSingleAction(params, aa, actionEntity, params.contextUser);
                     if (actionResult.LogEntry?.ID) {
                         stepEntity.TargetLogID = actionResult.LogEntry.ID;
                         await stepEntity.Save();
                     }
-                    const executionResult = {
-                        type: 'action',
-                        actionId: action.id,
-                        actionName: action.name,
-                        result: actionResult
-                    };
-                    const nextStepDecision = {
-                        decision: 'retry',
-                        reasoning: 'Action completed successfully',
-                        nextStepDetails: undefined
-                    };
-                    this._executionChain.push({
-                        stepEntity,
-                        executionType: 'action',
-                        executionResult,
-                        nextStepDecision,
-                        startTime,
-                        endTime: new Date(),
-                        durationMs: new Date().getTime() - startTime.getTime()
-                    });
                     const outputData = {
                         actionResult: {
                             success: actionResult.Success,
@@ -962,11 +967,11 @@ class BaseAgent {
                         }
                     };
                     await this.finalizeStepEntity(stepEntity, actionResult.Success, actionResult.Success ? undefined : actionResult.Message, outputData);
-                    return { success: true, result: actionResult, action, stepEntity };
+                    return { success: true, result: actionResult, action: aa, actionEntity, stepEntity };
                 }
                 catch (error) {
                     await this.finalizeStepEntity(stepEntity, false, error.message);
-                    return { success: false, result: actionResult, error: error.message, action, stepEntity };
+                    return { success: false, result: actionResult, error: error.message, action: aa, actionEntity, stepEntity };
                 }
             });
             const actionResults = await Promise.all(actionPromises);
@@ -977,7 +982,7 @@ class BaseAgent {
                 const actionResult = result.success ? result.result : null;
                 return {
                     actionName: result.action.name,
-                    actionId: result.action.id,
+                    actionId: result.actionEntity?.ID,
                     params: result.result?.Params || {},
                     success: result.success,
                     resultCode: actionResult?.Result?.ResultCode || (result.success ? 'SUCCESS' : 'ERROR'),
@@ -994,8 +999,9 @@ class BaseAgent {
             });
             return {
                 terminate: false,
-                step: 'retry',
-                returnValue: actionSummaries,
+                step: 'Retry',
+                previousPayload: previousDecision?.previousPayload || null,
+                priorStepResult: actionSummaries,
                 retryReason: failedActions.length > 0
                     ? `Processing results with ${failedActions.length} failed action(s): ${failedActions.map(a => a.actionName).join(', ')}`
                     : `Analyzing results from ${actionSummaries.length} completed action(s) to formulate response`
@@ -1004,38 +1010,22 @@ class BaseAgent {
         catch (e) {
             return {
                 terminate: false,
-                step: 'retry',
-                returnValue: e && e.message ? e.message : e ? e : 'Unknown error execution actions',
+                step: 'Retry',
+                errorMessage: e && e.message ? e.message : e ? e : 'Unknown error execution actions',
                 retryReason: 'Error while processing actions, retry'
             };
         }
     }
-    async executeChatStep(params, userMessage) {
-        const startTime = new Date();
-        const stepEntity = await this.createStepEntity('chat', 'User Interaction', params.contextUser);
-        const executionResult = {
-            type: 'chat',
-            userMessage,
-            result: { success: false, continueExecution: false }
-        };
-        const nextStepDecision = {
-            decision: 'failed',
-            reasoning: 'Chat functionality not implemented in base agent'
-        };
-        this._executionChain.push({
-            stepEntity,
-            executionType: 'chat',
-            executionResult,
-            nextStepDecision,
-            startTime,
-            endTime: new Date(),
-            durationMs: new Date().getTime() - startTime.getTime()
-        });
+    async executeChatStep(params, previousDecision) {
+        const stepEntity = await this.createStepEntity('Chat', 'User Interaction', params.contextUser);
         await this.finalizeStepEntity(stepEntity, false, 'Chat not implemented');
         return {
-            step: 'chat',
+            step: 'Chat',
             terminate: true,
-            returnValue: userMessage,
+            priorStepResult: previousDecision.message,
+            reasoning: previousDecision.reasoning,
+            confidence: previousDecision.confidence,
+            previousPayload: previousDecision.previousPayload,
         };
     }
     async createFailureResult(errorMessage, contextUser) {
@@ -1053,10 +1043,7 @@ class BaseAgent {
         }
         return {
             success: false,
-            finalStep: 'failed',
-            errorMessage,
-            agentRun: this._agentRun,
-            executionTree: this.buildExecutionTree()
+            agentRun: this._agentRun
         };
     }
     async createCancelledResult(message, contextUser) {
@@ -1074,220 +1061,57 @@ class BaseAgent {
         }
         return {
             success: false,
-            finalStep: 'failed',
-            errorMessage: message,
-            cancelled: true,
-            cancellationReason: 'user_requested',
-            agentRun: this._agentRun,
-            executionTree: this.buildExecutionTree()
+            agentRun: this._agentRun
         };
     }
-    async finalizeAgentRun(finalStep, returnValue, contextUser) {
+    async finalizeAgentRun(finalStep, payload, contextUser) {
         if (this._agentRun) {
             this._agentRun.Status = 'Completed';
             this._agentRun.CompletedAt = new Date();
-            this._agentRun.Success = finalStep === 'success';
-            this._agentRun.Result = returnValue ? JSON.stringify(returnValue) : null;
+            this._agentRun.Success = finalStep.step === 'Success' || finalStep.step === 'Chat';
+            this._agentRun.Result = payload ? JSON.stringify(payload) : null;
+            this._agentRun.FinalStep = finalStep.step;
+            this._agentRun.Message = finalStep.message;
+            this._agentRun.FinalPayloadObject = payload;
             const tokenStats = this.calculateTokenStats();
             this._agentRun.TotalTokensUsed = tokenStats.totalTokens;
             this._agentRun.TotalPromptTokensUsed = tokenStats.promptTokens;
             this._agentRun.TotalCompletionTokensUsed = tokenStats.completionTokens;
             this._agentRun.TotalCost = tokenStats.totalCost;
-            await this._agentRun.Save();
+            const ok = await this._agentRun.Save();
+            if (!ok) {
+                (0, core_1.LogError)(`Failed to finalize agent run ${this._agentRun.ID}`);
+            }
         }
         return {
-            success: finalStep === 'success' || finalStep === 'chat',
-            finalStep,
-            returnValue,
-            agentRun: this._agentRun,
-            executionTree: this.buildExecutionTree()
+            success: finalStep.step === 'Success' || finalStep.step === 'Chat',
+            payload,
+            agentRun: this._agentRun
         };
     }
-    countStepsInTree(nodes) {
-        let count = 0;
-        for (const node of nodes) {
-            count++;
-            if (node.children && node.children.length > 0) {
-                count += this.countStepsInTree(node.children);
-            }
-        }
-        return count;
-    }
     calculateTokenStats() {
         let totalTokens = 0;
         let promptTokens = 0;
         let completionTokens = 0;
         let totalCost = 0;
-        for (const step of this._executionChain) {
-            if (step.executionType === 'prompt' && step.executionResult.type === 'prompt') {
-                const promptResult = step.executionResult;
-                if (promptResult.result) {
-                    totalTokens += promptResult.result.tokensUsed || 0;
-                    promptTokens += promptResult.result.promptTokens || 0;
-                    completionTokens += promptResult.result.completionTokens || 0;
-                    totalCost += promptResult.result.promptRun?.TotalCost || 0;
+        if (this._agentRun?.Steps) {
+            for (const step of this._agentRun.Steps) {
+                if (step.StepType === 'Prompt' && step.PromptRun) {
+                    totalTokens += step.PromptRun.TokensUsedRollup || 0;
+                    promptTokens += step.PromptRun.TokensPromptRollup || 0;
+                    completionTokens += step.PromptRun.TokensCompletionRollup || 0;
+                    totalCost += step.PromptRun.TotalCost || 0;
                 }
-            }
-            else if (step.executionType === 'sub-agent' && step.executionResult.type === 'sub-agent') {
-                const subAgentResult = step.executionResult;
-                if (subAgentResult.result?.agentRun) {
-                    totalTokens += subAgentResult.result.agentRun.TotalTokensUsed || 0;
-                    promptTokens += subAgentResult.result.agentRun.TotalPromptTokensUsed || 0;
-                    completionTokens += subAgentResult.result.agentRun.TotalCompletionTokensUsed || 0;
-                    totalCost += subAgentResult.result.agentRun.TotalCost || 0;
+                else if (step.StepType === 'Sub-Agent' && step.SubAgentRun) {
+                    totalTokens += step.SubAgentRun.TotalTokensUsed || 0;
+                    promptTokens += step.SubAgentRun.TotalPromptTokensUsed || 0;
+                    completionTokens += step.SubAgentRun.TotalCompletionTokensUsed || 0;
+                    totalCost += step.SubAgentRun.TotalCost || 0;
                 }
             }
         }
         return { totalTokens, promptTokens, completionTokens, totalCost };
     }
-    buildExecutionTree() {
-        const executionTree = [];
-        const allEvents = [];
-        let maxProgressStepNumber = 0;
-        for (const progressStep of this._allProgressSteps) {
-            allEvents.push({
-                type: 'progress',
-                timestamp: progressStep.timestamp,
-                data: progressStep
-            });
-        }
-        for (const chainStep of this._executionChain) {
-            allEvents.push({
-                type: 'execution',
-                timestamp: chainStep.startTime,
-                data: chainStep
-            });
-        }
-        allEvents.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-        for (const event of allEvents) {
-            if (event.type === 'progress') {
-                const progressData = event.data;
-                maxProgressStepNumber++;
-                const progressNode = {
-                    step: {
-                        ID: `progress-${event.timestamp.getTime()}`,
-                        StepNumber: maxProgressStepNumber,
-                        StepName: progressData.message,
-                        StepType: progressData.step || 'progress',
-                        Status: 'Completed',
-                        StartedAt: event.timestamp,
-                        CompletedAt: event.timestamp
-                    },
-                    inputData: null,
-                    outputData: {
-                        percentage: progressData.percentage,
-                        metadata: progressData.metadata
-                    },
-                    executionType: progressData.step || 'progress',
-                    startTime: event.timestamp,
-                    endTime: event.timestamp,
-                    durationMs: 0,
-                    children: [],
-                    depth: progressData.depth || this._runContext?.depth || 0,
-                    parentStepId: null,
-                    agentHierarchy: progressData.agentHierarchy || this._runContext?.agentHierarchy || []
-                };
-                executionTree.push(progressNode);
-            }
-            else {
-                const chainStep = event.data;
-                const stepEntity = chainStep.stepEntity;
-                let inputData = null;
-                let outputData = null;
-                try {
-                    if (stepEntity.InputData) {
-                        inputData = JSON.parse(stepEntity.InputData);
-                    }
-                    if (stepEntity.OutputData) {
-                        outputData = JSON.parse(stepEntity.OutputData);
-                    }
-                }
-                catch (e) {
-                    inputData = stepEntity.InputData;
-                    outputData = stepEntity.OutputData;
-                }
-                const node = {
-                    step: stepEntity,
-                    inputData,
-                    outputData,
-                    executionType: chainStep.executionType,
-                    startTime: chainStep.startTime,
-                    endTime: chainStep.endTime,
-                    durationMs: chainStep.durationMs,
-                    nextStepDecision: chainStep.nextStepDecision,
-                    children: [],
-                    depth: this._runContext?.depth || 0,
-                    parentStepId: null,
-                    agentHierarchy: this._runContext?.agentHierarchy || []
-                };
-                if (chainStep.executionType === 'sub-agent' && chainStep.executionResult?.type === 'sub-agent') {
-                    const subAgentResult = chainStep.executionResult.result;
-                    if (subAgentResult.executionTree) {
-                        node.children = subAgentResult.executionTree.map(childNode => ({
-                            ...childNode,
-                            parentStepId: stepEntity.ID,
-                            depth: (this._runContext?.depth || 0) + 1
-                        }));
-                        this.sortExecutionTreeByStepNumber(node.children);
-                    }
-                }
-                executionTree.push(node);
-            }
-        }
-        this.sortExecutionTreeByStepNumber(executionTree);
-        return executionTree;
-    }
-    sortExecutionTreeByStepNumber(nodes) {
-        nodes.sort((a, b) => {
-            const aStepNumber = a.step?.StepNumber || 0;
-            const bStepNumber = b.step?.StepNumber || 0;
-            return aStepNumber - bStepNumber;
-        });
-        for (const node of nodes) {
-            if (node.children && node.children.length > 0) {
-                this.sortExecutionTreeByStepNumber(node.children);
-            }
-        }
-    }
-    getNextStepReasoning(nextStep) {
-        switch (nextStep.step) {
-            case 'success':
-                return 'Agent completed successfully';
-            case 'failed':
-                return `Agent failed: ${nextStep.errorMessage || 'Unknown error'}`;
-            case 'retry':
-                return nextStep.retryReason || 'Retrying with additional context';
-            case 'sub-agent':
-                return `Invoking sub-agent: ${nextStep.subAgent?.name}`;
-            case 'actions':
-                return `Executing ${nextStep.actions?.length || 0} action(s)`;
-            case 'chat':
-                return 'User interaction required';
-            default:
-                return 'Unknown next step';
-        }
-    }
-    getNextStepDetails(nextStep) {
-        switch (nextStep.step) {
-            case 'success':
-            case 'failed':
-                return { type: 'complete', returnValue: nextStep.returnValue };
-            case 'retry':
-                return {
-                    type: 'retry',
-                    retryReason: nextStep.retryReason || '',
-                    retryInstructions: nextStep.retryInstructions || ''
-                };
-            case 'sub-agent':
-                return nextStep.subAgent ? { type: 'sub-agent', subAgent: nextStep.subAgent } : undefined;
-            case 'actions':
-                return nextStep.actions ? { type: 'action', actions: nextStep.actions } : undefined;
-            case 'chat':
-                return { type: 'chat', message: nextStep.userMessage || '' };
-            default:
-                return undefined;
-        }
-    }
 }
 exports.BaseAgent = BaseAgent;
 //# sourceMappingURL=base-agent.js.map