@memberjunction/ai-agents 2.49.0 → 2.51.0

package/dist/base-agent.js

@@ -1,113 +1,236 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseAgent = void 0;
+const core_1 = require("@memberjunction/core");
 const ai_prompts_1 = require("@memberjunction/ai-prompts");
-const base_agent_type_1 = require("./base-agent-type");
+const base_agent_type_1 = require("./agent-types/base-agent-type");
 const global_1 = require("@memberjunction/global");
 const aiengine_1 = require("@memberjunction/aiengine");
 const actions_1 = require("@memberjunction/actions");
+const AgentRunner_1 = require("./AgentRunner");
 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._allProgressSteps = [];
+        this._subAgentRuns = [];
+    }
+    async getAgentRunSteps(contextUser) {
+        if (!this._agentRun)
+            return [];
+        const md = new core_1.Metadata();
+        const rv = new core_1.RunView();
+        const result = await rv.RunView({
+            EntityName: 'MJ: AI Agent Run Steps',
+            ExtraFilter: `AgentRunID = '${this._agentRun.ID}'`,
+            OrderBy: 'StepNumber',
+            ResultType: 'entity_object'
+        }, contextUser);
+        return result.Success ? result.Results : [];
+    }
+    wrapProgressCallback(originalCallback) {
+        if (!originalCallback)
+            return undefined;
+        return (progress) => {
+            this._allProgressSteps.push({
+                ...progress,
+                timestamp: new Date(),
+                agentHierarchy: this._runContext?.agentHierarchy || [],
+                depth: this._runContext?.depth || 0
+            });
+            originalCallback(progress);
+        };
     }
     async Execute(params) {
         try {
-            await aiengine_1.AIEngine.Instance.Config(false, params.contextUser);
-            await actions_1.ActionEngineServer.Instance.Config(false, params.contextUser);
-            const engine = aiengine_1.AIEngine.Instance;
-            if (params.agent.Status !== 'Active') {
-                return {
-                    nextStep: 'failed',
-                    errorMessage: `Agent '${params.agent.Name}' is not active. Current status: ${params.agent.Status}`
-                };
-            }
-            const agentType = engine.AgentTypes.find(at => at.ID === params.agent.TypeID);
-            if (!agentType) {
-                return {
-                    nextStep: 'failed',
-                    errorMessage: `Agent type not found for ID: ${params.agent.TypeID}`
-                };
-            }
-            const systemPrompt = engine.Prompts.find(p => p.ID === agentType.SystemPromptID);
-            if (!systemPrompt) {
-                return {
-                    nextStep: 'failed',
-                    errorMessage: `System prompt not found for agent type: ${agentType.Name}`
-                };
-            }
-            const agentPrompt = engine.AgentPrompts
-                .filter(ap => ap.AgentID === params.agent.ID && ap.Status === 'Active')
-                .sort((a, b) => a.ExecutionOrder - b.ExecutionOrder)[0];
-            if (!agentPrompt) {
-                return {
-                    nextStep: 'failed',
-                    errorMessage: `No prompts configured for agent: ${params.agent.Name}`
-                };
+            const wrappedParams = {
+                ...params,
+                onProgress: this.wrapProgressCallback(params.onProgress)
+            };
+            if (params.cancellationToken?.aborted) {
+                return await this.createCancelledResult('Cancelled before execution started', params.contextUser);
             }
-            const childPrompt = engine.Prompts.find(p => p.ID === agentPrompt.PromptID);
-            if (!childPrompt) {
-                return {
-                    nextStep: 'failed',
-                    errorMessage: `Child prompt not found for ID: ${agentPrompt.PromptID}`
-                };
+            wrappedParams.onProgress?.({
+                step: 'initialization',
+                percentage: 0,
+                message: this.formatHierarchicalMessage(`Initializing ${params.agent.Name} agent and preparing execution environment`)
+            });
+            await this.initializeAgentRun(wrappedParams);
+            await this.initializeEngines(params.contextUser);
+            if (params.cancellationToken?.aborted) {
+                return await this.createCancelledResult('Cancelled during initialization', params.contextUser);
             }
-            const contextData = await this.gatherContextData(params.agent, params.contextUser);
-            const promptParams = new ai_prompts_1.AIPromptParams();
-            promptParams.prompt = systemPrompt;
-            promptParams.data = contextData;
-            promptParams.contextUser = params.contextUser;
-            promptParams.conversationMessages = params.conversationMessages;
-            promptParams.templateMessageRole = 'system';
-            if (!agentType.AgentPromptPlaceholder) {
-                const errorMsg = `Agent type '${agentType.Name}' does not have AgentPromptPlaceholder configured. This field is required to properly inject agent prompt results into the system prompt template.`;
-                console.error(errorMsg);
-                return {
-                    nextStep: 'failed',
-                    errorMessage: errorMsg
-                };
+            wrappedParams.onProgress?.({
+                step: 'validation',
+                percentage: 10,
+                message: this.formatHierarchicalMessage('Validating agent configuration and loading prompts')
+            });
+            const validationResult = await this.validateAgentWithTracking(params.agent, params.contextUser);
+            if (validationResult)
+                return validationResult;
+            const config = await this.loadAgentConfiguration(params.agent);
+            if (!config.success) {
+                return await this.createFailureResult(config.errorMessage || 'Failed to load agent configuration', params.contextUser);
             }
-            promptParams.childPrompts = [
-                new ai_prompts_1.ChildPromptParam({
-                    prompt: childPrompt,
-                    data: contextData,
-                    contextUser: params.contextUser,
-                    conversationMessages: params.conversationMessages,
-                    templateMessageRole: 'user'
-                }, agentType.AgentPromptPlaceholder)
-            ];
-            const result = await this._promptRunner.ExecutePrompt(promptParams);
-            if (!result.success) {
-                return {
-                    nextStep: 'failed',
-                    errorMessage: result.errorMessage,
-                    rawResult: result.rawResult
-                };
+            let continueExecution = true;
+            let currentNextStep = null;
+            let finalReturnValue = undefined;
+            let stepCount = 0;
+            while (continueExecution) {
+                if (params.cancellationToken?.aborted) {
+                    return await this.createCancelledResult('Cancelled during execution', params.contextUser);
+                }
+                const stepResult = await this.executeNextStep(wrappedParams, config, currentNextStep);
+                stepCount++;
+                if (stepResult.terminate) {
+                    continueExecution = false;
+                    finalReturnValue = stepResult.returnValue;
+                }
+                else {
+                    currentNextStep = stepResult.nextStep;
+                }
             }
-            let agentTypeInstance;
-            try {
-                agentTypeInstance = await this.getAgentTypeInstance(agentType);
-            }
-            catch (error) {
-                return {
-                    nextStep: 'failed',
-                    errorMessage: error.message
-                };
+            wrappedParams.onProgress?.({
+                step: 'finalization',
+                percentage: 95,
+                message: this.formatHierarchicalMessage('Finalizing agent execution')
+            });
+            return await this.finalizeAgentRun(finalReturnValue?.step || 'success', finalReturnValue, params.contextUser);
+        }
+        catch (error) {
+            if (params.cancellationToken?.aborted) {
+                return await this.createCancelledResult('Cancelled due to error during execution', params.contextUser);
             }
-            const nextStep = await agentTypeInstance.DetermineNextStep(result);
+            return await this.createFailureResult(error.message, params.contextUser);
+        }
+    }
+    async initializeEngines(contextUser) {
+        await aiengine_1.AIEngine.Instance.Config(false, contextUser);
+        await actions_1.ActionEngineServer.Instance.Config(false, contextUser);
+    }
+    async validateAgent(agent) {
+        if (agent.Status !== 'Active') {
             return {
-                nextStep: nextStep.step,
-                returnValue: nextStep.returnValue || result.result,
-                rawResult: result.rawResult
+                success: false,
+                finalStep: 'failed',
+                errorMessage: `Agent '${agent.Name}' is not active. Current status: ${agent.Status}`,
+                agentRun: this._agentRun,
+                executionTree: []
             };
         }
+        return null;
+    }
+    async loadAgentConfiguration(agent) {
+        const engine = aiengine_1.AIEngine.Instance;
+        const agentType = engine.AgentTypes.find(at => at.ID === agent.TypeID);
+        if (!agentType) {
+            return {
+                success: false,
+                errorMessage: `Agent type not found for ID: ${agent.TypeID}`
+            };
+        }
+        const systemPrompt = engine.Prompts.find(p => p.ID === agentType.SystemPromptID);
+        if (!systemPrompt) {
+            return {
+                success: false,
+                errorMessage: `System prompt not found for agent type: ${agentType.Name}`
+            };
+        }
+        const agentPrompt = engine.AgentPrompts
+            .filter(ap => ap.AgentID === agent.ID && ap.Status === 'Active')
+            .sort((a, b) => a.ExecutionOrder - b.ExecutionOrder)[0];
+        if (!agentPrompt) {
+            return {
+                success: false,
+                errorMessage: `No prompts configured for agent: ${agent.Name}`
+            };
+        }
+        const childPrompt = engine.Prompts.find(p => p.ID === agentPrompt.PromptID);
+        if (!childPrompt) {
+            return {
+                success: false,
+                errorMessage: `Child prompt not found for ID: ${agentPrompt.PromptID}`
+            };
+        }
+        if (!agentType.AgentPromptPlaceholder) {
+            return {
+                success: false,
+                errorMessage: `Agent type '${agentType.Name}' does not have AgentPromptPlaceholder configured.`
+            };
+        }
+        return {
+            success: true,
+            agentType,
+            systemPrompt,
+            childPrompt
+        };
+    }
+    async preparePromptParams(agentType, systemPrompt, childPrompt, params) {
+        const contextData = await this.gatherContextData(params.agent, params.contextUser);
+        const promptParams = new ai_prompts_1.AIPromptParams();
+        promptParams.prompt = systemPrompt;
+        promptParams.data = contextData;
+        promptParams.contextUser = params.contextUser;
+        promptParams.conversationMessages = params.conversationMessages;
+        promptParams.templateMessageRole = 'system';
+        promptParams.childPrompts = [
+            new ai_prompts_1.ChildPromptParam({
+                prompt: childPrompt,
+                data: contextData,
+                contextUser: params.contextUser,
+                conversationMessages: params.conversationMessages,
+                templateMessageRole: 'user'
+            }, agentType.AgentPromptPlaceholder)
+        ];
+        return promptParams;
+    }
+    async executePrompt(promptParams) {
+        return await this._promptRunner.ExecutePrompt(promptParams);
+    }
+    async processNextStep(params, agentType, promptResult) {
+        let agentTypeInstance;
+        try {
+            agentTypeInstance = await this.getAgentTypeInstance(agentType);
+        }
         catch (error) {
             return {
-                nextStep: 'failed',
-                errorMessage: error.message,
+                step: 'failed',
+                errorMessage: error.message
             };
         }
+        const nextStep = await agentTypeInstance.DetermineNextStep(promptResult);
+        return nextStep;
+    }
+    createActionResultMessage(actions, results) {
+        const resultSummary = actions.map((action, index) => {
+            const result = results[index];
+            const outputParams = result.Params?.filter((p) => p.Type === 'Output' || p.Type === 'Both') || [];
+            return {
+                actionName: action.name,
+                success: result.Success,
+                resultCode: result.Result?.Code || 'N/A',
+                message: result.Message || null,
+                outputs: outputParams.reduce((acc, param) => {
+                    acc[param.Name] = param.Value;
+                    return acc;
+                }, {})
+            };
+        });
+        return {
+            role: 'user',
+            content: `Action results:\n${JSON.stringify(resultSummary, null, 2)}`
+        };
+    }
+    createSubAgentResultMessage(subAgent, result) {
+        return {
+            role: 'user',
+            content: `Sub-agent '${subAgent.name}' result:\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}`
+        };
     }
-    async gatherContextData(agent, contextUser) {
+    async gatherContextData(agent, _contextUser) {
         try {
             const engine = aiengine_1.AIEngine.Instance;
             const subAgents = engine.Agents.filter(a => a.ParentID === agent.ID)
@@ -119,21 +242,9 @@ class BaseAgent {
                 agentName: agent.Name,
                 agentDescription: agent.Description,
                 subAgentCount: subAgents.length,
-                subAgentDetails: JSON.stringify(subAgents.map(sa => {
-                    return {
-                        ID: sa.ID,
-                        Name: sa.Name,
-                        Description: sa.Description
-                    };
-                }), null, 2),
+                subAgentDetails: this.formatSubAgentDetails(subAgents),
                 actionCount: actions.length,
-                actionDetails: JSON.stringify(activeActions.map(action => {
-                    return {
-                        ID: action.ID,
-                        Name: action.Name,
-                        Description: action.Description,
-                    };
-                }), null, 2),
+                actionDetails: this.formatActionDetails(activeActions),
             };
             return contextData;
         }
@@ -151,6 +262,882 @@ class BaseAgent {
         }
         return instance;
     }
+    async ExecuteActions(actions, contextUser) {
+        try {
+            const actionEngine = actions_1.ActionEngineServer.Instance;
+            const actionPromises = actions.map(async (action) => {
+                const actionEntity = actionEngine.Actions.find(a => a.ID === action.id || a.Name === action.name);
+                if (!actionEntity) {
+                    throw new Error(`Action not found: ${action.name || action.id}`);
+                }
+                const actionParams = Object.entries(action.params || {}).map(([key, value]) => ({
+                    Name: key,
+                    Value: value,
+                    Type: 'Input'
+                }));
+                const result = await actionEngine.RunAction({
+                    Action: actionEntity,
+                    Params: actionParams,
+                    ContextUser: contextUser,
+                    Filters: [],
+                    SkipActionLog: false
+                });
+                if (!result.Success) {
+                    throw new Error(`Action '${action.name}' failed: ${result.Message || 'Unknown error'}`);
+                }
+                return result;
+            });
+            return await Promise.all(actionPromises);
+        }
+        catch (error) {
+            throw new Error(`Error executing actions: ${error.message}`);
+        }
+    }
+    async ExecuteSubAgent(subAgentRequest, conversationMessages, contextUser, cancellationToken, onProgress, onStreaming) {
+        try {
+            const engine = aiengine_1.AIEngine.Instance;
+            const subAgent = engine.Agents.find(a => a.ID === subAgentRequest.id || a.Name === subAgentRequest.name);
+            if (!subAgent) {
+                throw new Error(`Sub-agent not found: ${subAgentRequest.name || subAgentRequest.id}`);
+            }
+            const runner = new AgentRunner_1.AgentRunner();
+            const subAgentMessages = [
+                ...conversationMessages,
+                {
+                    role: 'user',
+                    content: subAgentRequest.message
+                }
+            ];
+            const result = await runner.RunAgent({
+                agent: subAgent,
+                conversationMessages: subAgentMessages,
+                contextUser: contextUser,
+                cancellationToken: cancellationToken,
+                onProgress: onProgress,
+                onStreaming: onStreaming,
+                parentAgentHierarchy: this._runContext?.agentHierarchy,
+                parentDepth: this._runContext?.depth
+            });
+            if (!result.success) {
+                throw new Error(`Sub-agent '${subAgentRequest.name}' failed: ${result.errorMessage || 'Unknown error'}`);
+            }
+            return result;
+        }
+        catch (error) {
+            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',
+            Status: sa.Status,
+            ExecutionMode: sa.ExecutionMode,
+            ExecutionOrder: sa.ExecutionOrder
+        })), null, 2);
+    }
+    formatActionDetails(actions) {
+        return JSON.stringify(actions.map(action => ({
+            ID: action.ID,
+            Name: action.Name,
+            Description: action.Description,
+            Parameters: {
+                Input: action.Params
+                    .filter(p => p.Type.trim().toLowerCase() === 'input' || p.Type.trim().toLowerCase() === 'both')
+                    .map(param => this.formatActionParameter(param)),
+                Output: action.Params
+                    .filter(p => p.Type.trim().toLowerCase() === 'output' || p.Type.trim().toLowerCase() === 'both')
+                    .map(param => this.formatActionParameter(param))
+            },
+            ResultCodes: action.ResultCodes.map(rc => ({
+                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
+        })), null, 2);
+    }
+    formatActionParameter(param) {
+        return {
+            Name: param.Name,
+            Type: param.Type,
+            IsRequired: param.IsRequired,
+            IsArray: param.IsArray,
+            DefaultValue: param.DefaultValue,
+            Description: param.Description,
+            ValueType: param.ValueType
+        };
+    }
+    getAgentTypeName(typeID) {
+        const agentType = aiengine_1.AIEngine.Instance.AgentTypes.find(at => at.ID === typeID);
+        return agentType?.Name || 'Unknown';
+    }
+    getValueListItems(valueListID) {
+        return null;
+    }
+    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;
+        this._agentRun.Status = 'Running';
+        this._agentRun.StartedAt = new Date();
+        this._agentRun.UserID = params.contextUser?.ID || null;
+        this._agentRun.ParentRunID = null;
+        if (!await this._agentRun.Save()) {
+            throw new Error('Failed to create agent run record');
+        }
+        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._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);
+            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()
+            });
+            await this.finalizeStepEntity(stepEntity, true);
+            return null;
+        }
+        catch (error) {
+            return await this.createFailureResult(`Validation error: ${error.message}`, contextUser);
+        }
+    }
+    async createStepEntity(stepType, stepName, contextUser, targetId, inputData) {
+        const stepEntity = await this._metadata.GetEntityObject('MJ: AI Agent Run Steps', contextUser);
+        stepEntity.AgentRunID = this._agentRun.ID;
+        stepEntity.StepNumber = this._runContext.currentStepIndex + 1;
+        stepEntity.StepType = stepType;
+        stepEntity.StepName = this.formatHierarchicalMessage(stepName);
+        stepEntity.TargetID = targetId || null;
+        stepEntity.Status = 'Running';
+        stepEntity.StartedAt = new Date();
+        if (inputData) {
+            stepEntity.InputData = JSON.stringify({
+                ...inputData,
+                context: {
+                    agentHierarchy: this._runContext.agentHierarchy,
+                    depth: this._runContext.depth,
+                    stepNumber: stepEntity.StepNumber
+                }
+            });
+        }
+        if (!await stepEntity.Save()) {
+            throw new Error(`Failed to create agent run step record: ${JSON.stringify(stepEntity.LatestResult)}`);
+        }
+        this._runContext.currentStepIndex++;
+        return stepEntity;
+    }
+    async finalizeStepEntity(stepEntity, success, errorMessage, outputData) {
+        stepEntity.Status = success ? 'Completed' : 'Failed';
+        stepEntity.CompletedAt = new Date();
+        stepEntity.Success = success;
+        stepEntity.ErrorMessage = errorMessage || null;
+        if (outputData) {
+            stepEntity.OutputData = JSON.stringify({
+                ...outputData,
+                context: {
+                    success,
+                    durationMs: stepEntity.CompletedAt.getTime() - stepEntity.StartedAt.getTime(),
+                    errorMessage
+                }
+            });
+        }
+        if (!await stepEntity.Save()) {
+            console.error('Failed to update agent run step record');
+        }
+    }
+    formatHierarchicalMessage(baseMessage) {
+        if (this._runContext && this._runContext.depth > 0) {
+            const breadcrumb = this._runContext.agentHierarchy
+                .slice(1)
+                .join(' → ');
+            return breadcrumb ? `${breadcrumb}: ${baseMessage}` : baseMessage;
+        }
+        return baseMessage;
+    }
+    async executeNextStep(params, config, previousDecision) {
+        if (!previousDecision) {
+            return await this.executePromptStep(params, config);
+        }
+        switch (previousDecision.step) {
+            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 'failed':
+                return { terminate: true, returnValue: previousDecision.returnValue };
+            default:
+                throw new Error(`Unsupported next step: ${previousDecision.step}`);
+        }
+    }
+    async executePromptStep(params, config, retryContext) {
+        const startTime = new Date();
+        const inputData = {
+            promptId: config.childPrompt?.ID,
+            promptName: config.childPrompt?.Name,
+            isRetry: !!retryContext,
+            retryContext: retryContext ? {
+                reason: retryContext.retryReason,
+                instructions: retryContext.retryInstructions
+            } : undefined,
+            conversationMessages: params.conversationMessages,
+            agentState: this._runContext?.agentState
+        };
+        const stepEntity = await this.createStepEntity('prompt', 'Execute Agent Prompt', params.contextUser, config.childPrompt?.ID, inputData);
+        try {
+            const isRetry = !!retryContext;
+            const promptMessage = isRetry
+                ? `Re-executing agent prompt with additional context from ${retryContext.retryReason || 'previous actions'}`
+                : `Executing agent's initial prompt to analyze your request`;
+            params.onProgress?.({
+                step: 'prompt_execution',
+                percentage: 30,
+                message: this.formatHierarchicalMessage(promptMessage),
+                metadata: {
+                    promptId: config.childPrompt?.ID,
+                    isRetry,
+                    promptName: config.childPrompt?.Name
+                }
+            });
+            const promptParams = await this.preparePromptParams(config.agentType, config.systemPrompt, config.childPrompt, params);
+            promptParams.cancellationToken = params.cancellationToken;
+            promptParams.onStreaming = params.onStreaming ? (chunk) => {
+                params.onStreaming({
+                    ...chunk,
+                    stepType: 'prompt',
+                    stepEntityId: stepEntity.ID
+                });
+            } : undefined;
+            const promptResult = await this.executePrompt(promptParams);
+            if (params.cancellationToken?.aborted) {
+                await this.finalizeStepEntity(stepEntity, false, 'Cancelled during prompt execution');
+                return { terminate: true, returnValue: await this.createCancelledResult('Cancelled during prompt execution', params.contextUser) };
+            }
+            const executionResult = {
+                type: 'prompt',
+                promptId: config.childPrompt.ID,
+                promptName: config.childPrompt.Name,
+                result: promptResult
+            };
+            params.onProgress?.({
+                step: 'decision_processing',
+                percentage: 70,
+                message: this.formatHierarchicalMessage('Analyzing response and determining next steps')
+            });
+            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()
+            });
+            const outputData = {
+                promptResult: {
+                    success: promptResult.success,
+                    llmResponse: promptResult.llmResponse,
+                    modelUsed: promptResult.runInfo?.modelName,
+                    tokensUsed: promptResult.runInfo?.promptRun?.TotalTokensUsed,
+                    totalCost: promptResult.runInfo?.promptRun?.TotalCost
+                },
+                nextStep: {
+                    decision: nextStep.step,
+                    reasoning: nextStepDecision.reasoning
+                }
+            };
+            await this.finalizeStepEntity(stepEntity, promptResult.success, promptResult.success ? undefined : promptResult.errorMessage, outputData);
+            if (nextStep.step === 'chat') {
+                return { terminate: true, returnValue: nextStep };
+            }
+            else if (nextStep.step === 'success' || nextStep.step === 'failed') {
+                return { terminate: true, returnValue: nextStep.returnValue };
+            }
+            else {
+                return { terminate: false, nextStep };
+            }
+        }
+        catch (error) {
+            await this.finalizeStepEntity(stepEntity, false, error.message);
+            throw error;
+        }
+    }
+    async executeSubAgentStep(params, subAgentRequest) {
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Cancelled before sub-agent execution');
+        }
+        params.onProgress?.({
+            step: 'subagent_execution',
+            percentage: 60,
+            message: this.formatHierarchicalMessage(`Delegating to ${subAgentRequest.name} agent`),
+            metadata: {
+                subAgentId: subAgentRequest.id,
+                subAgentName: subAgentRequest.name,
+                reason: subAgentRequest.message
+            }
+        });
+        params.conversationMessages.push({
+            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,
+            subAgentName: subAgentRequest.name,
+            message: subAgentRequest.message,
+            terminateAfter: subAgentRequest.terminateAfter,
+            conversationMessages: params.conversationMessages,
+            parentAgentHierarchy: this._runContext?.agentHierarchy
+        };
+        const stepEntity = await this.createStepEntity('subagent', `Execute Sub-Agent: ${subAgentRequest.name}`, params.contextUser, subAgentRequest.id, inputData);
+        try {
+            const subAgentResult = await this.ExecuteSubAgent(subAgentRequest, params.conversationMessages, params.contextUser, params.cancellationToken, params.onProgress ? (progress) => {
+                params.onProgress(progress);
+            } : undefined, params.onStreaming ? (chunk) => {
+                params.onStreaming({
+                    ...chunk,
+                    stepType: 'subagent',
+                    stepEntityId: stepEntity.ID
+                });
+            } : undefined);
+            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,
+                    agentRunId: subAgentResult.agentRun?.ID,
+                    stepCount: this.countStepsInTree(subAgentResult.executionTree)
+                },
+                shouldTerminate: shouldTerminate,
+                nextStep: nextStepDecision.decision
+            };
+            await this.finalizeStepEntity(stepEntity, subAgentResult.success, subAgentResult.errorMessage, outputData);
+            const subAgentSummary = {
+                subAgentName: subAgentRequest.name,
+                subAgentId: subAgentRequest.id,
+                success: subAgentResult.success,
+                finalStep: subAgentResult.finalStep,
+                returnValue: subAgentResult.returnValue,
+                errorMessage: subAgentResult.errorMessage || null
+            };
+            const resultMessage = subAgentResult.success
+                ? `Sub-agent completed successfully:\n${JSON.stringify(subAgentSummary, null, 2)}`
+                : `Sub-agent failed:\n${JSON.stringify(subAgentSummary, null, 2)}`;
+            params.conversationMessages.push({
+                role: 'user',
+                content: resultMessage
+            });
+            if (shouldTerminate) {
+                return { terminate: true, returnValue: subAgentResult.returnValue };
+            }
+            else {
+                return {
+                    terminate: false,
+                    nextStep: {
+                        step: 'retry',
+                        retryReason: `Analyzing results from "${subAgentRequest.name}" agent to integrate findings`
+                    }
+                };
+            }
+        }
+        catch (error) {
+            await this.finalizeStepEntity(stepEntity, false, error.message);
+            throw error;
+        }
+    }
+    async executeActionsStep(params, actions) {
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Cancelled before action execution');
+        }
+        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)
+                    .map(([key, value]) => {
+                    const displayValue = typeof value === 'object'
+                        ? JSON.stringify(value, null, 2)
+                        : String(value);
+                    return `  - \`${key}\`: ${displayValue}`;
+                })
+                    .join('\n');
+                progressMessage += `\n${paramsList}`;
+            }
+        }
+        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)
+                        .map(([key, value]) => {
+                        const displayValue = typeof value === 'object'
+                            ? JSON.stringify(value, null, 2)
+                            : String(value);
+                        return `  - \`${key}\`: ${displayValue}`;
+                    })
+                        .join('\n');
+                    progressMessage += `\n${paramsList}`;
+                }
+            });
+        }
+        params.onProgress?.({
+            step: 'action_execution',
+            percentage: 50,
+            message: this.formatHierarchicalMessage(progressMessage),
+            metadata: {
+                actionCount: actions.length,
+                actionNames: actions.map(a => a.name)
+            }
+        });
+        const actionMessage = actions.length === 1
+            ? `I'm executing the "${actions[0].name}" action...`
+            : `I'm executing ${actions.length} actions to gather the information needed:\n${actions.map(a => `• ${a.name}`).join('\n')}`;
+        params.conversationMessages.push({
+            role: 'assistant',
+            content: actionMessage
+        });
+        const actionSteps = [];
+        for (const action of actions) {
+            const startTime = new Date();
+            const stepEntity = await this.createStepEntity('action', `Execute Action: ${action.name}`, params.contextUser, action.id);
+            actionSteps.push({ action, stepEntity, startTime });
+        }
+        const actionPromises = actionSteps.map(async ({ action, stepEntity, startTime }) => {
+            try {
+                const actionResults = await this.ExecuteActions([action], params.contextUser);
+                const actionResult = actionResults[0];
+                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,
+                        resultCode: actionResult.ResultCode,
+                        message: actionResult.Message,
+                        result: actionResult.ResultType === 'ComplexObject'
+                            ? actionResult.Complex
+                            : actionResult.Simple
+                    }
+                };
+                await this.finalizeStepEntity(stepEntity, actionResult.Success, actionResult.Success ? undefined : actionResult.Message, outputData);
+                return { success: true, result: actionResult };
+            }
+            catch (error) {
+                await this.finalizeStepEntity(stepEntity, false, error.message);
+                return { success: false, error: error.message };
+            }
+        });
+        const actionResults = await Promise.all(actionPromises);
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Cancelled after action execution');
+        }
+        const actionSummaries = actionSteps.map((step, index) => {
+            const result = actionResults[index];
+            const actionResult = result.success ? result.result : null;
+            return {
+                actionName: step.action.name,
+                actionId: step.action.id,
+                params: step.action.params,
+                success: result.success,
+                resultCode: actionResult?.ResultCode || (result.success ? 'SUCCESS' : 'ERROR'),
+                message: result.success ? actionResult?.Message || 'Action completed' : result.error
+            };
+        });
+        const failedActions = actionSummaries.filter(a => !a.success);
+        const resultsMessage = failedActions.length > 0
+            ? `Action results (${failedActions.length} failed):\n${JSON.stringify(actionSummaries, null, 2)}`
+            : `Action results (all succeeded):\n${JSON.stringify(actionSummaries, null, 2)}`;
+        params.conversationMessages.push({
+            role: 'user',
+            content: resultsMessage
+        });
+        return {
+            terminate: false,
+            nextStep: {
+                step: 'retry',
+                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`
+            }
+        };
+    }
+    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()
+        });
+        await this.finalizeStepEntity(stepEntity, false, 'Chat not implemented');
+        return { terminate: true };
+    }
+    async createFailureResult(errorMessage, contextUser) {
+        if (this._agentRun) {
+            this._agentRun.Status = 'Failed';
+            this._agentRun.CompletedAt = new Date();
+            this._agentRun.Success = false;
+            this._agentRun.ErrorMessage = errorMessage;
+            await this._agentRun.Save();
+        }
+        return {
+            success: false,
+            finalStep: 'failed',
+            errorMessage,
+            agentRun: this._agentRun,
+            executionTree: this.buildExecutionTree()
+        };
+    }
+    async createCancelledResult(message, contextUser) {
+        if (this._agentRun) {
+            this._agentRun.Status = 'Cancelled';
+            this._agentRun.CompletedAt = new Date();
+            this._agentRun.Success = false;
+            this._agentRun.ErrorMessage = message;
+            await this._agentRun.Save();
+        }
+        return {
+            success: false,
+            finalStep: 'failed',
+            errorMessage: message,
+            cancelled: true,
+            cancellationReason: 'user_requested',
+            agentRun: this._agentRun,
+            executionTree: this.buildExecutionTree()
+        };
+    }
+    async finalizeAgentRun(finalStep, returnValue, 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;
+            await this._agentRun.Save();
+        }
+        return {
+            success: finalStep === 'success' || finalStep === 'chat',
+            finalStep,
+            returnValue,
+            agentRun: this._agentRun,
+            executionTree: this.buildExecutionTree()
+        };
+    }
+    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;
+    }
+    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