@memberjunction/ai-agents 2.123.1 → 2.124.0

package/dist/base-agent.js

@@ -54,6 +54,7 @@ class BaseAgent {
         this._subAgentRuns = [];
         this._payloadManager = new PayloadManager_1.PayloadManager();
         this._effectiveActions = [];
+        this._dynamicActionLimits = {};
         this._validationRetryCount = 0;
         this._contextRecoveryAttempts = 0;
         this.MAX_RECOVERY_ATTEMPTS = 1;
@@ -238,6 +239,8 @@ class BaseAgent {
             this._validationRetryCount = 0;
             this._generalValidationRetryCount = 0;
             this._contextRecoveryAttempts = 0;
+            this._effectiveActions = [];
+            this._dynamicActionLimits = {};
             this._messageLifecycleCallback = params.onMessageLifecycle;
             await this.initializeEngines(params.contextUser);
             if (params.cancellationToken?.aborted) {
@@ -735,27 +738,29 @@ class BaseAgent {
         return nextStep;
     }
     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 effectiveActions = this.getEffectiveActionsForValidation(params.agent.ID);
+        const dbAgentActions = aiengine_1.AIEngine.Instance.AgentActions.filter(aa => aa.AgentID === params.agent.ID && aa.Status === 'Active');
         const missingActions = nextStep.actions?.filter(action => {
             const actionName = action.name.trim().toLowerCase();
-            const exactMatch = curAgentActions.find(aa => aa.Action.trim().toLowerCase() === actionName);
+            const exactMatch = effectiveActions.find(a => a.Name.trim().toLowerCase() === actionName);
             if (exactMatch)
                 return false;
-            const containsMatches = curAgentActions.filter(aa => aa.Action.trim().toLowerCase().includes(actionName));
+            const containsMatches = effectiveActions.filter(a => a.Name.trim().toLowerCase().includes(actionName));
             if (containsMatches.length === 1) {
-                const correctedName = containsMatches[0].Action;
+                const correctedName = containsMatches[0].Name;
                 this.logStatus(`Action name fuzzy matched: '${action.name}' → '${correctedName}'`, true, params);
                 action.name = correctedName;
                 return false;
             }
             if (containsMatches.length > 1) {
-                this.logStatus(`Ambiguous action name '${action.name}' matches ${containsMatches.length} actions: ${containsMatches.map(a => a.Action).join(', ')}`, true, params);
+                this.logStatus(`Ambiguous action name '${action.name}' matches ${containsMatches.length} actions: ${containsMatches.map(a => a.Name).join(', ')}`, true, params);
             }
             return true;
         });
         if (missingActions && missingActions.length > 0) {
             const missingActionNames = missingActions.map(a => a.name).join(', ');
-            this.logError(`Actions '${missingActionNames}' not found or not active for agent '${params.agent.Name}'`, {
+            const availableActionNames = effectiveActions.map(a => a.Name).join(', ');
+            this.logError(`Actions '${missingActionNames}' not found or not active for agent '${params.agent.Name}'. Available actions: ${availableActionNames}`, {
                 agent: params.agent,
                 category: 'ActionExecution'
             });
@@ -765,17 +770,27 @@ class BaseAgent {
             return {
                 step: 'Retry',
                 terminate: false,
-                errorMessage: `Actions '${missingActionNames}' not found or not active`
+                errorMessage: `Actions '${missingActionNames}' not found or not active. Available: ${availableActionNames}`
             };
         }
         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})`);
+                const actionEntity = effectiveActions.find(a => a.Name.trim().toLowerCase() === action.name.trim().toLowerCase());
+                if (!actionEntity)
+                    continue;
+                const dbAgentAction = dbAgentActions.find(aa => aa.ActionID === actionEntity.ID);
+                let maxExecutions = null;
+                if (dbAgentAction?.MaxExecutionsPerRun != null) {
+                    maxExecutions = dbAgentAction.MaxExecutionsPerRun;
+                }
+                else if (this._dynamicActionLimits[actionEntity.ID] != null) {
+                    maxExecutions = this._dynamicActionLimits[actionEntity.ID];
+                }
+                if (maxExecutions != null) {
+                    const executionCount = await this.getActionExecutionCount(agentRun.ID, actionEntity.ID);
+                    if (executionCount >= maxExecutions) {
+                        violatedActions.push(`${action.name} (limit: ${maxExecutions}, current: ${executionCount})`);
                     }
                 }
             }
@@ -800,6 +815,13 @@ class BaseAgent {
         }
         return nextStep;
     }
+    getEffectiveActionsForValidation(agentId) {
+        if (this._effectiveActions.length > 0) {
+            return this._effectiveActions;
+        }
+        const agentActions = aiengine_1.AIEngine.Instance.AgentActions.filter(aa => aa.AgentID === agentId && aa.Status === 'Active');
+        return actions_1.ActionEngineServer.Instance.Actions.filter(a => agentActions.some(aa => aa.ActionID === a.ID) && a.Status === 'Active');
+    }
     async validateSuccessNextStep(params, nextStep, currentPayload, agentRun, currentStep) {
         const minViolations = await this.checkMinimumExecutionRequirements(params.agent, agentRun);
         if (minViolations.length > 0) {
@@ -1620,7 +1642,9 @@ The context is now within limits. Please retry your request with the recovered c
             let actions = actions_1.ActionEngineServer.Instance.Actions.filter(a => agentActions.some(aa => aa.ActionID === a.ID));
             if (actionChanges?.length) {
                 const isRoot = this._depth === 0;
-                actions = this.applyActionChanges(actions, actionChanges, agent.ID, isRoot);
+                const result = this.applyActionChanges(actions, actionChanges, agent.ID, isRoot);
+                actions = result.actions;
+                this._dynamicActionLimits = result.dynamicLimits;
             }
             const activeActions = actions.filter(a => a.Status === 'Active');
             this._effectiveActions = activeActions;
@@ -1900,6 +1924,7 @@ The context is now within limits. Please retry your request with the recovered c
     }
     applyActionChanges(baseActions, actionChanges, agentId, isRoot) {
         let actions = [...baseActions];
+        const dynamicLimits = {};
         for (const change of actionChanges) {
             if (!this.doesChangeScopeApply(change.scope, agentId, isRoot, change.agentIds)) {
                 continue;
@@ -1910,6 +1935,9 @@ The context is now within limits. Please retry your request with the recovered c
                         const actionToAdd = actions_1.ActionEngineServer.Instance.Actions.find(a => a.ID === actionId);
                         if (actionToAdd) {
                             actions.push(actionToAdd);
+                            if (change.actionLimits?.[actionId] != null) {
+                                dynamicLimits[actionId] = change.actionLimits[actionId];
+                            }
                         }
                         else {
                             (0, core_1.LogStatus)(`Action with ID '${actionId}' not found in ActionEngineServer - skipping add`);
@@ -1921,7 +1949,7 @@ The context is now within limits. Please retry your request with the recovered c
                 actions = actions.filter(a => !change.actionIds.includes(a.ID));
             }
         }
-        return actions;
+        return { actions, dynamicLimits };
     }
     filterActionChangesForSubAgent(actionChanges) {
         if (!actionChanges?.length) {
@@ -3417,18 +3445,22 @@ The context is now within limits. Please retry your request with the recovered c
         return null;
     }
     validateActionInAgent(actionName) {
-        const aa = aiengine_1.AIEngine.Instance.AgentActions.filter(aa => aa.AgentID === this._agentRun.AgentID);
-        let action = aa.filter(a => a.Agent?.trim().toLowerCase() === actionName.trim().toLowerCase());
-        if (!action) {
-            const partialAction = aa.filter(a => a.Agent?.trim().toLowerCase().includes(actionName.trim().toLowerCase() || ''));
-            if (partialAction.length > 1) {
-                return `Ambiguous action '${actionName}' specified`;
-            }
-            else if (partialAction.length === 0) {
-                return `No action '${actionName}' found`;
-            }
+        const effectiveActions = this.getEffectiveActionsForValidation(this._agentRun.AgentID);
+        const normalizedName = actionName.trim().toLowerCase();
+        const exactMatch = effectiveActions.find(a => a.Name.trim().toLowerCase() === normalizedName);
+        if (exactMatch) {
+            return null;
+        }
+        const partialMatches = effectiveActions.filter(a => a.Name.trim().toLowerCase().includes(normalizedName));
+        if (partialMatches.length === 1) {
+            return null;
+        }
+        else if (partialMatches.length > 1) {
+            return `Ambiguous action '${actionName}' specified. Matches: ${partialMatches.map(a => a.Name).join(', ')}`;
+        }
+        else {
+            return `No action '${actionName}' found. Available: ${effectiveActions.map(a => a.Name).join(', ')}`;
         }
-        return null;
     }
     validateSubAgentInAgent(subAgentName) {
         const relatedAgents = aiengine_1.AIEngine.Instance.AgentRelationships.filter(ar => ar.AgentID === this._agentRun.AgentID);
@@ -3622,22 +3654,23 @@ The context is now within limits. Please retry your request with the recovered c
         });
     }
     findAgentActionForLoop(actionName, agentId, agentName, params) {
-        const agentActions = aiengine_1.AIEngine.Instance.AgentActions.filter(aa => aa.AgentID === agentId && aa.Status === 'Active');
-        let matched = agentActions.find(aa => aa.Action.trim().toLowerCase() === actionName.trim().toLowerCase());
-        if (!matched) {
-            const containsMatches = agentActions.filter(aa => aa.Action.trim().toLowerCase().includes(actionName.trim().toLowerCase()));
+        const effectiveActions = this.getEffectiveActionsForValidation(agentId);
+        const normalizedName = actionName.trim().toLowerCase();
+        let matchedAction = effectiveActions.find(a => a.Name.trim().toLowerCase() === normalizedName);
+        if (!matchedAction) {
+            const containsMatches = effectiveActions.filter(a => a.Name.trim().toLowerCase().includes(normalizedName));
             if (containsMatches.length === 1) {
-                matched = containsMatches[0];
-                this.logStatus(`Action fuzzy matched: '${actionName}' → '${matched.Action}'`, true, params);
+                matchedAction = containsMatches[0];
+                this.logStatus(`Action fuzzy matched: '${actionName}' → '${matchedAction.Name}'`, true, params);
             }
             else if (containsMatches.length > 1) {
-                throw new Error(`Ambiguous action '${actionName}'. Matches: ${containsMatches.map(a => a.Action).join(', ')}`);
+                throw new Error(`Ambiguous action '${actionName}'. Matches: ${containsMatches.map(a => a.Name).join(', ')}`);
             }
             else {
-                throw new Error(`Action '${actionName}' not found for agent '${agentName}'`);
+                throw new Error(`Action '${actionName}' not found for agent '${agentName}'. Available: ${effectiveActions.map(a => a.Name).join(', ')}`);
             }
         }
-        return matched;
+        return { Action: matchedAction.Name };
     }
     createFailedStep(errorMessage, previousDecision) {
         return {