@memberjunction/ai-agents 2.106.0 → 2.108.0

package/dist/base-agent.js

@@ -49,6 +49,7 @@ class BaseAgent {
         this._subAgentRuns = [];
         this._payloadManager = new PayloadManager_1.PayloadManager();
         this._validationRetryCount = 0;
+        this._contextRecoveryAttempted = false;
     }
     get AgentTypeState() {
         return this._agentTypeState;
@@ -158,6 +159,8 @@ class BaseAgent {
             await this.initializeAgentRun(wrappedParams);
             this._validationRetryCount = 0;
             this._generalValidationRetryCount = 0;
+            this._contextRecoveryAttempted = false;
+            this._messageLifecycleCallback = params.onMessageLifecycle;
             await this.initializeEngines(params.contextUser);
             if (params.cancellationToken?.aborted) {
                 return await this.createCancelledResult('Cancelled during initialization', params.contextUser);
@@ -219,6 +222,7 @@ class BaseAgent {
             if (params.cancellationToken?.aborted) {
                 throw new Error('Cancelled during execution');
             }
+            await this.pruneAndCompactExpiredMessages(params, stepCount);
             this.logStatus(`🔄 Executing step ${stepCount + 1} for agent '${params.agent.Name}'`, true, params);
             const nextStep = await this.executeNextStep(params, config, currentNextStep);
             stepCount++;
@@ -897,6 +901,163 @@ class BaseAgent {
         }
         return { exceeded: false };
     }
+    isFatalPromptError(promptResult) {
+        if (!promptResult?.chatResult?.errorInfo) {
+            return false;
+        }
+        const errorInfo = promptResult.chatResult.errorInfo;
+        if (errorInfo.severity === 'Fatal') {
+            return true;
+        }
+        const fatalErrorTypes = [
+            'ContextLengthExceeded',
+            'Authentication',
+            'InvalidRequest'
+        ];
+        return fatalErrorTypes.includes(errorInfo.errorType);
+    }
+    contentToString(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return content.map((block) => {
+            if (block.type === 'text') {
+                return block.content;
+            }
+            return `[${block.type}: ${block.content}]`;
+        }).join('\n');
+    }
+    smartTrimContent(content, maxLength = 1000) {
+        const originalLength = content.length;
+        try {
+            const data = JSON.parse(content);
+            if (Array.isArray(data)) {
+                const itemsToKeep = 10;
+                if (data.length > itemsToKeep) {
+                    const truncated = data.slice(0, itemsToKeep);
+                    const trimmed = JSON.stringify(truncated, null, 2) +
+                        `\n\n... (${(data.length - itemsToKeep).toLocaleString()} more items truncated due to context length)`;
+                    return {
+                        trimmed,
+                        strategy: 'JSON array truncation',
+                        originalLength
+                    };
+                }
+            }
+            else if (typeof data === 'object' && data !== null) {
+                const truncated = {};
+                let fieldCount = 0;
+                const maxFields = 20;
+                for (const [key, value] of Object.entries(data)) {
+                    if (fieldCount >= maxFields) {
+                        truncated['...'] = `(${Object.keys(data).length - maxFields} more fields truncated)`;
+                        break;
+                    }
+                    if (typeof value === 'string' && value.length > 200) {
+                        truncated[key] = value.substring(0, 200) + '... (truncated)';
+                    }
+                    else if (Array.isArray(value) && value.length > 5) {
+                        truncated[key] = [...value.slice(0, 5), `... (${value.length - 5} more items)`];
+                    }
+                    else {
+                        truncated[key] = value;
+                    }
+                    fieldCount++;
+                }
+                return {
+                    trimmed: JSON.stringify(truncated, null, 2),
+                    strategy: 'JSON object field truncation',
+                    originalLength
+                };
+            }
+        }
+        catch {
+        }
+        if (content.includes('\n')) {
+            const lines = content.split('\n');
+            const firstLine = lines[0];
+            if (firstLine.includes(',') && lines.length > 1) {
+                const rowsToKeep = 10;
+                if (lines.length > rowsToKeep + 1) {
+                    const header = lines[0];
+                    const dataRows = lines.slice(1, rowsToKeep + 1);
+                    const trimmed = [header, ...dataRows].join('\n') +
+                        `\n... (${(lines.length - rowsToKeep - 1).toLocaleString()} more rows truncated due to context length)`;
+                    return {
+                        trimmed,
+                        strategy: 'CSV row truncation',
+                        originalLength
+                    };
+                }
+            }
+        }
+        if (content.length > maxLength) {
+            return {
+                trimmed: content.substring(0, maxLength) + '\n\n... (truncated due to context length)',
+                strategy: 'character truncation',
+                originalLength
+            };
+        }
+        return {
+            trimmed: content,
+            strategy: 'no truncation needed',
+            originalLength
+        };
+    }
+    async attemptContextRecovery(params, payload, errorMessage) {
+        this.logStatus(`⚠️ Context length exceeded - attempting recovery by trimming conversation messages`, true, params);
+        const messages = params.conversationMessages;
+        let lastUserMessageIndex = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'user') {
+                lastUserMessageIndex = i;
+                break;
+            }
+        }
+        if (lastUserMessageIndex === -1) {
+            this.logStatus(`❌ Context recovery failed: No trimmable user messages found`, true, params);
+            return {
+                errorMessage: `Context overflow with no trimmable messages: ${errorMessage}`,
+                step: 'Failed',
+                terminate: true,
+                previousPayload: payload,
+                newPayload: payload
+            };
+        }
+        const originalMessage = messages[lastUserMessageIndex];
+        const contentString = this.contentToString(originalMessage.content);
+        const trimResult = this.smartTrimContent(contentString, 1000);
+        this.logStatus(`✂️ Trimmed message from ${trimResult.originalLength.toLocaleString()} to ${trimResult.trimmed.length.toLocaleString()} characters using ${trimResult.strategy}`, true, params);
+        messages[lastUserMessageIndex] = {
+            role: 'user',
+            content: `⚠️ CONTEXT OVERFLOW RECOVERY ⚠️
+
+The previous step returned a result that exceeded the context window (${(trimResult.originalLength - trimResult.trimmed.length).toLocaleString()} characters truncated).
+
+Here is a PARTIAL result from the previous action:
+---
+${trimResult.trimmed}
+---
+
+❗ THE ABOVE IS INCOMPLETE - the full result was too large for the context window.
+
+RECOMMENDED ACTIONS:
+1. Use a different action with more specific filters to get smaller result sets
+2. Request data in batches or pages instead of all at once
+3. Ask the user to clarify scope to narrow the query
+4. If you need the full data, acknowledge the limitation and ask the user how to proceed
+
+Please choose an alternative approach to complete your task.`
+        };
+        return {
+            step: 'Retry',
+            retryReason: 'Context length recovery - previous result too large',
+            retryInstructions: 'The previous action result exceeded context limits. Use more specific filters or request data in smaller batches.',
+            terminate: false,
+            previousPayload: payload,
+            newPayload: payload
+        };
+    }
     async processNextStep(nextStep, params, agentType, promptResult, currentPayload, currentStep) {
         const validatedNextStep = await this.validateNextStep(params, nextStep, currentPayload, this._agentRun, currentStep);
         const guardrailCheckedStep = await this.checkExecutionGuardrails(params, validatedNextStep, currentPayload, this._agentRun, currentStep);
@@ -1006,16 +1167,18 @@ class BaseAgent {
             throw new Error(`Error executing actions: ${error.message}`);
         }
     }
-    async ExecuteSubAgent(params, subAgentRequest, subAgent, stepEntity, payload) {
+    async ExecuteSubAgent(params, subAgentRequest, subAgent, stepEntity, payload, contextMessage) {
         try {
             this.logStatus(`🤖 Executing sub-agent '${subAgentRequest.name}'`, true, params);
             const runner = new AgentRunner_1.AgentRunner();
-            const subAgentMessages = [
-                {
-                    role: 'user',
-                    content: subAgentRequest.message
-                }
-            ];
+            const subAgentMessages = [];
+            if (contextMessage) {
+                subAgentMessages.push(contextMessage);
+            }
+            subAgentMessages.push({
+                role: 'user',
+                content: subAgentRequest.message
+            });
             this.logStatus(`📨 Sub-agent message: "${subAgentRequest.message}"`, true, params);
             if (subAgentRequest.templateParameters) {
                 this.logStatus(`📎 Template parameters: ${JSON.stringify(subAgentRequest.templateParameters)}`, true, params);
@@ -1134,6 +1297,25 @@ class BaseAgent {
             ValueType: param.ValueType
         };
     }
+    formatParamValueForMessage(value, maxLength = 100) {
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+        let stringValue;
+        if (typeof value === 'string') {
+            stringValue = value;
+        }
+        else if (typeof value === 'object') {
+            stringValue = JSON.stringify(value);
+        }
+        else {
+            stringValue = String(value);
+        }
+        if (stringValue.length > maxLength) {
+            return `\`${stringValue.substring(0, maxLength)}...\``;
+        }
+        return `\`${stringValue}\``;
+    }
     getAgentTypeName(typeID) {
         const agentType = aiengine_1.AIEngine.Instance.AgentTypes.find(at => at.ID === typeID);
         return agentType?.Name || 'Unknown';
@@ -1364,9 +1546,13 @@ class BaseAgent {
         }
         switch (previousDecision.step) {
             case 'Retry':
+                if (previousDecision.messageIndex !== undefined) {
+                    const currentStepCount = this._agentRun?.Steps?.length || 0;
+                    this.executeExpandMessageStep(previousDecision, params, currentStepCount);
+                }
                 return await this.executePromptStep(params, config, previousDecision);
             case 'Sub-Agent':
-                return await this.executeSubAgentStep(params, previousDecision);
+                return await this.processSubAgentStep(params, previousDecision);
             case 'Actions':
                 return await this.executeActionsStep(params, config, previousDecision);
             case 'Chat':
@@ -1466,6 +1652,25 @@ class BaseAgent {
                 stepEntity.TargetLogID = promptResult.promptRun.ID;
                 stepEntity.PromptRun = promptResult.promptRun;
             }
+            if (!promptResult.success) {
+                await this.finalizeStepEntity(stepEntity, false, promptResult.errorMessage);
+                const isFatal = this.isFatalPromptError(promptResult);
+                const isContextOverflow = isFatal &&
+                    promptResult.chatResult?.errorInfo?.errorType === 'ContextLengthExceeded';
+                if (isContextOverflow && !this._contextRecoveryAttempted) {
+                    this._contextRecoveryAttempted = true;
+                    this.logStatus(`⚠️ Context length exceeded - attempting recovery by trimming conversation`, true, params);
+                    return await this.attemptContextRecovery(params, payload, promptResult.errorMessage || 'Context length exceeded');
+                }
+                this.logStatus(`❌ Prompt execution failed: ${promptResult.errorMessage} (fatal: ${isFatal})`, true, params);
+                return {
+                    errorMessage: promptResult.errorMessage || 'Prompt execution failed',
+                    step: 'Failed',
+                    terminate: isFatal,
+                    previousPayload: payload,
+                    newPayload: payload
+                };
+            }
             if (params.cancellationToken?.aborted) {
                 await this.finalizeStepEntity(stepEntity, false, 'Cancelled during prompt execution');
                 const cancelledResult = await this.createCancelledResult('Cancelled during prompt execution', params.contextUser);
@@ -1555,7 +1760,7 @@ class BaseAgent {
             return errorNextStep;
         }
     }
-    async executeSubAgentStep(params, previousDecision) {
+    async executeChildSubAgentStep(params, previousDecision) {
         const subAgentRequest = previousDecision.subAgent;
         if (params.cancellationToken?.aborted) {
             throw new Error('Cancelled before sub-agent execution');
@@ -1631,7 +1836,7 @@ class BaseAgent {
                 }
             }
             stepEntity.PayloadAtStart = JSON.stringify(previousDecision.newPayload);
-            const subAgentResult = await this.ExecuteSubAgent(params, subAgentRequest, subAgentEntity, stepEntity, scopedPayload);
+            const subAgentResult = await this.ExecuteSubAgent(params, subAgentRequest, subAgentEntity, stepEntity, scopedPayload, undefined);
             let mergedPayload = previousDecision.newPayload;
             let currentStepPayloadChangeResult = undefined;
             if (subAgentResult.success) {
@@ -1771,6 +1976,322 @@ class BaseAgent {
             };
         }
     }
+    async processSubAgentStep(params, previousDecision) {
+        const subAgentRequest = previousDecision.subAgent;
+        const name = subAgentRequest?.name;
+        if (!name) {
+            return {
+                step: 'Failed',
+                terminate: false,
+                errorMessage: 'Sub-agent name is required',
+                previousPayload: previousDecision?.newPayload,
+                newPayload: previousDecision?.newPayload
+            };
+        }
+        const childAgents = aiengine_1.AIEngine.Instance.Agents.filter(a => a.ParentID === params.agent.ID &&
+            a.Status === 'Active');
+        const childAgent = childAgents.find(a => a.Name.trim().toLowerCase() === name.trim().toLowerCase());
+        if (childAgent) {
+            return await this.executeChildSubAgentStep(params, previousDecision);
+        }
+        const activeRelationships = aiengine_1.AIEngine.Instance.AgentRelationships.filter(ar => ar.AgentID === params.agent.ID &&
+            ar.Status === 'Active');
+        for (const relationship of activeRelationships) {
+            const relatedAgent = aiengine_1.AIEngine.Instance.Agents.find(a => a.ID === relationship.SubAgentID &&
+                a.Status === 'Active');
+            if (relatedAgent && relatedAgent.Name.trim().toLowerCase() === name.trim().toLowerCase()) {
+                return await this.executeRelatedSubAgentStep(params, previousDecision, relatedAgent, relationship);
+            }
+        }
+        this.logError(`Sub-agent '${name}' not found or not active for agent '${params.agent.Name}'`, {
+            agent: params.agent,
+            category: 'SubAgentExecution'
+        });
+        return {
+            step: 'Retry',
+            terminate: false,
+            errorMessage: `Sub-agent '${name}' not found or not active`,
+            previousPayload: previousDecision?.newPayload,
+            newPayload: previousDecision?.newPayload
+        };
+    }
+    async executeRelatedSubAgentStep(params, previousDecision, subAgentEntity, relationship) {
+        const subAgentRequest = previousDecision.subAgent;
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Cancelled before related sub-agent execution');
+        }
+        params.onProgress?.({
+            step: 'subagent_execution',
+            percentage: 60,
+            message: this.formatHierarchicalMessage(`Delegating to ${subAgentRequest.name} agent`),
+            metadata: {
+                agentName: params.agent.Name,
+                subAgentName: subAgentRequest.name,
+                reason: subAgentRequest.message,
+                relationshipType: 'related'
+            }
+        });
+        params.conversationMessages.push({
+            role: 'assistant',
+            content: `I'm delegating this task to the "${subAgentRequest.name}" agent.\n\nReason: ${subAgentRequest.message}`
+        });
+        const inputData = {
+            agentName: params.agent.Name,
+            subAgentName: subAgentRequest.name,
+            message: subAgentRequest.message,
+            terminateAfter: subAgentRequest.terminateAfter,
+            conversationMessages: params.conversationMessages,
+            parentAgentHierarchy: this._agentHierarchy,
+            relationshipType: 'related'
+        };
+        const stepEntity = await this.createStepEntity('Sub-Agent', `Execute Related Sub-Agent: ${subAgentRequest.name}`, params.contextUser, subAgentEntity.ID, inputData, undefined, previousDecision.newPayload);
+        this.incrementExecutionCount(subAgentEntity.ID);
+        try {
+            stepEntity.PayloadAtStart = JSON.stringify(previousDecision.newPayload);
+            let initialSubAgentPayload = undefined;
+            if (relationship.SubAgentInputMapping) {
+                const mapped = this.applySubAgentInputMapping(previousDecision.newPayload, relationship.SubAgentInputMapping);
+                if (mapped && Object.keys(mapped).length > 0) {
+                    initialSubAgentPayload = mapped;
+                    if (params.verbose === true || (0, core_1.IsVerboseLoggingEnabled)()) {
+                        (0, core_1.LogStatus)(`Related sub-agent '${subAgentRequest.name}' receiving mapped payload: ${JSON.stringify(Object.keys(mapped))}`);
+                    }
+                }
+            }
+            let contextPaths = [];
+            if (relationship.SubAgentContextPaths) {
+                try {
+                    contextPaths = JSON.parse(relationship.SubAgentContextPaths);
+                }
+                catch (parseError) {
+                    (0, core_1.LogError)(`Failed to parse SubAgentContextPaths for sub-agent ${subAgentRequest.name}: ${parseError.message}`);
+                }
+            }
+            const contextMessage = this.prepareRelatedSubAgentContextMessage(previousDecision.newPayload, contextPaths);
+            if (contextMessage && (params.verbose === true || (0, core_1.IsVerboseLoggingEnabled)())) {
+                (0, core_1.LogStatus)(`Related sub-agent '${subAgentRequest.name}' receiving context from paths: ${contextPaths.join(', ')}`);
+            }
+            const subAgentResult = await this.ExecuteSubAgent(params, subAgentRequest, subAgentEntity, stepEntity, initialSubAgentPayload, contextMessage);
+            let mergedPayload = previousDecision.newPayload;
+            let currentStepPayloadChangeResult = undefined;
+            if (subAgentResult.success && relationship.SubAgentOutputMapping) {
+                const payloadChange = this.applySubAgentOutputMapping(subAgentResult.payload, previousDecision.newPayload, relationship.SubAgentOutputMapping);
+                if (payloadChange && payloadChange.updateElements) {
+                    const mergeResult = this._payloadManager.applyAgentChangeRequest(previousDecision.newPayload, payloadChange, {
+                        validateChanges: true,
+                        logChanges: true,
+                        analyzeChanges: true,
+                        generateDiff: true,
+                        agentName: `${subAgentRequest.name} (related agent mapping)`,
+                        verbose: params.verbose === true || (0, core_1.IsVerboseLoggingEnabled)()
+                    });
+                    mergedPayload = mergeResult.result;
+                    currentStepPayloadChangeResult = this.buildPayloadChangeResultSummary(mergeResult);
+                    if (mergeResult.warnings.length > 0 && (params.verbose === true || (0, core_1.IsVerboseLoggingEnabled)())) {
+                        (0, core_1.LogStatus)(`Related sub-agent mapping warnings: ${mergeResult.warnings.join('; ')}`);
+                    }
+                }
+            }
+            const shouldTerminate = subAgentRequest.terminateAfter === true;
+            const outputData = {
+                subAgentResult: {
+                    success: subAgentResult.success,
+                    finalStep: subAgentResult.agentRun?.FinalStep,
+                    errorMessage: subAgentResult.agentRun?.ErrorMessage,
+                    stepCount: subAgentResult.agentRun?.Steps?.length || 0,
+                    hasMergedPayload: !!(relationship.SubAgentOutputMapping && mergedPayload !== previousDecision.newPayload)
+                },
+                shouldTerminate: shouldTerminate,
+                nextStep: shouldTerminate ? 'success' : 'retry',
+                ...(currentStepPayloadChangeResult && {
+                    payloadChangeResult: currentStepPayloadChangeResult
+                })
+            };
+            if (stepEntity) {
+                stepEntity.PayloadAtEnd = JSON.stringify(mergedPayload);
+            }
+            await this.finalizeStepEntity(stepEntity, subAgentResult.success, subAgentResult.agentRun?.ErrorMessage, outputData);
+            if (subAgentResult.agentRun?.FinalStep === 'Chat') {
+                return {
+                    step: 'Chat',
+                    terminate: true,
+                    message: subAgentResult.agentRun?.Message || null,
+                    previousPayload: previousDecision?.newPayload,
+                    newPayload: previousDecision?.newPayload
+                };
+            }
+            const subAgentSummary = {
+                agentName: params.agent.Name,
+                subAgentName: subAgentRequest.name,
+                success: subAgentResult.success,
+                payload: subAgentResult.payload,
+                errorMessage: subAgentResult.agentRun?.ErrorMessage
+            };
+            params.conversationMessages.push({
+                role: 'user',
+                content: `Related sub-agent "${subAgentRequest.name}" completed:\n${JSON.stringify(subAgentSummary, null, 2)}`
+            });
+            if (this._agentRun) {
+                this._agentRun.FinalPayloadObject = mergedPayload;
+            }
+            return {
+                ...subAgentResult,
+                step: subAgentResult.success ? 'Success' : 'Failed',
+                terminate: shouldTerminate,
+                previousPayload: previousDecision?.newPayload,
+                newPayload: mergedPayload
+            };
+        }
+        catch (error) {
+            const payload = stepEntity.PayloadAtEnd ? JSON.parse(stepEntity.PayloadAtEnd) : previousDecision?.newPayload || params.payload;
+            stepEntity.PayloadAtEnd = payload ? JSON.stringify(payload) : null;
+            await this.finalizeStepEntity(stepEntity, false, error.message);
+            return {
+                errorMessage: `Related sub-agent execution failed: ${error.message}`,
+                step: 'Failed',
+                terminate: false,
+                previousPayload: payload,
+                newPayload: payload
+            };
+        }
+    }
+    applySubAgentOutputMapping(subAgentResult, _parentPayload, mappingConfig) {
+        try {
+            const mapping = JSON.parse(mappingConfig);
+            const updateObj = {};
+            for (const [subAgentPath, parentPath] of Object.entries(mapping)) {
+                let value;
+                if (subAgentPath === '*') {
+                    value = subAgentResult;
+                }
+                else {
+                    value = this.getValueFromPath(subAgentResult, subAgentPath);
+                }
+                if (value !== undefined) {
+                    const pathParts = parentPath.split('.');
+                    let current = updateObj;
+                    for (let i = 0; i < pathParts.length - 1; i++) {
+                        const part = pathParts[i];
+                        if (!(part in current)) {
+                            current[part] = {};
+                        }
+                        current = current[part];
+                    }
+                    current[pathParts[pathParts.length - 1]] = value;
+                }
+            }
+            if (Object.keys(updateObj).length === 0) {
+                return null;
+            }
+            return {
+                updateElements: updateObj
+            };
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Failed to parse SubAgentOutputMapping: ${error.message}`);
+            return null;
+        }
+    }
+    applySubAgentInputMapping(parentPayload, mappingConfig) {
+        try {
+            const mapping = JSON.parse(mappingConfig);
+            const subAgentPayload = {};
+            for (const [parentPath, subAgentPath] of Object.entries(mapping)) {
+                let value;
+                if (parentPath === '*') {
+                    value = parentPayload;
+                }
+                else {
+                    value = this.getValueFromPath(parentPayload, parentPath);
+                }
+                if (value !== undefined) {
+                    const pathParts = subAgentPath.split('.');
+                    let current = subAgentPayload;
+                    for (let i = 0; i < pathParts.length - 1; i++) {
+                        const part = pathParts[i];
+                        if (!(part in current)) {
+                            current[part] = {};
+                        }
+                        current = current[part];
+                    }
+                    current[pathParts[pathParts.length - 1]] = value;
+                }
+            }
+            if (Object.keys(subAgentPayload).length === 0) {
+                return null;
+            }
+            return subAgentPayload;
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Failed to parse SubAgentInputMapping: ${error.message}`);
+            return null;
+        }
+    }
+    prepareRelatedSubAgentContextMessage(parentPayload, contextPaths) {
+        if (!contextPaths || contextPaths.length === 0) {
+            return null;
+        }
+        if (contextPaths.includes('*')) {
+            return {
+                role: 'user',
+                content: `Parent Agent Context:\n\n${JSON.stringify(parentPayload, null, 2)}`
+            };
+        }
+        const contextData = {};
+        for (const path of contextPaths) {
+            const value = this.getValueFromPath(parentPayload, path);
+            if (value !== undefined) {
+                contextData[path] = value;
+            }
+        }
+        if (Object.keys(contextData).length === 0) {
+            return null;
+        }
+        const contextLines = Object.entries(contextData).map(([key, value]) => {
+            const valueStr = typeof value === 'object'
+                ? JSON.stringify(value, null, 2)
+                : String(value);
+            return `${key}:\n${valueStr}`;
+        });
+        return {
+            role: 'user',
+            content: `Parent Agent Context:\n\n${contextLines.join('\n\n')}`
+        };
+    }
+    getValueFromPath(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (!part)
+                continue;
+            const arrayMatch = part.match(/^([^[]+)\[(\d+)\]$/);
+            if (arrayMatch) {
+                const arrayName = arrayMatch[1];
+                const index = parseInt(arrayMatch[2], 10);
+                if (current && typeof current === 'object' && arrayName in current) {
+                    current = current[arrayName];
+                    if (Array.isArray(current) && index >= 0 && index < current.length) {
+                        current = current[index];
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                else {
+                    return undefined;
+                }
+            }
+            else {
+                if (current && typeof current === 'object' && part in current) {
+                    current = current[part];
+                }
+                else {
+                    return undefined;
+                }
+            }
+        }
+        return current;
+    }
     async executeActionsStep(params, config, previousDecision) {
         try {
             const currentPayload = previousDecision?.newPayload || previousDecision?.previousPayload || params.payload;
@@ -1781,35 +2302,34 @@ class BaseAgent {
             let progressMessage;
             if (actions.length === 1) {
                 const aa = actions[0];
-                progressMessage = `Executing action: **${aa.name}**`;
+                progressMessage = `Executing **${aa.name}** action`;
                 if (aa.params && Object.keys(aa.params).length > 0) {
                     const paramsList = Object.entries(aa.params)
                         .map(([key, value]) => {
-                        const displayValue = typeof value === 'object'
-                            ? JSON.stringify(value, null, 2)
-                            : String(value);
-                        return `  - \`${key}\`: ${displayValue}`;
+                        const displayValue = this.formatParamValueForMessage(value);
+                        return `• **${key}**: ${displayValue}`;
                     })
                         .join('\n');
-                    progressMessage += `\n${paramsList}`;
+                    progressMessage += ` with parameters:\n${paramsList}`;
+                }
+                else {
+                    progressMessage += '.';
                 }
             }
             else {
-                progressMessage = `Executing ${actions.length} actions:`;
-                actions.forEach(aa => {
-                    progressMessage += `\n\n• **${aa.name}**`;
+                progressMessage = `Executing **${actions.length} actions** in parallel:\n\n` + actions.map((aa, index) => {
+                    let actionText = `${index + 1}. **${aa.name}**`;
                     if (aa.params && Object.keys(aa.params).length > 0) {
                         const paramsList = Object.entries(aa.params)
                             .map(([key, value]) => {
-                            const displayValue = typeof value === 'object'
-                                ? JSON.stringify(value, null, 2)
-                                : String(value);
-                            return `  - \`${key}\`: ${displayValue}`;
+                            const displayValue = this.formatParamValueForMessage(value);
+                            return `   • **${key}**: ${displayValue}`;
                         })
                             .join('\n');
-                        progressMessage += `\n${paramsList}`;
+                        actionText += `\n${paramsList}`;
                     }
-                });
+                    return actionText;
+                }).join('\n\n');
             }
             params.onProgress?.({
                 step: 'action_execution',
@@ -1821,9 +2341,38 @@ class BaseAgent {
                 },
                 displayMode: 'live'
             });
-            const actionMessage = actions.length === 1
-                ? `I'm executing the "${actions[0].name}" action...`
-                : `I'm executing ${actions.length} actions to gather the information needed:\n${actions.map(a => `• ${a.name}`).join('\n')}`;
+            let actionMessage;
+            if (actions.length === 1) {
+                const aa = actions[0];
+                actionMessage = `I'm executing the **${aa.name}** action`;
+                if (aa.params && Object.keys(aa.params).length > 0) {
+                    const paramsList = Object.entries(aa.params)
+                        .map(([key, value]) => {
+                        const displayValue = this.formatParamValueForMessage(value);
+                        return `• **${key}**: ${displayValue}`;
+                    })
+                        .join('\n');
+                    actionMessage += ` with parameters:\n${paramsList}`;
+                }
+                else {
+                    actionMessage += '.';
+                }
+            }
+            else {
+                actionMessage = `I'm executing **${actions.length} actions** in parallel:\n\n` + actions.map((aa, index) => {
+                    let actionText = `${index + 1}. **${aa.name}**`;
+                    if (aa.params && Object.keys(aa.params).length > 0) {
+                        const paramsList = Object.entries(aa.params)
+                            .map(([key, value]) => {
+                            const displayValue = this.formatParamValueForMessage(value);
+                            return `   • **${key}**: ${displayValue}`;
+                        })
+                            .join('\n');
+                        actionText += `\n${paramsList}`;
+                    }
+                    return actionText;
+                }).join('\n\n');
+            }
             params.conversationMessages.push({
                 role: 'assistant',
                 content: actionMessage
@@ -1892,9 +2441,44 @@ class BaseAgent {
             });
             const failedActions = actionSummaries.filter(a => !a.success);
             const resultsMessage = (failedActions.length > 0 ? `${failedActions.length} of ${actionSummaries.length} failed:` : `Action results:`) + `\n${JSON.stringify(actionSummaries, null, 2)}`;
+            let metadata;
+            const agentActionConfigs = actionResults
+                .map(r => agentActions.find(aa => aa.ActionID === r.actionEntity.ID))
+                .filter(aa => aa != null);
+            if (agentActionConfigs.length > 0) {
+                let minExpirationTurns = null;
+                let expirationMode = 'None';
+                let compactMode;
+                let compactLength;
+                let compactPromptId;
+                for (const agentAction of agentActionConfigs) {
+                    if (agentAction.ResultExpirationTurns != null) {
+                        if (minExpirationTurns === null || agentAction.ResultExpirationTurns < minExpirationTurns) {
+                            minExpirationTurns = agentAction.ResultExpirationTurns;
+                            expirationMode = agentAction.ResultExpirationMode || 'None';
+                            compactMode = agentAction.CompactMode;
+                            compactLength = agentAction.CompactLength;
+                            compactPromptId = agentAction.CompactPromptID;
+                        }
+                    }
+                }
+                if (minExpirationTurns !== null && expirationMode !== 'None') {
+                    const currentStepCount = this._agentRun?.Steps?.length || 0;
+                    metadata = {
+                        turnAdded: currentStepCount,
+                        messageType: 'action-result',
+                        expirationTurns: minExpirationTurns,
+                        expirationMode: expirationMode,
+                        compactMode: compactMode,
+                        compactLength: compactLength,
+                        compactPromptId: compactPromptId
+                    };
+                }
+            }
             params.conversationMessages.push({
                 role: 'user',
-                content: resultsMessage
+                content: resultsMessage,
+                metadata: metadata
             });
             let finalPayload = currentPayload;
             try {
@@ -1960,6 +2544,7 @@ class BaseAgent {
             confidence: previousDecision.confidence,
             previousPayload: previousDecision.previousPayload,
             newPayload: previousDecision.newPayload || previousDecision.previousPayload,
+            suggestedResponses: previousDecision.suggestedResponses
         };
     }
     async createFailureResult(errorMessage, contextUser) {
@@ -2029,7 +2614,8 @@ class BaseAgent {
         return {
             success: finalStep.step === 'Success' || finalStep.step === 'Chat',
             payload,
-            agentRun: this._agentRun
+            agentRun: this._agentRun,
+            suggestedResponses: finalStep.suggestedResponses
         };
     }
     calculateTokenStats() {
@@ -2090,6 +2676,236 @@ class BaseAgent {
         }
         return violations;
     }
+    async pruneAndCompactExpiredMessages(params, currentTurn) {
+        const messagesToCompact = [];
+        const messagesToRemove = [];
+        for (let i = 0; i < params.conversationMessages.length; i++) {
+            const msg = params.conversationMessages[i];
+            if (!msg.metadata?.expirationTurns && msg.metadata?.expirationTurns !== 0) {
+                continue;
+            }
+            if (msg.metadata.expirationMode === 'None') {
+                continue;
+            }
+            const turnAdded = msg.metadata.turnAdded || 0;
+            const turnsAlive = currentTurn - turnAdded;
+            if (turnsAlive > msg.metadata.expirationTurns) {
+                msg.metadata.isExpired = true;
+                if (msg.metadata.expirationMode === 'Remove') {
+                    messagesToRemove.push(i);
+                    this.emitMessageLifecycleEvent({
+                        type: 'message-expired',
+                        turn: currentTurn,
+                        messageIndex: i,
+                        message: msg,
+                        reason: `Expired after ${turnsAlive} turns (limit: ${msg.metadata.expirationTurns})`
+                    });
+                }
+                else if (msg.metadata.expirationMode === 'Compact') {
+                    if (msg.metadata.compactMode) {
+                        messagesToCompact.push({
+                            index: i,
+                            message: msg,
+                            metadata: {
+                                compactMode: msg.metadata.compactMode,
+                                compactLength: msg.metadata.compactLength || 500,
+                                compactPromptId: msg.metadata.compactPromptId || '',
+                                originalLength: typeof msg.content === 'string'
+                                    ? msg.content.length
+                                    : JSON.stringify(msg.content).length
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        const preserveOriginal = params.messageExpirationOverride?.preserveOriginalContent !== false;
+        for (const item of messagesToCompact) {
+            const originalContent = item.message.content;
+            const compacted = await this.compactMessage(item.message, item.metadata, params);
+            const originalTokens = this.estimateTokens(originalContent);
+            const compactedTokens = this.estimateTokens(compacted);
+            const tokensSaved = originalTokens - compactedTokens;
+            params.conversationMessages[item.index] = {
+                ...item.message,
+                content: compacted,
+                metadata: {
+                    ...item.message.metadata,
+                    wasCompacted: true,
+                    originalContent: preserveOriginal ? originalContent : undefined,
+                    originalLength: item.metadata.originalLength,
+                    tokensSaved,
+                    canExpand: preserveOriginal
+                }
+            };
+            this.emitMessageLifecycleEvent({
+                type: 'message-compacted',
+                turn: currentTurn,
+                messageIndex: item.index,
+                message: params.conversationMessages[item.index],
+                reason: `Compacted using ${item.metadata.compactMode} (saved ${tokensSaved} tokens)`,
+                tokensSaved
+            });
+        }
+        for (let i = messagesToRemove.length - 1; i >= 0; i--) {
+            const index = messagesToRemove[i];
+            const removed = params.conversationMessages.splice(index, 1)[0];
+            this.emitMessageLifecycleEvent({
+                type: 'message-removed',
+                turn: currentTurn,
+                messageIndex: index,
+                message: removed,
+                reason: 'Removed due to expiration'
+            });
+        }
+        if (params.verbose && (messagesToCompact.length > 0 || messagesToRemove.length > 0)) {
+            const totalSaved = messagesToCompact.reduce((sum, item) => {
+                const msg = params.conversationMessages[item.index];
+                return sum + (msg.metadata?.tokensSaved || 0);
+            }, 0);
+            console.log(`[Turn ${currentTurn}] Message pruning: ` +
+                `${messagesToCompact.length} compacted (saved ~${totalSaved} tokens), ` +
+                `${messagesToRemove.length} removed`);
+        }
+    }
+    async createCompactionStep(prompt, message, params) {
+        if (!this._agentRun) {
+            throw new Error('Cannot create compaction step: agent run not initialized');
+        }
+        const md = new core_1.Metadata();
+        const step = await md.GetEntityObject('MJ: AI Agent Run Steps', params.contextUser);
+        step.NewRecord();
+        step.AgentRunID = this._agentRun.ID;
+        step.StepType = 'Prompt';
+        step.Status = 'Running';
+        step.InputData = JSON.stringify({
+            stepName: 'Message Compaction',
+            description: `Compacting message using AI Summary (${message.metadata?.messageType || 'unknown'} from turn ${message.metadata?.turnAdded || 0})`,
+            messageType: message.metadata?.messageType,
+            turnAdded: message.metadata?.turnAdded,
+            originalLength: message.metadata?.originalLength ||
+                (typeof message.content === 'string' ? message.content.length : JSON.stringify(message.content).length),
+            compactMode: 'AI Summary',
+            promptId: prompt.ID,
+            promptName: prompt.Name
+        });
+        await step.Save();
+        return step;
+    }
+    async updateCompactionStep(step, result, message, params) {
+        step.Status = result.success ? 'Completed' : 'Failed';
+        const promptTokens = result.promptTokens || 0;
+        const completionTokens = result.completionTokens || 0;
+        step.OutputData = JSON.stringify({
+            success: result.success,
+            summaryLength: result.result?.summary?.length || 0,
+            tokensSaved: message.metadata?.tokensSaved || 0,
+            promptTokens,
+            completionTokens,
+            totalTokens: promptTokens + completionTokens,
+            cost: result.cost
+        });
+        if (!result.success) {
+            step.ErrorMessage = result.errorMessage || 'AI Summary compaction failed';
+        }
+        await step.Save();
+    }
+    async compactMessage(message, metadata, params) {
+        const originalContent = typeof message.content === 'string'
+            ? message.content
+            : JSON.stringify(message.content);
+        switch (metadata.compactMode) {
+            case 'First N Chars': {
+                const length = metadata.compactLength;
+                if (originalContent.length <= length) {
+                    return originalContent;
+                }
+                const truncated = originalContent.substring(0, length);
+                return `${truncated}...\n\n[Compacted: showing first ${length} of ${originalContent.length} characters. Agent can request expansion if needed.]`;
+            }
+            case 'AI Summary': {
+                try {
+                    const promptId = metadata.compactPromptId || this.getSystemDefaultCompactPromptId();
+                    const prompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.ID === promptId);
+                    if (!prompt) {
+                        console.warn(`Compact prompt ${promptId} not found, falling back to First N Chars`);
+                        return this.compactMessage(message, { ...metadata, compactMode: 'First N Chars' }, params);
+                    }
+                    const step = await this.createCompactionStep(prompt, message, params);
+                    const promptParams = new ai_core_plus_1.AIPromptParams();
+                    promptParams.prompt = prompt;
+                    promptParams.data = {
+                        originalContent,
+                        originalLength: metadata.originalLength,
+                        targetLength: metadata.compactLength || 500,
+                        messageType: message.metadata?.messageType || 'unknown',
+                        turnAdded: message.metadata?.turnAdded || 0
+                    };
+                    promptParams.contextUser = params.contextUser;
+                    const runner = new ai_prompts_1.AIPromptRunner();
+                    const result = await runner.ExecutePrompt(promptParams);
+                    await this.updateCompactionStep(step, result, message, params);
+                    if (!result.success || !result.result?.summary) {
+                        console.warn('AI summary failed, falling back to First N Chars');
+                        return this.compactMessage(message, { ...metadata, compactMode: 'First N Chars' }, params);
+                    }
+                    return `[AI Summary of ${metadata.originalLength} chars. Agent can request full expansion if needed.]\n\n${result.result.summary}`;
+                }
+                catch (error) {
+                    console.error('Error during AI summary:', error);
+                    return this.compactMessage(message, { ...metadata, compactMode: 'First N Chars' }, params);
+                }
+            }
+            default:
+                return originalContent;
+        }
+    }
+    getSystemDefaultCompactPromptId() {
+        const prompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.Name === 'Compact Agent Message');
+        if (!prompt) {
+            console.warn('System default compact prompt not found. Ensure "Compact Agent Message" prompt exists.');
+            return '';
+        }
+        return prompt.ID;
+    }
+    estimateTokens(content) {
+        const text = typeof content === 'string'
+            ? content
+            : JSON.stringify(content);
+        return Math.ceil(text.length / 4);
+    }
+    emitMessageLifecycleEvent(event) {
+        if (this._messageLifecycleCallback) {
+            this._messageLifecycleCallback(event);
+        }
+    }
+    executeExpandMessageStep(request, params, currentTurn) {
+        const messageIndex = request.messageIndex;
+        const reason = request.expandReason;
+        if (messageIndex === undefined || messageIndex < 0 || messageIndex >= params.conversationMessages.length) {
+            console.warn(`Cannot expand message: index ${messageIndex} out of bounds`);
+            return;
+        }
+        const message = params.conversationMessages[messageIndex];
+        if (!message.metadata?.canExpand || !message.metadata?.originalContent) {
+            console.warn(`Cannot expand message at index ${messageIndex}: not expandable or no original content`);
+            return;
+        }
+        message.content = message.metadata.originalContent;
+        message.metadata.wasCompacted = false;
+        message.metadata.canExpand = false;
+        delete message.metadata.originalContent;
+        this.emitMessageLifecycleEvent({
+            type: 'message-expanded',
+            turn: currentTurn,
+            messageIndex,
+            message,
+            reason: reason || 'Agent requested expansion'
+        });
+        if (params.verbose) {
+            console.log(`[Turn ${currentTurn}] Expanded message at index ${messageIndex}`);
+        }
+    }
 }
 exports.BaseAgent = BaseAgent;
 BaseAgent.MAX_VALIDATION_RETRIES = 10;