@memberjunction/ai-agents 2.48.0 → 2.50.0

package/dist/base-agent-original.js

@@ -1,1243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadBaseAgent = exports.BaseAgent = void 0;
-const core_1 = require("@memberjunction/core");
-const aiengine_1 = require("@memberjunction/aiengine");
-const ai_prompts_1 = require("@memberjunction/ai-prompts");
-const actions_1 = require("@memberjunction/actions");
-class BaseAgent {
-    constructor(agent, factory, contextUser, promptRunner) {
-        this._agent = agent;
-        this._factory = factory;
-        this._promptRunner = promptRunner ? promptRunner : new ai_prompts_1.AIPromptRunner();
-        this._contextUser = contextUser;
-        this._metadata = new core_1.Metadata();
-    }
-    get agent() {
-        return this._agent;
-    }
-    get factory() {
-        return this._factory;
-    }
-    get promptRunner() {
-        return this._promptRunner;
-    }
-    get contextUser() {
-        return this._contextUser;
-    }
-    async Execute(params) {
-        const startTime = new Date();
-        try {
-            const context = await this.initializeContext(params, startTime);
-            if (params.cancellationToken?.aborted) {
-                return this.createCancelledResult(startTime);
-            }
-            this.sendProgress(params.onProgress, {
-                step: 'initialization',
-                percentage: 10,
-                message: `Initializing agent '${this.agent.Name}'`,
-                metadata: { agentName: this.agent.Name, agentId: this.agent.ID }
-            });
-            await this.processContext(context);
-            if (params.cancellationToken?.aborted) {
-                return this.createCancelledResult(startTime);
-            }
-            this.sendProgress(params.onProgress, {
-                step: 'context_processing',
-                percentage: 20,
-                message: 'Processing conversation context',
-            });
-            const result = await this.executeCore(context);
-            const endTime = new Date();
-            result.executionTimeMS = endTime.getTime() - startTime.getTime();
-            this.sendProgress(params.onProgress, {
-                step: 'completion',
-                percentage: 100,
-                message: `Agent '${this.agent.Name}' execution completed`,
-                metadata: {
-                    success: result.success,
-                    executionTimeMS: result.executionTimeMS
-                }
-            });
-            return result;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error executing agent '${this.agent?.Name || 'Unknown'}': ${error.message}`);
-            const endTime = new Date();
-            return {
-                success: false,
-                errorMessage: error.message,
-                executionTimeMS: endTime.getTime() - startTime.getTime(),
-                cancelled: params.cancellationToken?.aborted || false
-            };
-        }
-    }
-    async executeCore(context) {
-        let executionStepEntity = null;
-        try {
-            executionStepEntity = await this.createExecutionStep(context, 'decision', 'Agent core execution loop', this.agent.ID, { maxIterations: 10 });
-            const decisionHistory = [];
-            const executionHistory = [];
-            const actionResults = [];
-            let currentMessages = [...context.conversationMessages];
-            let maxIterations = 10;
-            let iteration = 0;
-            while (iteration < maxIterations) {
-                iteration++;
-                context.currentStep = `decision-iteration-${iteration}`;
-                await this.updateAgentRunState(context, executionHistory, decisionHistory, actionResults);
-                if (context.params.cancellationToken?.aborted) {
-                    if (executionStepEntity) {
-                        await this.completeExecutionStep(executionStepEntity, false, null, 'Execution cancelled by user');
-                    }
-                    await this.finalizeAgentRun(context, false, 'Execution cancelled by user', null, null, null);
-                    return this.createCancelledResult(context.startTime);
-                }
-                this.sendProgress(context.params.onProgress, {
-                    step: 'subagent_coordination',
-                    percentage: 30 + (50 * iteration / maxIterations),
-                    message: `Decision-making iteration ${iteration}/${maxIterations}`,
-                    metadata: {
-                        iteration,
-                        maxIterations,
-                        runId: context.agentRun?.ID,
-                        stepNumber: context.currentStepNumber
-                    }
-                });
-                const decisionStepEntity = await this.createExecutionStep(context, 'decision', `Decision making - iteration ${iteration}`, undefined, { iteration, maxIterations, messagesCount: currentMessages.length });
-                let decision;
-                try {
-                    const decisionInput = await this.createDecisionInput(context, currentMessages, executionHistory);
-                    decision = await this.makeDecision(context, decisionInput);
-                    decisionHistory.push(decision);
-                    await this.completeExecutionStep(decisionStepEntity, true, {
-                        decision: decision.decision,
-                        reasoning: decision.reasoning,
-                        executionPlanLength: decision.executionPlan.length,
-                        confidence: decision.confidence
-                    });
-                }
-                catch (error) {
-                    await this.completeExecutionStep(decisionStepEntity, false, null, error.message);
-                    throw error;
-                }
-                if (decision.isTaskComplete || decision.decision === 'complete_task') {
-                    const completionStepEntity = await this.createExecutionStep(context, 'completion', 'Task completion', undefined, { finalResponse: decision.finalResponse });
-                    await this.completeExecutionStep(completionStepEntity, true, {
-                        taskComplete: true,
-                        finalResponse: decision.finalResponse
-                    });
-                    if (executionStepEntity) {
-                        await this.completeExecutionStep(executionStepEntity, true, {
-                            iterations: iteration,
-                            decisionCount: decisionHistory.length,
-                            taskCompleted: true
-                        });
-                    }
-                    const result = {
-                        success: true,
-                        result: decision.finalResponse || decision.reasoning,
-                        conversationMessages: currentMessages,
-                        decisionHistory,
-                        actionResults: actionResults,
-                        finalDecision: decision,
-                        metadata: {
-                            iterations: iteration,
-                            decisionCount: decisionHistory.length,
-                            actionExecutions: actionResults.length,
-                            runId: context.agentRun?.ID
-                        }
-                    };
-                    await this.finalizeAgentRun(context, true, null, result.result, decisionHistory, actionResults);
-                    return result;
-                }
-                if (decision.decision === 'request_clarification') {
-                    const clarificationStepEntity = await this.createExecutionStep(context, 'clarification', 'Requesting user clarification', undefined, { reasoning: decision.reasoning });
-                    await this.completeExecutionStep(clarificationStepEntity, true, {
-                        clarificationRequest: decision.reasoning
-                    });
-                    if (executionStepEntity) {
-                        await this.completeExecutionStep(executionStepEntity, false, null, 'Clarification needed from user');
-                    }
-                    const result = {
-                        success: false,
-                        errorMessage: decision.reasoning,
-                        conversationMessages: currentMessages,
-                        decisionHistory,
-                        metadata: {
-                            needsClarification: true,
-                            clarificationRequest: decision.reasoning,
-                            runId: context.agentRun?.ID
-                        }
-                    };
-                    await this.finalizeAgentRun(context, false, decision.reasoning, null, decisionHistory, actionResults);
-                    return result;
-                }
-                let executionResults;
-                try {
-                    executionResults = await this.executeDecidedActions(context, decision, executionHistory);
-                    executionHistory.push(...executionResults.historyItems);
-                    actionResults.push(...executionResults.actionResults);
-                    if (executionResults.newMessages.length > 0) {
-                        currentMessages.push(...executionResults.newMessages);
-                    }
-                    const executionSummary = this.createExecutionSummary(decision, executionResults);
-                    currentMessages.push({
-                        role: 'assistant',
-                        content: executionSummary
-                    });
-                }
-                catch (error) {
-                    (0, core_1.LogError)(`Error executing actions in iteration ${iteration}: ${error.message}`);
-                }
-                await this.updateAgentRunState(context, executionHistory, decisionHistory, actionResults);
-            }
-            if (executionStepEntity) {
-                await this.completeExecutionStep(executionStepEntity, false, {
-                    iterations: iteration,
-                    maxIterationsReached: true
-                }, `Reached maximum iterations (${maxIterations}) without task completion`);
-            }
-            const result = {
-                success: false,
-                errorMessage: `Agent reached maximum iterations (${maxIterations}) without completing the task`,
-                conversationMessages: currentMessages,
-                decisionHistory,
-                actionResults: actionResults,
-                metadata: {
-                    maxIterationsReached: true,
-                    iterations: iteration,
-                    decisionCount: decisionHistory.length,
-                    runId: context.agentRun?.ID
-                }
-            };
-            await this.finalizeAgentRun(context, false, result.errorMessage, null, decisionHistory, actionResults);
-            return result;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error in executeCore for agent '${this.agent.Name}': ${error.message}`);
-            if (executionStepEntity) {
-                await this.completeExecutionStep(executionStepEntity, false, null, error.message);
-            }
-            const result = {
-                success: false,
-                errorMessage: error.message,
-                metadata: {
-                    errorStep: 'executeCore',
-                    agentName: this.agent.Name,
-                    runId: context.agentRun?.ID
-                }
-            };
-            await this.finalizeAgentRun(context, false, error.message, null, [], []);
-            return result;
-        }
-    }
-    async initializeContext(params, startTime) {
-        const agentRun = await this._metadata.GetEntityObject('MJ: AI Agent Runs', this.contextUser);
-        agentRun.NewRecord();
-        agentRun.AgentID = this.agent.ID;
-        agentRun.Status = 'Running';
-        agentRun.StartedAt = startTime;
-        if (params.contextUser) {
-            agentRun.UserID = params.contextUser.ID;
-        }
-        const conversationId = params.data?.conversationId ||
-            params.data?.conversationID;
-        if (conversationId) {
-            agentRun.ConversationID = conversationId;
-        }
-        const parentRunId = params.data?.parentRunId ||
-            params.data?.parentRunID;
-        if (parentRunId) {
-            agentRun.ParentRunID = parentRunId;
-        }
-        const saveResult = await agentRun.Save();
-        if (!saveResult) {
-            throw new Error('Failed to create agent run record in database');
-        }
-        const initialState = {
-            conversationMessages: params.conversationMessages || [],
-            executionHistory: [],
-            decisionHistory: [],
-            actionResults: [],
-            currentStep: 'initialization',
-            currentStepNumber: 1,
-            contextData: params.data || {},
-            agentConfiguration: {},
-            serializedAt: new Date(),
-            version: '1.0'
-        };
-        agentRun.AgentState = JSON.stringify(initialState);
-        await agentRun.Save();
-        return {
-            conversationMessages: params.conversationMessages || [],
-            params,
-            data: params.data || {},
-            currentStep: 'initialization',
-            startTime,
-            agentRun,
-            currentStepNumber: 1
-        };
-    }
-    async processContext(context) {
-        if (this.agent.EnableContextCompression &&
-            this.agent.ContextCompressionMessageThreshold &&
-            context.conversationMessages.length > this.agent.ContextCompressionMessageThreshold) {
-            await this.compressContext(context);
-        }
-    }
-    async compressContext(context) {
-        try {
-            if (!this.agent.ContextCompressionPromptID) {
-                (0, core_1.LogStatus)(`Context compression enabled but no compression prompt configured for agent '${this.agent.Name}'`);
-                return;
-            }
-            const retentionCount = this.agent.ContextCompressionMessageRetentionCount || 5;
-            const messagesToCompress = context.conversationMessages.slice(0, -retentionCount);
-            const messagesToKeep = context.conversationMessages.slice(-retentionCount);
-            if (messagesToCompress.length === 0) {
-                return;
-            }
-            const compressionPrompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.ID === this.agent.ContextCompressionPromptID);
-            if (!compressionPrompt) {
-                (0, core_1.LogError)(`Compression prompt not found: ${this.agent.ContextCompressionPromptID}`);
-                return;
-            }
-            const compressionParams = {
-                prompt: compressionPrompt,
-                data: {
-                    messages: messagesToCompress,
-                    messageCount: messagesToCompress.length
-                },
-                contextUser: context.params.contextUser,
-                agentRunId: context.agentRun?.ID
-            };
-            const compressionResult = await this.promptRunner.ExecutePrompt(compressionParams);
-            if (compressionResult.success && compressionResult.rawResult) {
-                const summaryMessage = {
-                    role: 'system',
-                    content: `[Conversation Summary] ${compressionResult.rawResult}`
-                };
-                context.conversationMessages = [summaryMessage, ...messagesToKeep];
-                (0, core_1.LogStatus)(`Compressed ${messagesToCompress.length} messages into summary for agent '${this.agent.Name}'`);
-            }
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error compressing context for agent '${this.agent.Name}': ${error.message}`);
-        }
-    }
-    async loadAgentPrompts() {
-        try {
-            await aiengine_1.AIEngine.Instance.Config(false, this.contextUser);
-            const agentPrompts = aiengine_1.AIEngine.Instance.AgentPrompts
-                .filter(ap => ap.AgentID === this.agent.ID && ap.Status === 'Active')
-                .sort((a, b) => (a.ExecutionOrder || 0) - (b.ExecutionOrder || 0));
-            const results = [];
-            for (const agentPrompt of agentPrompts) {
-                const prompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.ID === agentPrompt.PromptID);
-                if (prompt && prompt.Status === 'Active') {
-                    results.push(prompt);
-                }
-            }
-            if (results.length === 0) {
-                const agentType = await this.loadAgentType();
-                if (agentType && agentType.SystemPromptID) {
-                    const systemPrompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.ID === agentType.SystemPromptID);
-                    if (systemPrompt && systemPrompt.Status === 'Active') {
-                        results.push(systemPrompt);
-                    }
-                    else {
-                        (0, core_1.LogStatus)(`System prompt not found or inactive for agent type '${agentType.Name}'`);
-                    }
-                }
-                else {
-                    (0, core_1.LogStatus)(`No active prompts found for agent '${this.agent.Name}' and no system prompt configured`);
-                }
-            }
-            return results;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error loading agent prompts for '${this.agent.Name}': ${error.message}`);
-            return [];
-        }
-    }
-    async loadAgentType() {
-        try {
-            if (!this.agent.TypeID) {
-                (0, core_1.LogStatus)(`Agent '${this.agent.Name}' has no AgentTypeID defined`);
-                return null;
-            }
-            await aiengine_1.AIEngine.Instance.Config(false, this.contextUser);
-            const agentType = aiengine_1.AIEngine.Instance.AgentTypes.find(at => at.ID === this.agent.TypeID);
-            if (!agentType) {
-                (0, core_1.LogError)(`Agent type not found for ID: ${this.agent.TypeID}`);
-                return null;
-            }
-            return agentType;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error loading agent type for '${this.agent.Name}': ${error.message}`);
-            return null;
-        }
-    }
-    async loadChildAgents() {
-        try {
-            const childAgents = aiengine_1.AIEngine.Instance.Agents
-                .filter(a => a.ParentID === this.agent.ID)
-                .sort((a, b) => (a.ExecutionOrder || 0) - (b.ExecutionOrder || 0));
-            return childAgents;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error loading child agents for '${this.agent.Name}': ${error.message}`);
-            return [];
-        }
-    }
-    sendProgress(callback, progress) {
-        if (callback) {
-            try {
-                callback(progress);
-            }
-            catch (error) {
-                (0, core_1.LogError)(`Error in progress callback: ${error.message}`);
-            }
-        }
-    }
-    async createExecutionStep(context, stepType, stepName, targetId, inputData) {
-        try {
-            if (!context.agentRun) {
-                throw new Error('Agent run record not found in context');
-            }
-            const stepEntity = await this._metadata.GetEntityObject('MJ: AI Agent Run Steps', this.contextUser);
-            stepEntity.NewRecord();
-            stepEntity.AgentRunID = context.agentRun.ID;
-            stepEntity.StepNumber = context.currentStepNumber;
-            stepEntity.StepType = stepType;
-            stepEntity.StepName = stepName;
-            stepEntity.Status = 'Running';
-            stepEntity.StartedAt = new Date();
-            if (targetId) {
-                stepEntity.TargetID = targetId;
-            }
-            if (inputData) {
-                stepEntity.InputData = JSON.stringify(inputData);
-            }
-            const saveResult = await stepEntity.Save();
-            if (!saveResult) {
-                throw new Error(`Failed to create execution step: ${stepName}`);
-            }
-            context.currentStepNumber++;
-            return stepEntity;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error creating execution step '${stepName}': ${error.message}`);
-            throw error;
-        }
-    }
-    async completeExecutionStep(stepEntity, success, outputData, errorMessage) {
-        try {
-            stepEntity.Status = success ? 'Completed' : 'Failed';
-            stepEntity.Success = success;
-            stepEntity.CompletedAt = new Date();
-            if (outputData) {
-                stepEntity.OutputData = JSON.stringify(outputData);
-            }
-            if (errorMessage) {
-                stepEntity.ErrorMessage = errorMessage;
-            }
-            await stepEntity.Save();
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error completing execution step: ${error.message}`);
-        }
-    }
-    serializeAgentState(context, executionHistory, decisionHistory, actionResults) {
-        return {
-            conversationMessages: context.conversationMessages,
-            executionHistory,
-            decisionHistory,
-            actionResults,
-            currentStep: context.currentStep,
-            currentStepNumber: context.currentStepNumber,
-            contextData: context.data,
-            agentConfiguration: context.configuration || {},
-            serializedAt: new Date(),
-            version: '1.0'
-        };
-    }
-    deserializeAgentState(serializedState, context) {
-        context.conversationMessages = serializedState.conversationMessages;
-        context.currentStep = serializedState.currentStep;
-        context.currentStepNumber = serializedState.currentStepNumber;
-        context.data = { ...context.data, ...serializedState.contextData };
-        context.configuration = { ...context.configuration, ...serializedState.agentConfiguration };
-        return {
-            executionHistory: serializedState.executionHistory,
-            decisionHistory: serializedState.decisionHistory,
-            actionResults: serializedState.actionResults
-        };
-    }
-    async updateAgentRunState(context, executionHistory, decisionHistory, actionResults) {
-        try {
-            if (!context.agentRun) {
-                return;
-            }
-            const serializedState = this.serializeAgentState(context, executionHistory, decisionHistory, actionResults);
-            context.agentRun.AgentState = JSON.stringify(serializedState);
-            await context.agentRun.Save();
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error updating agent run state: ${error.message}`);
-        }
-    }
-    async finalizeAgentRun(context, success, errorMessage, finalResult, decisionHistory, actionResults) {
-        try {
-            if (!context.agentRun) {
-                return;
-            }
-            context.agentRun.Status = success ? 'Completed' : 'Failed';
-            context.agentRun.Success = success;
-            context.agentRun.CompletedAt = new Date();
-            if (errorMessage) {
-                context.agentRun.ErrorMessage = errorMessage;
-            }
-            if (finalResult) {
-                context.agentRun.Result = typeof finalResult === 'string' ? finalResult : JSON.stringify(finalResult);
-            }
-            if (actionResults && actionResults.length > 0) {
-                let totalTokens = 0;
-                let totalCost = 0;
-                for (const actionResult of actionResults) {
-                    if (actionResult.Params) {
-                        for (const param of actionResult.Params) {
-                            if (param.Name === 'tokensUsed' && typeof param.Value === 'number') {
-                                totalTokens += param.Value;
-                            }
-                            if (param.Name === 'cost' && typeof param.Value === 'number') {
-                                totalCost += param.Value;
-                            }
-                        }
-                    }
-                }
-                if (totalTokens > 0) {
-                    context.agentRun.TotalTokensUsed = totalTokens;
-                }
-                if (totalCost > 0) {
-                    context.agentRun.TotalCost = totalCost;
-                }
-            }
-            if (decisionHistory && actionResults) {
-                const finalState = this.serializeAgentState(context, [], decisionHistory, actionResults);
-                context.agentRun.AgentState = JSON.stringify(finalState);
-            }
-            await context.agentRun.Save();
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error finalizing agent run: ${error.message}`);
-        }
-    }
-    async createDecisionInput(context, currentMessages, executionHistory) {
-        const availableActions = await this.getAvailableActionDescriptions();
-        const availableSubAgents = await this.getAvailableSubAgentDescriptions();
-        const currentGoal = context.data.goal ||
-            context.data.task ||
-            this.agent.Description ||
-            'Complete the requested task';
-        return {
-            messages: currentMessages,
-            availableActions,
-            availableSubAgents,
-            currentGoal,
-            executionHistory,
-            contextData: context.data
-        };
-    }
-    async makeDecision(context, decisionInput) {
-        try {
-            const prompts = await this.loadAgentPrompts();
-            const agentType = await this.loadAgentType();
-            if (prompts.length === 0) {
-                throw new Error(`No prompts found for agent ${this.agent.Name}`);
-            }
-            const primaryprompt = prompts[0];
-            const contextualPrompt = this.buildContextualDecisionPrompt(decisionInput);
-            const promptData = {
-                agentName: this.agent.Name,
-                agentDescription: this.agent.Description,
-                availableActions: decisionInput.availableActions,
-                availableSubAgents: decisionInput.availableSubAgents,
-                currentGoal: decisionInput.currentGoal,
-                executionHistory: decisionInput.executionHistory,
-                contextData: decisionInput.contextData
-            };
-            const conversationMessages = [
-                ...decisionInput.messages,
-                {
-                    role: 'user',
-                    content: contextualPrompt
-                }
-            ];
-            const promptParams = new ai_prompts_1.AIPromptParams();
-            if (agentType && agentType.SystemPromptID && agentType.SystemPromptID !== primaryprompt.ID) {
-                const systemPrompt = prompts.find(p => p.ID === agentType.SystemPromptID);
-                if (systemPrompt) {
-                    const childPromptParams = new ai_prompts_1.AIPromptParams();
-                    childPromptParams.prompt = primaryprompt;
-                    childPromptParams.data = promptData;
-                    childPromptParams.contextUser = context.params.contextUser;
-                    const childPrompt = new ai_prompts_1.ChildPromptParam(childPromptParams, 'agentPrompt');
-                    promptParams.prompt = systemPrompt;
-                    promptParams.childPrompts = [childPrompt];
-                    promptParams.data = promptData;
-                }
-                else {
-                    promptParams.prompt = primaryprompt;
-                    promptParams.data = promptData;
-                }
-            }
-            else {
-                promptParams.prompt = primaryprompt;
-                promptParams.data = promptData;
-            }
-            promptParams.conversationMessages = conversationMessages;
-            promptParams.templateMessageRole = 'system';
-            promptParams.contextUser = context.params.contextUser;
-            promptParams.agentRunId = context.agentRun.ID;
-            const promptResult = await this._promptRunner.ExecutePrompt(promptParams);
-            if (!promptResult.success) {
-                throw new Error(`AI prompt execution failed: ${promptResult.errorMessage}`);
-            }
-            const decision = await this.parseAndValidateDecision(promptResult.rawResult || '');
-            return decision;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error making decision: ${error.message}`);
-            return {
-                decision: 'request_clarification',
-                reasoning: `Error occurred while making decision: ${error.message}`,
-                executionPlan: [],
-                isTaskComplete: false,
-                confidence: 0.1
-            };
-        }
-    }
-    buildContextualDecisionPrompt(decisionInput) {
-        const executionSummary = decisionInput.executionHistory.length > 0
-            ? this.summarizeExecutionHistory(decisionInput.executionHistory)
-            : 'No previous actions taken.';
-        const actionDetails = decisionInput.availableActions.length > 0
-            ? this.formatActionsForDecision(decisionInput.availableActions)
-            : '';
-        const subAgentDetails = decisionInput.availableSubAgents.length > 0
-            ? this.formatSubAgentsForDecision(decisionInput.availableSubAgents)
-            : '';
-        return `## Current Situation Analysis
-
-**Primary Goal:** ${decisionInput.currentGoal}
-
-**Conversation Context:** ${decisionInput.messages.length} messages in conversation
-**Previous Actions:** ${executionSummary}
-**Available Actions:** ${decisionInput.availableActions.length} actions
-**Available Sub-Agents:** ${decisionInput.availableSubAgents.length} sub-agents${actionDetails}${subAgentDetails}
-
-## Decision Request
-
-Based on your specialized instructions, the current context, and available resources, what should you do next to achieve the goal: "${decisionInput.currentGoal}"?
-
-Consider:
-1. Have you fully understood what the user is asking for?
-2. Do you have all the information needed to proceed?
-3. Which approach would be most effective and efficient?
-4. Should any actions be performed in parallel?
-5. Are you ready to provide a final response?
-
-**Respond with a JSON object following the specified structure.**`;
-    }
-    formatActionsForDecision(actions) {
-        if (actions.length === 0)
-            return '';
-        let section = '\n## Available Actions Details\n';
-        for (const action of actions.slice(0, 5)) {
-            section += `**${action.name}** (${action.id}): ${action.description}\n`;
-            if (action.metadata) {
-                if (action.metadata.estimatedDuration) {
-                    section += `  - Duration: ~${action.metadata.estimatedDuration}ms\n`;
-                }
-                if (action.metadata.reliability) {
-                    section += `  - Reliability: ${(action.metadata.reliability * 100).toFixed(0)}%\n`;
-                }
-                if (action.metadata.costLevel) {
-                    section += `  - Cost level: ${action.metadata.costLevel}\n`;
-                }
-            }
-        }
-        if (actions.length > 5) {
-            section += `... and ${actions.length - 5} more actions available\n`;
-        }
-        return section;
-    }
-    formatSubAgentsForDecision(subAgents) {
-        if (subAgents.length === 0)
-            return '';
-        let section = '\n## Available Sub-Agents Details\n';
-        const sortedAgents = [...subAgents].sort((a, b) => (a.executionOrder || 0) - (b.executionOrder || 0));
-        for (const agent of sortedAgents.slice(0, 5)) {
-            section += `**${agent.name}** (${agent.id}): ${agent.description}\n`;
-            section += `  - Suggested execution order: ${agent.executionOrder || 0}\n`;
-            section += `  - Supports parallel execution: ${agent.supportsParallel}\n`;
-            if (agent.metadata) {
-                if (agent.metadata.availabilityStatus) {
-                    section += `  - Status: ${agent.metadata.availabilityStatus}\n`;
-                }
-                if (agent.metadata.executionContext) {
-                    section += `  - Context: ${agent.metadata.executionContext}\n`;
-                }
-            }
-            section += '\n';
-        }
-        if (subAgents.length > 5) {
-            section += `... and ${subAgents.length - 5} more sub-agents available\n`;
-        }
-        section += '\n**Note**: Execution order values are suggestions. You have complete autonomy to choose any sequence that best achieves the goal.\n';
-        return section;
-    }
-    summarizeExecutionHistory(history) {
-        if (history.length === 0)
-            return 'None';
-        const successful = history.filter(h => h.success).length;
-        const failed = history.filter(h => !h.success).length;
-        const recent = history.slice(-3).map(h => `${h.type}:${h.targetId}(${h.success ? 'success' : 'failed'})`).join(', ');
-        return `${history.length} total actions (${successful} successful, ${failed} failed). Recent: ${recent}`;
-    }
-    async parseAndValidateDecision(llmResponse) {
-        try {
-            const jsonMatch = llmResponse.match(/```json\s*([\s\S]*?)\s*```/) ||
-                llmResponse.match(/\{[\s\S]*\}/);
-            const jsonString = jsonMatch ? (jsonMatch[1] || jsonMatch[0]) : llmResponse;
-            let decision;
-            try {
-                decision = JSON.parse(jsonString.trim());
-            }
-            catch (parseError) {
-                (0, core_1.LogError)(`Failed to parse LLM decision response: ${parseError.message}`);
-                return this.createFallbackDecision(llmResponse);
-            }
-            return this.validateAndNormalizeDecision(decision);
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error parsing decision: ${error.message}`);
-            return this.createFallbackDecision(llmResponse);
-        }
-    }
-    createFallbackDecision(llmResponse) {
-        const response = llmResponse.toLowerCase();
-        if (response.includes('complete') || response.includes('finished') || response.includes('done')) {
-            return {
-                decision: 'complete_task',
-                reasoning: `Task appears to be complete based on response: ${llmResponse}`,
-                executionPlan: [],
-                isTaskComplete: true,
-                finalResponse: llmResponse,
-                confidence: 0.3
-            };
-        }
-        if (response.includes('need') || response.includes('require') || response.includes('clarify')) {
-            return {
-                decision: 'request_clarification',
-                reasoning: `Clarification needed based on response: ${llmResponse}`,
-                executionPlan: [],
-                isTaskComplete: false,
-                confidence: 0.4
-            };
-        }
-        return {
-            decision: 'request_clarification',
-            reasoning: `Unable to parse LLM response format. Raw response: ${llmResponse}`,
-            executionPlan: [],
-            isTaskComplete: false,
-            confidence: 0.1
-        };
-    }
-    async executeDecidedActions(context, decision, executionHistory) {
-        const historyItems = [];
-        const actionResults = [];
-        const newMessages = [];
-        if (!decision.executionPlan || decision.executionPlan.length === 0) {
-            return { historyItems, actionResults, newMessages };
-        }
-        const executionGroups = this.groupExecutionStepsByOrder(decision.executionPlan);
-        for (const [order, steps] of executionGroups) {
-            this.sendProgress(context.params.onProgress, {
-                step: 'subagent_coordination',
-                percentage: 40 + (40 * order / executionGroups.size),
-                message: `Executing steps at order ${order}`,
-                metadata: {
-                    executionOrder: order,
-                    stepCount: steps.length,
-                    stepTypes: steps.map(s => s.type)
-                }
-            });
-            const hasSequentialSteps = steps.some(step => step.allowParallel === false);
-            if (hasSequentialSteps) {
-                const sequentialResults = await this.executeStepsSequentially(context, steps, executionHistory);
-                historyItems.push(...sequentialResults.historyItems);
-                actionResults.push(...sequentialResults.actionResults);
-                newMessages.push(...sequentialResults.newMessages);
-            }
-            else {
-                const parallelResults = await this.executeStepsInParallel(context, steps, executionHistory);
-                historyItems.push(...parallelResults.historyItems);
-                actionResults.push(...parallelResults.actionResults);
-                newMessages.push(...parallelResults.newMessages);
-            }
-            if (steps.length > 0) {
-                const successCount = historyItems.filter(h => h.success).length;
-                const orderSummary = `Completed execution order ${order}: ${successCount}/${steps.length} steps successful`;
-                newMessages.push({
-                    role: 'assistant',
-                    content: orderSummary
-                });
-            }
-        }
-        return { historyItems, actionResults, newMessages };
-    }
-    groupExecutionStepsByOrder(executionPlan) {
-        const groups = new Map();
-        for (const step of executionPlan) {
-            const order = step.executionOrder || 1;
-            if (!groups.has(order)) {
-                groups.set(order, []);
-            }
-            groups.get(order).push(step);
-        }
-        return new Map([...groups.entries()].sort(([a], [b]) => a - b));
-    }
-    async executeStepsInParallel(context, steps, executionHistory) {
-        const promises = steps.map(step => this.executeSingleStep(context, step, executionHistory));
-        const results = await Promise.allSettled(promises);
-        const historyItems = [];
-        const actionResults = [];
-        const newMessages = [];
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            const step = steps[i];
-            if (result.status === 'fulfilled') {
-                historyItems.push(result.value.historyItem);
-                if (result.value.actionResult) {
-                    actionResults.push(result.value.actionResult);
-                }
-                if (result.value.newMessage) {
-                    newMessages.push(result.value.newMessage);
-                }
-            }
-            else {
-                historyItems.push({
-                    type: step.type,
-                    targetId: step.targetId,
-                    parameters: step.parameters,
-                    result: null,
-                    success: false,
-                    errorMessage: result.reason?.message || 'Parallel execution failed',
-                    timestamp: new Date()
-                });
-            }
-        }
-        return { historyItems, actionResults, newMessages };
-    }
-    async executeStepsSequentially(context, steps, executionHistory) {
-        const historyItems = [];
-        const actionResults = [];
-        const newMessages = [];
-        for (const step of steps) {
-            try {
-                const result = await this.executeSingleStep(context, step, executionHistory);
-                historyItems.push(result.historyItem);
-                if (result.actionResult) {
-                    actionResults.push(result.actionResult);
-                }
-                if (result.newMessage) {
-                    newMessages.push(result.newMessage);
-                }
-            }
-            catch (error) {
-                historyItems.push({
-                    type: step.type,
-                    targetId: step.targetId,
-                    parameters: step.parameters,
-                    result: null,
-                    success: false,
-                    errorMessage: error.message,
-                    timestamp: new Date()
-                });
-            }
-        }
-        return { historyItems, actionResults, newMessages };
-    }
-    async executeSingleStep(context, step, executionHistory) {
-        const timestamp = new Date();
-        const stepEntity = await this.createExecutionStep(context, step.type, step.description || `Execute ${step.type} '${step.targetId}'`, step.targetId, step.parameters);
-        try {
-            if (step.type === 'action') {
-                const actionResult = await this.executeAction(step.targetId, step.parameters || {});
-                const statusMessage = step.description
-                    ? `${step.description} - ${actionResult.Success ? 'Completed' : 'Failed'}`
-                    : `Executed action '${step.targetId}': ${actionResult.Success ? 'Success' : actionResult.Message}`;
-                await this.completeExecutionStep(stepEntity, actionResult.Success, {
-                    actionResult: {
-                        success: actionResult.Success,
-                        message: actionResult.Message,
-                        paramsCount: actionResult.Params?.length || 0
-                    }
-                }, actionResult.Success ? undefined : actionResult.Message);
-                return {
-                    historyItem: {
-                        type: 'action',
-                        targetId: step.targetId,
-                        parameters: step.parameters,
-                        result: actionResult,
-                        success: actionResult.Success,
-                        errorMessage: actionResult.Success ? undefined : actionResult.Message,
-                        timestamp
-                    },
-                    actionResult,
-                    newMessage: {
-                        role: 'assistant',
-                        content: statusMessage
-                    }
-                };
-            }
-            else if (step.type === 'subagent') {
-                const subagentResult = await this.executeSubAgent(step.targetId, step.parameters || {}, context);
-                const statusMessage = step.description
-                    ? `${step.description} - ${subagentResult.success ? 'Completed' : 'Failed'}`
-                    : `Executed subagent '${step.targetId}': ${subagentResult.success ? 'Success' : subagentResult.errorMessage}`;
-                await this.completeExecutionStep(stepEntity, subagentResult.success, {
-                    subagentResult: {
-                        success: subagentResult.success,
-                        executionTimeMS: subagentResult.executionTimeMS,
-                        resultLength: subagentResult.result ? JSON.stringify(subagentResult.result).length : 0
-                    }
-                }, subagentResult.success ? undefined : subagentResult.errorMessage);
-                return {
-                    historyItem: {
-                        type: 'subagent',
-                        targetId: step.targetId,
-                        parameters: step.parameters,
-                        result: subagentResult,
-                        success: subagentResult.success,
-                        errorMessage: subagentResult.success ? undefined : subagentResult.errorMessage,
-                        timestamp
-                    },
-                    newMessage: {
-                        role: 'assistant',
-                        content: statusMessage
-                    }
-                };
-            }
-            else {
-                const errorMessage = `Unknown execution step type: ${step.type}`;
-                await this.completeExecutionStep(stepEntity, false, null, errorMessage);
-                throw new Error(errorMessage);
-            }
-        }
-        catch (error) {
-            await this.completeExecutionStep(stepEntity, false, null, error.message);
-            return {
-                historyItem: {
-                    type: step.type,
-                    targetId: step.targetId,
-                    parameters: step.parameters,
-                    result: null,
-                    success: false,
-                    errorMessage: error.message,
-                    timestamp
-                }
-            };
-        }
-    }
-    async getAvailableActionDescriptions() {
-        try {
-            const agentActions = aiengine_1.AIEngine.Instance.AgentActions
-                .filter(aa => aa.AgentID === this.agent.ID && aa.Status === 'Active');
-            const actions = [];
-            await actions_1.ActionEngineServer.Instance.Config(false, this.contextUser);
-            for (const agentAction of agentActions) {
-                const action = actions_1.ActionEngineServer.Instance.Actions.find(a => a.ID === agentAction.ActionID);
-                if (action && action.Status === 'Active') {
-                    actions.push({
-                        id: action.ID,
-                        name: action.Name,
-                        description: action.Description || '',
-                        parameters: action.Params?.map(p => ({
-                            name: p.Name,
-                            type: p.Type,
-                            description: p.Description || '',
-                            required: p.IsRequired || false,
-                            defaultValue: p.DefaultValue
-                        })) || [],
-                        supportsParallel: true
-                    });
-                }
-            }
-            return actions;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error loading available actions: ${error.message}`);
-            return [];
-        }
-    }
-    async getAvailableSubAgentDescriptions() {
-        try {
-            const childAgents = await this.loadChildAgents();
-            return childAgents.map(agent => ({
-                id: agent.ID,
-                name: agent.Name,
-                description: agent.Description || '',
-                supportsParallel: agent.ExecutionMode === 'Parallel',
-                executionOrder: agent.ExecutionOrder || 0,
-                metadata: {
-                    executionContext: `Default execution order: ${agent.ExecutionOrder || 0}. Mode: ${agent.ExecutionMode || 'Sequential'}`,
-                    availabilityStatus: 'available'
-                }
-            }));
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error loading available sub-agents: ${error.message}`);
-            return [];
-        }
-    }
-    async executeAction(actionId, parameters) {
-        try {
-            const actionParams = Object.entries(parameters).map(([name, value]) => ({
-                Name: name,
-                Value: value,
-                Type: 'Input'
-            }));
-            return await actions_1.ActionEngineServer.Instance.RunActionByID({
-                ActionID: actionId,
-                ContextUser: this.contextUser,
-                Params: actionParams,
-                SkipActionLog: false
-            });
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error executing action '${actionId}': ${error.message}`);
-            return {
-                Success: false,
-                Message: error.message,
-                LogEntry: null,
-                Params: [],
-                RunParams: null
-            };
-        }
-    }
-    async executeSubAgent(subAgentId, parameters, parentContext) {
-        try {
-            const subAgentEntity = aiengine_1.AIEngine.Instance.Agents.find(a => a.ID === subAgentId);
-            if (!subAgentEntity) {
-                throw new Error(`Sub-agent with ID '${subAgentId}' not found`);
-            }
-            const subAgent = this.factory.CreateAgentFromEntity(subAgentEntity, null, this._contextUser);
-            const subAgentParams = {
-                contextUser: parentContext.params.contextUser,
-                data: {
-                    ...parentContext.data,
-                    ...parameters,
-                    parentRunId: parentContext.agentRun?.ID,
-                    parentRunID: parentContext.agentRun?.ID
-                },
-                conversationMessages: [...parentContext.conversationMessages],
-                cancellationToken: parentContext.params.cancellationToken,
-                onProgress: parentContext.params.onProgress,
-                onStreaming: parentContext.params.onStreaming
-            };
-            return await subAgent.Execute(subAgentParams);
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error executing sub-agent '${subAgentId}': ${error.message}`);
-            return {
-                success: false,
-                errorMessage: error.message
-            };
-        }
-    }
-    validateAndNormalizeDecision(decision) {
-        let executionPlan = [];
-        if (decision.executionPlan && Array.isArray(decision.executionPlan)) {
-            executionPlan = decision.executionPlan.map((step, index) => ({
-                type: step.type || 'action',
-                targetId: step.targetId || '',
-                parameters: step.parameters || {},
-                executionOrder: step.executionOrder || (index + 1),
-                allowParallel: step.allowParallel !== false,
-                description: step.description || `Step ${index + 1}: ${step.type} ${step.targetId}`
-            }));
-        }
-        return {
-            decision: decision.decision || 'request_clarification',
-            reasoning: decision.reasoning || 'No reasoning provided',
-            executionPlan,
-            isTaskComplete: decision.isTaskComplete || false,
-            finalResponse: decision.finalResponse,
-            confidence: typeof decision.confidence === 'number' ? decision.confidence : 0.5,
-            metadata: decision.metadata
-        };
-    }
-    createExecutionSummary(decision, executionResults) {
-        const { historyItems } = executionResults;
-        const successful = historyItems.filter(h => h.success);
-        const failed = historyItems.filter(h => !h.success);
-        const parts = [
-            `Executed ${decision.executionPlan.length} steps: ${decision.reasoning}`
-        ];
-        if (successful.length) {
-            parts.push(`✅ Success: ${successful.map(h => h.targetId).join(', ')}`);
-        }
-        if (failed.length) {
-            parts.push(`❌ Failed: ${failed.map(h => h.targetId).join(', ')}`);
-        }
-        return parts.join('\n');
-    }
-    createCancelledResult(startTime) {
-        const endTime = new Date();
-        return {
-            success: false,
-            cancelled: true,
-            errorMessage: 'Agent execution was cancelled',
-            executionTimeMS: endTime.getTime() - startTime.getTime()
-        };
-    }
-    async getRunHistory(agentRunId) {
-        try {
-            const agentRun = await this._metadata.GetEntityObject('MJ: AI Agent Runs', this.contextUser);
-            const loadSuccess = await agentRun.Load(agentRunId);
-            if (!loadSuccess) {
-                return null;
-            }
-            const runView = new core_1.RunView();
-            const stepsResult = await runView.RunView({
-                EntityName: 'MJ: AI Agent Run Steps',
-                ExtraFilter: `AgentRunID = '${agentRunId}'`,
-                OrderBy: 'StepNumber ASC',
-                ResultType: 'entity_object'
-            }, this.contextUser);
-            return {
-                agentRun,
-                steps: stepsResult.Results
-            };
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error retrieving run history for '${agentRunId}': ${error.message}`);
-            return null;
-        }
-    }
-    async pauseExecution(context, reason = 'Execution paused by user') {
-        try {
-            if (!context.agentRun) {
-                throw new Error('No active agent run to pause');
-            }
-            context.agentRun.Status = 'Paused';
-            context.agentRun.ErrorMessage = reason;
-            await this.updateAgentRunState(context, [], [], []);
-            await context.agentRun.Save();
-            (0, core_1.LogStatus)(`Agent run '${context.agentRun.ID}' paused: ${reason}`);
-            return context.agentRun.ID;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error pausing execution: ${error.message}`);
-            return null;
-        }
-    }
-    async resumeExecution(agentRunId, contextUser) {
-        try {
-            const agentRun = await this._metadata.GetEntityObject('MJ: AI Agent Runs', this.contextUser);
-            const loadSuccess = await agentRun.Load(agentRunId);
-            if (!loadSuccess) {
-                throw new Error(`Agent run '${agentRunId}' not found`);
-            }
-            if (agentRun.Status !== 'Paused') {
-                throw new Error(`Agent run '${agentRunId}' is not in paused state (current status: ${agentRun.Status})`);
-            }
-            const agentEntity = aiengine_1.AIEngine.Instance.Agents.find(a => a.ID === agentRun.AgentID);
-            if (!agentEntity) {
-                throw new Error(`Agent entity not found for run '${agentRunId}'`);
-            }
-            let serializedState;
-            try {
-                serializedState = JSON.parse(agentRun.AgentState || '{}');
-            }
-            catch (error) {
-                throw new Error(`Failed to parse saved agent state: ${error.message}`);
-            }
-            const resumedContext = {
-                conversationMessages: serializedState.conversationMessages || [],
-                params: {
-                    contextUser,
-                    data: serializedState.contextData || {},
-                    conversationMessages: serializedState.conversationMessages || []
-                },
-                data: serializedState.contextData || {},
-                configuration: serializedState.agentConfiguration || {},
-                currentStep: serializedState.currentStep || 'resumed',
-                startTime: agentRun.StartedAt,
-                agentRun,
-                currentStepNumber: serializedState.currentStepNumber || 1
-            };
-            agentRun.Status = 'Running';
-            agentRun.ErrorMessage = null;
-            await agentRun.Save();
-            const { executionHistory, decisionHistory, actionResults } = this.deserializeAgentState(serializedState, resumedContext);
-            (0, core_1.LogStatus)(`Resuming agent run '${agentRunId}' from step: ${resumedContext.currentStep}`);
-            return await this.executeCore(resumedContext);
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error resuming execution for '${agentRunId}': ${error.message}`);
-            return {
-                success: false,
-                errorMessage: error.message,
-                metadata: {
-                    errorStep: 'resumeExecution',
-                    runId: agentRunId
-                }
-            };
-        }
-    }
-    async cleanupFailedRuns(maxAgeHours = 24) {
-        try {
-            const cutoffTime = new Date();
-            cutoffTime.setHours(cutoffTime.getHours() - maxAgeHours);
-            const runView = new core_1.RunView();
-            const staleRunsResult = await runView.RunView({
-                EntityName: 'MJ: AI Agent Runs',
-                ExtraFilter: `Status = 'Running' AND StartedAt < '${cutoffTime.toISOString()}'`,
-                ResultType: 'entity_object'
-            }, this.contextUser);
-            const staleRuns = staleRunsResult.Results;
-            let cleanedCount = 0;
-            for (const run of staleRuns) {
-                try {
-                    run.Status = 'Failed';
-                    run.Success = false;
-                    run.CompletedAt = new Date();
-                    run.ErrorMessage = `Run marked as failed due to cleanup - exceeded maximum age of ${maxAgeHours} hours`;
-                    await run.Save();
-                    cleanedCount++;
-                    (0, core_1.LogStatus)(`Cleaned up stale agent run: ${run.ID} (Agent: ${run.AgentID})`);
-                }
-                catch (error) {
-                    (0, core_1.LogError)(`Failed to clean up run ${run.ID}: ${error.message}`);
-                }
-            }
-            (0, core_1.LogStatus)(`Cleaned up ${cleanedCount} stale agent runs`);
-            return cleanedCount;
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error during cleanup of failed runs: ${error.message}`);
-            return 0;
-        }
-    }
-}
-exports.BaseAgent = BaseAgent;
-function LoadBaseAgent() {
-}
-exports.LoadBaseAgent = LoadBaseAgent;
-//# sourceMappingURL=base-agent-original.js.map