@memberjunction/ai-agents 2.68.0 → 2.69.1

package/dist/base-agent.js

@@ -38,12 +38,18 @@ class BaseAgent {
     constructor() {
         this._promptRunner = new ai_prompts_1.AIPromptRunner();
         this._metadata = new core_1.Metadata();
+        this._executionCounts = new Map();
+        this._generalValidationRetryCount = 0;
         this._agentRun = null;
         this._agentHierarchy = [];
         this._depth = 0;
         this._allProgressSteps = [];
         this._subAgentRuns = [];
         this._payloadManager = new PayloadManager_1.PayloadManager();
+        this._validationRetryCount = 0;
+    }
+    get ValidationRetryCount() {
+        return this._validationRetryCount;
     }
     logStatus(message, verboseOnly = false, params) {
         if (verboseOnly) {
@@ -128,6 +134,8 @@ class BaseAgent {
                 message: this.formatHierarchicalMessage(`Initializing ${params.agent.Name} agent and preparing execution environment`)
             });
             await this.initializeAgentRun(wrappedParams);
+            this._validationRetryCount = 0;
+            this._generalValidationRetryCount = 0;
             await this.initializeEngines(params.contextUser);
             if (params.cancellationToken?.aborted) {
                 return await this.createCancelledResult('Cancelled during initialization', params.contextUser);
@@ -349,20 +357,20 @@ class BaseAgent {
         const nextStep = await agentTypeInstance.DetermineNextStep(promptResult, currentPayload);
         return nextStep;
     }
-    async validateNextStep(params, nextStep, currentPayload) {
+    async validateNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
         switch (nextStep.step) {
             case 'Sub-Agent':
-                return this.validateSubAgentNextStep(params, nextStep, currentPayload);
+                return this.validateSubAgentNextStep(params, nextStep, currentPayload, agentRun, currentStep);
             case 'Actions':
-                return this.validateActionsNextStep(params, nextStep, currentPayload);
+                return this.validateActionsNextStep(params, nextStep, currentPayload, agentRun, currentStep);
             case 'Success':
-                return this.validateSuccessNextStep(params, nextStep, currentPayload);
+                return this.validateSuccessNextStep(params, nextStep, currentPayload, agentRun, currentStep);
             case 'Chat':
-                return this.validateChatNextStep(params, nextStep, currentPayload);
+                return this.validateChatNextStep(params, nextStep, currentPayload, agentRun, currentStep);
             case 'Retry':
-                return this.validateRetryNextStep(params, nextStep, currentPayload);
+                return this.validateRetryNextStep(params, nextStep, currentPayload, agentRun, currentStep);
             case 'Failed':
-                return this.validateFailedNextStep(params, nextStep, currentPayload);
+                return this.validateFailedNextStep(params, nextStep, currentPayload, agentRun, currentStep);
             default:
                 this.logError(`Invalid next step '${nextStep.step}' for agent '${params.agent.Name}'`, {
                     agent: params.agent,
@@ -375,23 +383,49 @@ class BaseAgent {
                 };
         }
     }
-    async validateSubAgentNextStep(params, nextStep, currentPayload) {
+    async validateSubAgentNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
         const name = nextStep.subAgent?.name;
-        const curAgentSubAgents = aiengine_1.AIEngine.Instance.Agents.filter(a => a.ParentID === params.agent.ID && a.Status === 'Active');
-        if (!name || !curAgentSubAgents.some(a => a.Name.trim().toLowerCase() === name?.trim().toLowerCase())) {
+        const curAgentSubAgents = aiengine_1.AIEngine.Instance.GetSubAgents(params.agent.ID, 'Active');
+        const subAgent = curAgentSubAgents.find(a => a.Name.trim().toLowerCase() === name?.trim().toLowerCase());
+        if (!name || !subAgent) {
             this.logError(`Sub-agent '${name}' not found or not active for agent '${params.agent.Name}'`, {
                 agent: params.agent,
                 category: 'SubAgentExecution'
             });
+            if (nextStep.step !== 'Retry') {
+                this._generalValidationRetryCount++;
+            }
             return {
                 step: 'Retry',
                 terminate: false,
                 errorMessage: `Sub-agent '${name}' not found or not active`
             };
         }
+        if (subAgent.MaxExecutionsPerRun != null) {
+            const executionCount = await this.getSubAgentExecutionCount(agentRun.ID, subAgent.ID);
+            if (executionCount >= subAgent.MaxExecutionsPerRun) {
+                this.logError(`Sub-agent '${name}' has reached its maximum execution limit of ${subAgent.MaxExecutionsPerRun}`, {
+                    agent: params.agent,
+                    category: 'SubAgentExecution',
+                    metadata: {
+                        subAgentName: name,
+                        executionCount,
+                        maxExecutions: subAgent.MaxExecutionsPerRun
+                    }
+                });
+                if (nextStep.step !== 'Retry') {
+                    this._generalValidationRetryCount++;
+                }
+                return {
+                    step: 'Retry',
+                    terminate: false,
+                    errorMessage: `Sub-agent '${name}' has reached its maximum execution limit of ${subAgent.MaxExecutionsPerRun}`
+                };
+            }
+        }
         return nextStep;
     }
-    async validateActionsNextStep(params, nextStep, currentPayload) {
+    async validateActionsNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
         const curAgentActions = aiengine_1.AIEngine.Instance.AgentActions.filter(aa => aa.AgentID === params.agent.ID && aa.Status === 'Active');
         const missingActions = nextStep.actions?.filter(action => !curAgentActions.some(aa => aa.Action.trim().toLowerCase() === action.name.trim().toLowerCase()));
         if (missingActions && missingActions.length > 0) {
@@ -400,31 +434,312 @@ class BaseAgent {
                 agent: params.agent,
                 category: 'ActionExecution'
             });
+            if (nextStep.step !== 'Retry') {
+                this._generalValidationRetryCount++;
+            }
             return {
                 step: 'Retry',
                 terminate: false,
                 errorMessage: `Actions '${missingActionNames}' not found or not active`
             };
         }
+        if (nextStep.actions) {
+            const violatedActions = [];
+            for (const action of nextStep.actions) {
+                const agentAction = curAgentActions.find(aa => aa.Action.trim().toLowerCase() === action.name.trim().toLowerCase());
+                if (agentAction && agentAction.MaxExecutionsPerRun != null) {
+                    const executionCount = await this.getActionExecutionCount(agentRun.ID, agentAction.ActionID);
+                    if (executionCount >= agentAction.MaxExecutionsPerRun) {
+                        violatedActions.push(`${action.name} (limit: ${agentAction.MaxExecutionsPerRun}, current: ${executionCount})`);
+                    }
+                }
+            }
+            if (violatedActions.length > 0) {
+                const violationMessage = `Actions have reached execution limits: ${violatedActions.join(', ')}`;
+                this.logError(violationMessage, {
+                    agent: params.agent,
+                    category: 'ActionExecution',
+                    metadata: {
+                        violatedActions
+                    }
+                });
+                if (nextStep.step !== 'Retry') {
+                    this._generalValidationRetryCount++;
+                }
+                return {
+                    step: 'Retry',
+                    terminate: false,
+                    errorMessage: violationMessage
+                };
+            }
+        }
         return nextStep;
     }
-    async validateSuccessNextStep(params, nextStep, currentPayload) {
+    async validateSuccessNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
+        const minViolations = await this.checkMinimumExecutionRequirements(params.agent, agentRun);
+        if (minViolations.length > 0) {
+            const violationMessage = `Minimum execution requirements not met:\n${minViolations.join('\n')}`;
+            this.logError(violationMessage, {
+                agent: params.agent,
+                category: 'MinimumExecutionValidation'
+            });
+            if (nextStep.step !== 'Retry') {
+                this._generalValidationRetryCount++;
+            }
+            return {
+                step: 'Retry',
+                terminate: false,
+                errorMessage: violationMessage
+            };
+        }
+        const agent = params.agent;
+        if (!agent.FinalPayloadValidation || !currentPayload) {
+            return nextStep;
+        }
+        try {
+            let validationSchema;
+            try {
+                validationSchema = JSON.parse(agent.FinalPayloadValidation);
+            }
+            catch (parseError) {
+                this.logError(`Invalid FinalPayloadValidation JSON for agent ${agent.Name}: ${parseError.message}`, {
+                    category: 'PayloadValidation',
+                    metadata: {
+                        agentName: agent.Name,
+                        agentId: agent.ID,
+                        validationSchema: agent.FinalPayloadValidation
+                    }
+                });
+                return nextStep;
+            }
+            let payloadToValidate = currentPayload;
+            if (agent.PayloadScope) {
+                payloadToValidate = this._payloadManager.applyPayloadScope(currentPayload, agent.PayloadScope);
+                if (payloadToValidate === null) {
+                    const errorMessage = `PayloadScope '${agent.PayloadScope}' not found in payload`;
+                    return this.handleFinalPayloadValidationFailure(params, nextStep, currentPayload, agent.FinalPayloadValidationMode || 'Retry', [errorMessage], agentRun, currentStep);
+                }
+            }
+            const jsonValidator = new global_1.JSONValidator();
+            const validationResult = jsonValidator.validate(payloadToValidate, validationSchema);
+            if (!validationResult.Success) {
+                const mode = agent.FinalPayloadValidationMode || 'Retry';
+                const errorMessages = validationResult.Errors.map(e => e.Message);
+                this.logStatus(`⚠️ Final payload validation failed for agent ${agent.Name} (mode: ${mode}):`, true, params);
+                errorMessages.forEach((error, index) => {
+                    this.logStatus(`   ${index + 1}. ${error}`, true, params);
+                });
+                return this.handleFinalPayloadValidationFailure(params, nextStep, currentPayload, mode, errorMessages, agentRun, currentStep);
+            }
+            this.logStatus(`✅ Final payload validation passed for agent ${agent.Name}`, true, params);
+            try {
+                currentStep.FinalPayloadValidationResult = 'Pass';
+                currentStep.FinalPayloadValidationMessages = null;
+                await currentStep.Save();
+            }
+            catch (error) {
+                this.logError(`Failed to save validation success result: ${error.message}`, {
+                    category: 'PayloadValidation',
+                    metadata: { stepId: currentStep.ID }
+                });
+            }
+            return nextStep;
+        }
+        catch (error) {
+            this.logError(`Unexpected error during final payload validation: ${error.message}`, {
+                category: 'PayloadValidation',
+                metadata: {
+                    agentName: agent.Name,
+                    agentId: agent.ID,
+                    error: error.message
+                }
+            });
+            return nextStep;
+        }
+    }
+    async handleFinalPayloadValidationFailure(params, nextStep, currentPayload, mode, errorMessages, agentRun, currentStep) {
+        const validationFeedback = `Final payload validation failed:\n${errorMessages.map((e, i) => `${i + 1}. ${e}`).join('\n')}`;
+        try {
+            currentStep.FinalPayloadValidationMessages = errorMessages.join('; ');
+            switch (mode) {
+                case 'Retry':
+                    this._validationRetryCount++;
+                    const maxRetries = params.agent.FinalPayloadValidationMaxRetries || 3;
+                    if (this._validationRetryCount >= maxRetries) {
+                        this.logStatus(`❌ Max validation retries (${maxRetries}) exceeded, forcing failure`, false, params);
+                        currentStep.FinalPayloadValidationResult = 'Fail';
+                        await currentStep.Save();
+                        return {
+                            ...nextStep,
+                            step: 'Failed',
+                            message: `${validationFeedback}\n\nMax validation retries (${maxRetries}) exceeded.`,
+                            terminate: true
+                        };
+                    }
+                    currentStep.FinalPayloadValidationResult = 'Retry';
+                    await currentStep.Save();
+                    this.logStatus(`🔄 Validation retry ${this._validationRetryCount}/${maxRetries}`, true, params);
+                    return {
+                        ...nextStep,
+                        step: 'Retry',
+                        message: `${validationFeedback}\n\nRetry attempt ${this._validationRetryCount} of ${maxRetries}`,
+                        terminate: false
+                    };
+                case 'Fail':
+                    currentStep.FinalPayloadValidationResult = 'Fail';
+                    await currentStep.Save();
+                    return {
+                        ...nextStep,
+                        step: 'Failed',
+                        message: validationFeedback,
+                        terminate: true
+                    };
+                case 'Warn':
+                    this.logStatus(`⚠️ WARNING: ${validationFeedback}`, false, params);
+                    currentStep.FinalPayloadValidationResult = 'Warn';
+                    await currentStep.Save();
+                    return nextStep;
+                default:
+                    this._validationRetryCount++;
+                    currentStep.FinalPayloadValidationResult = 'Retry';
+                    await currentStep.Save();
+                    return {
+                        ...nextStep,
+                        step: 'Retry',
+                        message: validationFeedback,
+                        terminate: false
+                    };
+            }
+        }
+        catch (error) {
+            this.logError(`Failed to save validation results: ${error.message}`, {
+                category: 'PayloadValidation',
+                metadata: { stepId: currentStep.ID }
+            });
+            return mode === 'Warn' ? nextStep : {
+                ...nextStep,
+                step: mode === 'Fail' ? 'Failed' : 'Retry',
+                message: validationFeedback,
+                terminate: mode === 'Fail'
+            };
+        }
+    }
+    async validateFailedNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
         return nextStep;
     }
-    async validateFailedNextStep(params, nextStep, currentPayload) {
+    async validateRetryNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
         return nextStep;
     }
-    async validateRetryNextStep(params, nextStep, currentPayload) {
+    async validateChatNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
         return nextStep;
     }
-    async validateChatNextStep(params, nextStep, currentPayload) {
+    async checkExecutionGuardrails(params, nextStep, currentPayload, agentRun, currentStep) {
+        if (nextStep.step === 'Success' || nextStep.step === 'Failed' || nextStep.step === 'Chat') {
+            return nextStep;
+        }
+        const guardrailResult = await this.hasExceededAgentRunGuardrails(params, agentRun);
+        if (guardrailResult.exceeded) {
+            this.logStatus(`⛔ Execution guardrail exceeded: ${guardrailResult.reason}`, false, params);
+            try {
+                const outputData = currentStep.OutputData ? JSON.parse(currentStep.OutputData) : {};
+                currentStep.OutputData = JSON.stringify({
+                    ...outputData,
+                    guardrailExceeded: {
+                        type: guardrailResult.type,
+                        limit: guardrailResult.limit,
+                        current: guardrailResult.current,
+                        reason: guardrailResult.reason,
+                        timestamp: new Date().toISOString()
+                    }
+                });
+                await currentStep.Save();
+            }
+            catch (error) {
+                this.logError(`Failed to save guardrail violation to step: ${error.message}`, {
+                    category: 'Guardrails',
+                    metadata: { stepId: currentStep.ID }
+                });
+            }
+            return {
+                ...nextStep,
+                step: 'Failed',
+                terminate: true,
+                message: guardrailResult.reason,
+                errorMessage: guardrailResult.reason
+            };
+        }
         return nextStep;
     }
-    async processNextStep(params, agentType, promptResult, currentPayload) {
+    async hasExceededAgentRunGuardrails(params, agentRun) {
+        const agent = params.agent;
+        if (agent.MaxCostPerRun && agentRun.TotalCost) {
+            if (agentRun.TotalCost >= agent.MaxCostPerRun) {
+                return {
+                    exceeded: true,
+                    type: 'cost',
+                    limit: agent.MaxCostPerRun,
+                    current: agentRun.TotalCost,
+                    reason: `Maximum cost limit of $${agent.MaxCostPerRun} exceeded. Current cost: $${agentRun.TotalCost.toFixed(4)}`
+                };
+            }
+        }
+        if (agent.MaxTokensPerRun && agentRun.TotalTokensUsed) {
+            if (agentRun.TotalTokensUsed >= agent.MaxTokensPerRun) {
+                return {
+                    exceeded: true,
+                    type: 'tokens',
+                    limit: agent.MaxTokensPerRun,
+                    current: agentRun.TotalTokensUsed,
+                    reason: `Maximum token limit of ${agent.MaxTokensPerRun} exceeded. Current tokens: ${agentRun.TotalTokensUsed}`
+                };
+            }
+        }
+        if (agent.MaxIterationsPerRun && agentRun.TotalPromptIterations) {
+            if (agentRun.TotalPromptIterations >= agent.MaxIterationsPerRun) {
+                return {
+                    exceeded: true,
+                    type: 'iterations',
+                    limit: agent.MaxIterationsPerRun,
+                    current: agentRun.TotalPromptIterations,
+                    reason: `Maximum iteration limit of ${agent.MaxIterationsPerRun} exceeded. Current iterations: ${agentRun.TotalPromptIterations}`
+                };
+            }
+        }
+        if (agent.MaxTimePerRun && agentRun.StartedAt) {
+            const elapsedSeconds = Math.floor((Date.now() - new Date(agentRun.StartedAt).getTime()) / 1000);
+            if (elapsedSeconds >= agent.MaxTimePerRun) {
+                return {
+                    exceeded: true,
+                    type: 'time',
+                    limit: agent.MaxTimePerRun,
+                    current: elapsedSeconds,
+                    reason: `Maximum time limit of ${agent.MaxTimePerRun} seconds exceeded. Elapsed time: ${elapsedSeconds} seconds`
+                };
+            }
+        }
+        if (this._generalValidationRetryCount >= BaseAgent.MAX_VALIDATION_RETRIES) {
+            return {
+                exceeded: true,
+                type: 'iterations',
+                limit: BaseAgent.MAX_VALIDATION_RETRIES,
+                current: this._generalValidationRetryCount,
+                reason: `Maximum validation retries of ${BaseAgent.MAX_VALIDATION_RETRIES} exceeded. The agent is unable to produce valid output after ${this._generalValidationRetryCount} validation failures.`
+            };
+        }
+        return { exceeded: false };
+    }
+    async processNextStep(params, agentType, promptResult, currentPayload, currentStep) {
         const nextStep = await this.determineNextStep(params, agentType, promptResult, currentPayload);
-        const validatedNextStep = await this.validateNextStep(params, nextStep, currentPayload);
-        this.logStatus(`📌 Next step determined: ${validatedNextStep.step}${validatedNextStep.terminate ? ' (terminating)' : ''}`, true, params);
-        return validatedNextStep;
+        const validatedNextStep = await this.validateNextStep(params, nextStep, currentPayload, this._agentRun, currentStep);
+        const guardrailCheckedStep = await this.checkExecutionGuardrails(params, validatedNextStep, currentPayload, this._agentRun, currentStep);
+        this.logStatus(`📌 Next step determined: ${guardrailCheckedStep.step}${guardrailCheckedStep.terminate ? ' (terminating)' : ''}`, true, params);
+        if (guardrailCheckedStep.step === 'Retry' && (guardrailCheckedStep.message || guardrailCheckedStep.errorMessage || guardrailCheckedStep.retryInstructions)) {
+            params.conversationMessages.push({
+                role: 'user',
+                content: `Retrying due to: ${guardrailCheckedStep.retryInstructions || guardrailCheckedStep.message || guardrailCheckedStep.errorMessage}`
+            });
+        }
+        return guardrailCheckedStep;
     }
     createActionResultMessage(actions, results) {
         const resultSummary = actions.map((action, index) => {
@@ -913,6 +1228,9 @@ class BaseAgent {
                 stepEntity.TargetLogID = promptResult.promptRun.ID;
                 stepEntity.PromptRun = promptResult.promptRun;
             }
+            if (this._agentRun) {
+                this._agentRun.TotalPromptIterations = (this._agentRun.TotalPromptIterations || 0) + 1;
+            }
             if (params.cancellationToken?.aborted) {
                 await this.finalizeStepEntity(stepEntity, false, 'Cancelled during prompt execution');
                 const cancelledResult = await this.createCancelledResult('Cancelled during prompt execution', params.contextUser);
@@ -930,7 +1248,7 @@ class BaseAgent {
                 message: this.formatHierarchicalMessage('Analyzing response and determining next steps'),
                 displayMode: 'both'
             });
-            const nextStep = await this.processNextStep(params, config.agentType, promptResult, payload);
+            const nextStep = await this.processNextStep(params, config.agentType, promptResult, payload, stepEntity);
             let finalPayload = payload;
             let currentStepPayloadChangeResult = undefined;
             if (nextStep.payloadChangeRequest) {
@@ -1023,6 +1341,7 @@ class BaseAgent {
             throw new Error(`Sub-agent '${subAgentRequest.name}' not found`);
         }
         const stepEntity = await this.createStepEntity('Sub-Agent', `Execute Sub-Agent: ${subAgentRequest.name}`, params.contextUser, subAgentEntity.ID, inputData);
+        this.incrementExecutionCount(subAgentEntity.ID);
         try {
             let downstreamPaths = ['*'];
             let upstreamPaths = ['*'];
@@ -1046,10 +1365,31 @@ class BaseAgent {
                     }
                 });
             }
-            const downstreamPayload = this._payloadManager.extractDownstreamPayload(subAgentRequest.name, previousDecision.newPayload, downstreamPaths);
+            let downstreamPayload = this._payloadManager.extractDownstreamPayload(subAgentRequest.name, previousDecision.newPayload, downstreamPaths);
+            let scopedPayload = downstreamPayload;
+            if (subAgentEntity.PayloadScope) {
+                scopedPayload = this._payloadManager.applyPayloadScope(downstreamPayload, subAgentEntity.PayloadScope);
+                if (scopedPayload === null) {
+                    const errorMessage = `Critical: Failed to extract payload scope '${subAgentEntity.PayloadScope}' for sub-agent '${subAgentRequest.name}'. The specified path does not exist in the payload.`;
+                    this.logError(errorMessage, {
+                        category: 'SubAgentExecution',
+                        metadata: {
+                            agentName: params.agent.Name,
+                            subAgentName: subAgentRequest.name,
+                            payloadScope: subAgentEntity.PayloadScope,
+                            availableKeys: Object.keys(downstreamPayload || {})
+                        }
+                    });
+                    throw new Error(errorMessage);
+                }
+            }
             stepEntity.PayloadAtStart = JSON.stringify(previousDecision.newPayload);
-            const subAgentResult = await this.ExecuteSubAgent(params, subAgentRequest, subAgentEntity, stepEntity, downstreamPayload);
-            const mergedPayload = this._payloadManager.mergeUpstreamPayload(subAgentRequest.name, previousDecision.newPayload, subAgentResult.payload, upstreamPaths);
+            const subAgentResult = await this.ExecuteSubAgent(params, subAgentRequest, subAgentEntity, stepEntity, scopedPayload);
+            let resultPayloadForMerge = subAgentResult.payload;
+            if (subAgentEntity.PayloadScope) {
+                resultPayloadForMerge = this._payloadManager.reversePayloadScope(subAgentResult.payload, subAgentEntity.PayloadScope);
+            }
+            const mergedPayload = this._payloadManager.mergeUpstreamPayload(subAgentRequest.name, previousDecision.newPayload, resultPayloadForMerge, upstreamPaths);
             const mergeChangeRequest = {
                 newElements: {},
                 updateElements: {},
@@ -1216,6 +1556,7 @@ class BaseAgent {
                 }
                 const stepEntity = await this.createStepEntity('Actions', `Execute Action: ${aa.name}`, params.contextUser, actionEntity.ID);
                 stepEntity.StepNumber = baseStepNumber + numActionsProcessed++;
+                this.incrementExecutionCount(actionEntity.ID);
                 let actionResult;
                 try {
                     actionResult = await this.ExecuteSingleAction(params, aa, actionEntity, params.contextUser);
@@ -1377,6 +1718,42 @@ class BaseAgent {
         }
         return { totalTokens, promptTokens, completionTokens, totalCost };
     }
+    async getActionExecutionCount(agentRunId, actionId) {
+        return this.getExecutionCount(actionId);
+    }
+    async getSubAgentExecutionCount(agentRunId, subAgentId) {
+        return this.getExecutionCount(subAgentId);
+    }
+    incrementExecutionCount(itemId) {
+        const currentCount = this._executionCounts.get(itemId) || 0;
+        this._executionCounts.set(itemId, currentCount + 1);
+    }
+    getExecutionCount(itemId) {
+        return this._executionCounts.get(itemId) || 0;
+    }
+    async checkMinimumExecutionRequirements(agent, agentRun) {
+        const violations = [];
+        const agentActions = aiengine_1.AIEngine.Instance.AgentActions.filter(aa => aa.AgentID === agent.ID &&
+            aa.Status === 'Active' &&
+            aa.MinExecutionsPerRun != null &&
+            aa.MinExecutionsPerRun > 0);
+        for (const agentAction of agentActions) {
+            const executionCount = await this.getActionExecutionCount(agentRun.ID, agentAction.ActionID);
+            if (executionCount < agentAction.MinExecutionsPerRun) {
+                violations.push(`Action '${agentAction.Action}' requires ${agentAction.MinExecutionsPerRun} execution(s) but was executed ${executionCount} time(s)`);
+            }
+        }
+        const subAgents = aiengine_1.AIEngine.Instance.GetSubAgents(agent.ID, "Active").filter(a => a.MinExecutionsPerRun != null &&
+            a.MinExecutionsPerRun > 0);
+        for (const subAgent of subAgents) {
+            const executionCount = await this.getSubAgentExecutionCount(agentRun.ID, subAgent.ID);
+            if (executionCount < subAgent.MinExecutionsPerRun) {
+                violations.push(`Sub-agent '${subAgent.Name}' requires ${subAgent.MinExecutionsPerRun} execution(s) but was executed ${executionCount} time(s)`);
+            }
+        }
+        return violations;
+    }
 }
 exports.BaseAgent = BaseAgent;
+BaseAgent.MAX_VALIDATION_RETRIES = 10;
 //# sourceMappingURL=base-agent.js.map