@memberjunction/ai-agents 2.111.1 → 2.113.0

package/dist/base-agent.js

@@ -31,6 +31,7 @@ const global_1 = require("@memberjunction/global");
 const aiengine_1 = require("@memberjunction/aiengine");
 const actions_1 = require("@memberjunction/actions");
 const ai_engine_base_1 = require("@memberjunction/ai-engine-base");
+const agent_context_injector_1 = require("./agent-context-injector");
 const ai_core_plus_1 = require("@memberjunction/ai-core-plus");
 const AgentRunner_1 = require("./AgentRunner");
 const PayloadManager_1 = require("./PayloadManager");
@@ -51,7 +52,10 @@ class BaseAgent {
         this._subAgentRuns = [];
         this._payloadManager = new PayloadManager_1.PayloadManager();
         this._validationRetryCount = 0;
-        this._contextRecoveryAttempted = false;
+        this._contextRecoveryAttempts = 0;
+        this.MAX_RECOVERY_ATTEMPTS = 1;
+        this._memoryContext = '';
+        this._injectedMemory = { notes: [], examples: [] };
     }
     get AgentTypeState() {
         return this._agentTypeState;
@@ -208,7 +212,7 @@ class BaseAgent {
             await this.initializeAgentRun(wrappedParams);
             this._validationRetryCount = 0;
             this._generalValidationRetryCount = 0;
-            this._contextRecoveryAttempted = false;
+            this._contextRecoveryAttempts = 0;
             this._messageLifecycleCallback = params.onMessageLifecycle;
             await this.initializeEngines(params.contextUser);
             if (params.cancellationToken?.aborted) {
@@ -237,6 +241,13 @@ class BaseAgent {
             }
             await this.preloadAgentData(wrappedParams);
             await this.initializeAgentType(wrappedParams, config);
+            const userId = params.userId || params.contextUser?.ID;
+            const companyId = params.companyId;
+            const lastUserMessage = params.conversationMessages
+                .filter(m => m.role === 'user')
+                .pop();
+            const inputText = lastUserMessage?.content || '';
+            await this.InjectContextMemory(typeof inputText === 'string' ? inputText : '', params.agent, userId, companyId, params.contextUser, wrappedParams.conversationMessages);
             this.logStatus(`🚀 Executing agent '${params.agent.Name}' internal logic`, true, params);
             const executionResult = await this.executeAgentInternal(wrappedParams, config);
             wrappedParams.onProgress?.({
@@ -298,6 +309,50 @@ class BaseAgent {
         await aiengine_1.AIEngine.Instance.Config(false, contextUser);
         await actions_1.ActionEngineServer.Instance.Config(false, contextUser);
     }
+    async InjectContextMemory(input, agent, userId, companyId, contextUser, conversationMessages) {
+        if (!agent.InjectNotes && !agent.InjectExamples) {
+            return { notes: [], examples: [] };
+        }
+        const injector = new agent_context_injector_1.AgentContextInjector();
+        const notes = agent.InjectNotes
+            ? await injector.GetNotesForContext({
+                agentId: agent.ID,
+                userId,
+                companyId,
+                currentInput: input,
+                strategy: agent.NoteInjectionStrategy,
+                maxNotes: agent.MaxNotesToInject || 5,
+                contextUser: contextUser
+            })
+            : [];
+        const examples = agent.InjectExamples
+            ? await injector.GetExamplesForContext({
+                agentId: agent.ID,
+                userId,
+                companyId,
+                currentInput: input,
+                strategy: agent.ExampleInjectionStrategy,
+                maxExamples: agent.MaxExamplesToInject || 3,
+                contextUser: contextUser
+            })
+            : [];
+        if ((notes.length > 0 || examples.length > 0) && conversationMessages) {
+            const notesText = injector.FormatNotesForInjection(notes);
+            const examplesText = injector.FormatExamplesForInjection(examples);
+            this._memoryContext = '';
+            if (notesText)
+                this._memoryContext += notesText + '\n\n';
+            if (examplesText)
+                this._memoryContext += examplesText + '\n\n';
+            conversationMessages.unshift({
+                role: 'system',
+                content: this._memoryContext
+            });
+            this.logStatus(`💾 Injected ${notes.length} notes and ${examples.length} examples into conversation context`, true);
+        }
+        this._injectedMemory = { notes, examples };
+        return { notes, examples };
+    }
     async validateRunChain(lastRunId, contextUser) {
         const visitedRunIds = new Set();
         visitedRunIds.add(this._agentRun.ID);
@@ -1073,55 +1128,242 @@ class BaseAgent {
             originalLength
         };
     }
-    async attemptContextRecovery(params, payload, errorMessage) {
-        this.logStatus(`⚠️ Context length exceeded - attempting recovery by trimming conversation messages`, true, params);
-        const messages = params.conversationMessages;
+    recoveryStrategy_RemoveOldestActionResults(params, tokensToSave, currentStepCount, minAge = 5) {
+        let tokensSaved = 0;
+        const removedIndices = [];
+        const candidates = params.conversationMessages
+            .map((msg, index) => ({
+            message: msg,
+            index: index,
+            age: msg.metadata?.turnAdded
+                ? currentStepCount - msg.metadata.turnAdded
+                : 0,
+            tokens: this.estimateTokens(msg.content),
+            isActionResult: msg.metadata?.messageType === 'action-result'
+        }))
+            .filter(c => c.isActionResult && c.age >= minAge)
+            .sort((a, b) => b.age - a.age);
+        for (const candidate of candidates) {
+            if (tokensSaved >= tokensToSave)
+                break;
+            removedIndices.push(candidate.index);
+            tokensSaved += candidate.tokens;
+            this.logStatus(`Removing action-result from ${candidate.age} turns ago (${candidate.tokens} tokens)`, true, params);
+        }
+        removedIndices.sort((a, b) => b - a).forEach(index => {
+            const removed = params.conversationMessages.splice(index, 1)[0];
+            this.emitMessageLifecycleEvent({
+                type: 'message-removed',
+                turn: currentStepCount,
+                messageIndex: index,
+                message: removed,
+                reason: 'Context recovery - oldest action results',
+                tokensSaved: this.estimateTokens(removed.content)
+            });
+        });
+        return {
+            tokensSaved,
+            strategyName: `Removed ${removedIndices.length} old action-results (${minAge}+ turns)`
+        };
+    }
+    async recoveryStrategy_CompactOldActionResults(params, tokensToSave, currentStepCount, minAge = 3) {
+        let tokensSaved = 0;
+        let compactedCount = 0;
+        const candidates = params.conversationMessages
+            .map((msg, index) => ({
+            message: msg,
+            index: index,
+            age: msg.metadata?.turnAdded
+                ? currentStepCount - msg.metadata.turnAdded
+                : 0,
+            tokens: this.estimateTokens(msg.content),
+            isActionResult: msg.metadata?.messageType === 'action-result',
+            alreadyCompacted: msg.metadata?.wasCompacted === true
+        }))
+            .filter(c => c.isActionResult && c.age >= minAge && !c.alreadyCompacted)
+            .sort((a, b) => b.age - a.age);
+        for (const candidate of candidates) {
+            if (tokensSaved >= tokensToSave)
+                break;
+            const originalTokens = candidate.tokens;
+            const originalMessage = candidate.message;
+            const originalContent = typeof originalMessage.content === 'string'
+                ? originalMessage.content
+                : JSON.stringify(originalMessage.content);
+            const compactedContent = await this.compactMessage(originalMessage, {
+                compactMode: 'First N Chars',
+                compactLength: 500,
+                compactPromptId: '',
+                originalLength: originalContent.length
+            }, params);
+            const newTokens = this.estimateTokens(compactedContent);
+            const saved = originalTokens - newTokens;
+            if (saved > 0) {
+                params.conversationMessages[candidate.index] = {
+                    ...originalMessage,
+                    content: compactedContent,
+                    metadata: {
+                        ...originalMessage.metadata,
+                        wasCompacted: true,
+                        originalLength: originalContent.length,
+                        tokensSaved: saved
+                    }
+                };
+                tokensSaved += saved;
+                compactedCount++;
+                this.logStatus(`Compacted action-result from ${candidate.age} turns ago (saved ${saved} tokens)`, true, params);
+            }
+        }
+        return {
+            tokensSaved,
+            strategyName: `Compacted ${compactedCount} old action-results (${minAge}+ turns)`
+        };
+    }
+    async recoveryStrategy_CompactAllActionResults(params, tokensToSave) {
+        let tokensSaved = 0;
+        let compactedCount = 0;
+        const candidates = params.conversationMessages
+            .map((msg, index) => ({
+            message: msg,
+            index: index,
+            tokens: this.estimateTokens(msg.content),
+            isActionResult: msg.metadata?.messageType === 'action-result',
+            alreadyCompacted: msg.metadata?.wasCompacted === true
+        }))
+            .filter(c => c.isActionResult && !c.alreadyCompacted && c.tokens > 200)
+            .sort((a, b) => b.tokens - a.tokens);
+        for (const candidate of candidates) {
+            if (tokensSaved >= tokensToSave)
+                break;
+            const originalTokens = candidate.tokens;
+            const originalMessage = candidate.message;
+            const originalContent = typeof originalMessage.content === 'string'
+                ? originalMessage.content
+                : JSON.stringify(originalMessage.content);
+            const compactedContent = await this.compactMessage(originalMessage, {
+                compactMode: 'First N Chars',
+                compactLength: 200,
+                compactPromptId: '',
+                originalLength: originalContent.length
+            }, params);
+            const newTokens = this.estimateTokens(compactedContent);
+            const saved = originalTokens - newTokens;
+            if (saved > 0) {
+                params.conversationMessages[candidate.index] = {
+                    ...originalMessage,
+                    content: compactedContent,
+                    metadata: {
+                        ...originalMessage.metadata,
+                        wasCompacted: true,
+                        originalLength: originalContent.length,
+                        tokensSaved: saved
+                    }
+                };
+                tokensSaved += saved;
+                compactedCount++;
+            }
+        }
+        return {
+            tokensSaved,
+            strategyName: `Aggressively compacted ${compactedCount} action-results`
+        };
+    }
+    recoveryStrategy_TrimLastUserMessage(params, tokensToSave) {
         let lastUserMessageIndex = -1;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            if (messages[i].role === 'user') {
+        for (let i = params.conversationMessages.length - 1; i >= 0; i--) {
+            if (params.conversationMessages[i].role === 'user') {
                 lastUserMessageIndex = i;
                 break;
             }
         }
         if (lastUserMessageIndex === -1) {
-            this.logStatus(`❌ Context recovery failed: No trimmable user messages found`, true, params);
+            return { tokensSaved: 0, strategyName: 'No user message to trim' };
+        }
+        const lastUserMessage = params.conversationMessages[lastUserMessageIndex];
+        const originalTokens = this.estimateTokens(lastUserMessage.content);
+        const contentString = this.contentToString(lastUserMessage.content);
+        const targetChars = 1000;
+        if (contentString.length <= targetChars) {
+            return { tokensSaved: 0, strategyName: 'User message already short' };
+        }
+        const trimResult = this.smartTrimContent(contentString, targetChars);
+        const newContent = trimResult.trimmed +
+            '\n\n<CONTEXT_LIMIT_REACHED>\n' +
+            'Note: The conversation has exceeded the model\'s context window. ' +
+            'The remainder of your message was trimmed to fit within the limit. ' +
+            'The beginning of your request (shown above) has been preserved.\n' +
+            '</CONTEXT_LIMIT_REACHED>';
+        const newTokens = this.estimateTokens(newContent);
+        const saved = originalTokens - newTokens;
+        if (saved > 0) {
+            params.conversationMessages[lastUserMessageIndex] = {
+                ...lastUserMessage,
+                content: newContent
+            };
+        }
+        return {
+            tokensSaved: saved,
+            strategyName: 'Preserved beginning of user message with context limit marker'
+        };
+    }
+    async attemptContextRecovery(params, payload, errorMessage, modelSelectionInfo) {
+        this.logStatus(`⚠️ Context length exceeded - attempting recovery with multi-strategy approach`, true, params);
+        const modelLimit = this.getModelContextLimit(modelSelectionInfo);
+        const currentTokens = this.estimateConversationTokens(params.conversationMessages);
+        const tokensToSave = currentTokens - Math.floor(modelLimit * 0.9);
+        this.logStatus(`Need to save ~${tokensToSave} tokens (current: ${currentTokens}, limit: ${modelLimit})`, true, params);
+        if (tokensToSave <= 0) {
+            this.logStatus(`Already under context limit, retrying...`, true, params);
+            return {
+                step: 'Retry',
+                retryReason: 'Context recovery - already under limit',
+                retryInstructions: 'The context is now within limits.',
+                terminate: false,
+                previousPayload: payload,
+                newPayload: payload
+            };
+        }
+        const currentStepCount = this._agentRun?.Steps?.length || 0;
+        const strategies = [
+            () => this.recoveryStrategy_RemoveOldestActionResults(params, tokensToSave, currentStepCount, 5),
+            () => this.recoveryStrategy_CompactOldActionResults(params, tokensToSave, currentStepCount, 3),
+            () => this.recoveryStrategy_RemoveOldestActionResults(params, tokensToSave, currentStepCount, 2),
+            () => this.recoveryStrategy_CompactAllActionResults(params, tokensToSave),
+            () => Promise.resolve(this.recoveryStrategy_TrimLastUserMessage(params, tokensToSave))
+        ];
+        let tokensSaved = 0;
+        const strategiesUsed = [];
+        for (const strategy of strategies) {
+            const result = await strategy();
+            tokensSaved += result.tokensSaved;
+            if (result.tokensSaved > 0) {
+                strategiesUsed.push(result.strategyName);
+                this.logStatus(`${result.strategyName}: saved ${result.tokensSaved} tokens`, true, params);
+            }
+            if (tokensSaved >= tokensToSave) {
+                break;
+            }
+        }
+        if (tokensSaved < tokensToSave * 0.5) {
+            this.logStatus(`❌ Context recovery insufficient: only saved ${tokensSaved}/${tokensToSave} tokens`, true, params);
             return {
-                errorMessage: `Context overflow with no trimmable messages: ${errorMessage}`,
+                errorMessage: `Context recovery failed: only saved ${tokensSaved}/${tokensToSave} tokens. ${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.`
-        };
+        this.logStatus(`✅ Context recovery successful: saved ${tokensSaved} tokens using ${strategiesUsed.length} strategies`, true, params);
+        const strategyDescriptions = strategiesUsed.map((strategy, index) => `${index + 1}. ${strategy}`).join('\n');
         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.',
+            retryReason: `Context recovery successful - ${tokensSaved} tokens freed`,
+            retryInstructions: `The conversation exceeded the model's context limit (${modelLimit} tokens). I've applied the following context recovery strategies to free up ${tokensSaved} tokens:
+
+${strategyDescriptions}
+
+The context is now within limits. Please retry your request with the recovered context.`,
             terminate: false,
             previousPayload: payload,
             newPayload: payload
@@ -1236,18 +1478,61 @@ Please choose an alternative approach to complete your task.`
             throw new Error(`Error executing actions: ${error.message}`);
         }
     }
+    prepareSubAgentMessages(params, subAgentRequest, subAgent, contextMessage) {
+        const engine = aiengine_1.AIEngine.Instance;
+        let messages = [];
+        const relationship = engine.AgentRelationships.find(r => r.AgentID === params.agent.ID && r.SubAgentID === subAgent.ID);
+        let messageMode = relationship?.MessageMode || subAgent.MessageMode || 'None';
+        let maxMessages = relationship?.MaxMessages || subAgent.MaxMessages || null;
+        switch (messageMode) {
+            case 'None':
+                break;
+            case 'All':
+                messages = [...params.conversationMessages];
+                break;
+            case 'Latest':
+                if (maxMessages && maxMessages > 0) {
+                    messages = params.conversationMessages.slice(-maxMessages);
+                }
+                else {
+                    messages = [...params.conversationMessages];
+                }
+                break;
+            case 'Bookend':
+                if (maxMessages && maxMessages > 2 && params.conversationMessages.length > maxMessages) {
+                    const firstTwo = params.conversationMessages.slice(0, 2);
+                    const remaining = params.conversationMessages.slice(-(maxMessages - 2));
+                    const omittedCount = params.conversationMessages.length - maxMessages;
+                    messages = [
+                        ...firstTwo,
+                        {
+                            role: 'system',
+                            content: `[${omittedCount} messages omitted for context management]`
+                        },
+                        ...remaining
+                    ];
+                }
+                else {
+                    messages = [...params.conversationMessages];
+                }
+                break;
+            default:
+                break;
+        }
+        if (contextMessage) {
+            messages.push(contextMessage);
+        }
+        messages.push({
+            role: 'user',
+            content: subAgentRequest.message
+        });
+        return messages;
+    }
     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 = [];
-            if (contextMessage) {
-                subAgentMessages.push(contextMessage);
-            }
-            subAgentMessages.push({
-                role: 'user',
-                content: subAgentRequest.message
-            });
+            const subAgentMessages = this.prepareSubAgentMessages(params, subAgentRequest, subAgent, contextMessage);
             this.logStatus(`📨 Sub-agent message: "${subAgentRequest.message}"`, true, params);
             if (subAgentRequest.templateParameters) {
                 this.logStatus(`📎 Template parameters: ${JSON.stringify(subAgentRequest.templateParameters)}`, true, params);
@@ -1781,10 +2066,10 @@ Please choose an alternative approach to complete your task.`
                 await stepEntity.Save();
             };
             const promptResult = await this.executePrompt(promptParams);
-            const loopMsgIndex = params.conversationMessages.findIndex(m => m.metadata?._loopResults === true);
-            if (loopMsgIndex !== -1) {
-                params.conversationMessages.splice(loopMsgIndex, 1);
-            }
+            params.conversationMessages = params.conversationMessages.filter(m => {
+                const metadata = m.metadata;
+                return !metadata?._loopResults && !metadata?._subAgentResult;
+            });
             if (promptResult.promptRun?.ID) {
                 stepEntity.TargetLogID = promptResult.promptRun.ID;
                 stepEntity.PromptRun = promptResult.promptRun;
@@ -1794,10 +2079,10 @@ Please choose an alternative approach to complete your task.`
                 const isFatal = this.isFatalPromptError(promptResult);
                 const isContextOverflow = isFatal &&
                     promptResult.chatResult?.errorInfo?.errorType === 'ContextLengthExceeded';
-                if (isContextOverflow && !this._contextRecoveryAttempted) {
-                    this._contextRecoveryAttempted = true;
+                if (isContextOverflow && this._contextRecoveryAttempts < this.MAX_RECOVERY_ATTEMPTS) {
+                    this._contextRecoveryAttempts++;
                     this.logStatus(`⚠️ Context length exceeded - attempting recovery by trimming conversation`, true, params);
-                    return await this.attemptContextRecovery(params, payload, promptResult.errorMessage || 'Context length exceeded');
+                    return await this.attemptContextRecovery(params, payload, promptResult.errorMessage || 'Context length exceeded', promptResult.modelSelectionInfo);
                 }
                 this.logStatus(`❌ Prompt execution failed: ${promptResult.errorMessage} (fatal: ${isFatal})`, true, params);
                 return {
@@ -2084,7 +2369,13 @@ Please choose an alternative approach to complete your task.`
                 : `Sub-agent failed:\n${JSON.stringify(subAgentSummary, null, 2)}`;
             params.conversationMessages.push({
                 role: 'user',
-                content: resultMessage
+                content: resultMessage,
+                metadata: {
+                    _temporary: true,
+                    _subAgentResult: true,
+                    subAgentName: subAgentRequest.name,
+                    subAgentId: subAgentEntity.ID
+                }
             });
             if (stepEntity) {
                 stepEntity.PayloadAtEnd = JSON.stringify(mergedPayload);
@@ -3100,7 +3391,10 @@ Please choose an alternative approach to complete your task.`
             success: finalStep.step === 'Success' || finalStep.step === 'Chat',
             payload,
             agentRun: this._agentRun,
-            suggestedResponses: finalStep.suggestedResponses
+            suggestedResponses: finalStep.suggestedResponses,
+            memoryContext: this._injectedMemory.notes.length > 0 || this._injectedMemory.examples.length > 0
+                ? this._injectedMemory
+                : undefined
         };
     }
     calculateTokenStats() {
@@ -3353,11 +3647,65 @@ Please choose an alternative approach to complete your task.`
         }
         return prompt.ID;
     }
-    estimateTokens(content) {
+    estimateTokens(content, modelName) {
         const text = typeof content === 'string'
             ? content
             : JSON.stringify(content);
-        return Math.ceil(text.length / 4);
+        return this.heuristicTokenCount(text);
+    }
+    heuristicTokenCount(text) {
+        const charCount = text.length;
+        const structuralChars = (text.match(/[\{\}\[\],:]/g) || []).length;
+        const whitespaceChars = (text.match(/\s/g) || []).length;
+        const effectiveChars = charCount - (whitespaceChars * 0.5);
+        const baseTokens = effectiveChars / 4;
+        const structuralTokens = structuralChars * 0.05;
+        return Math.ceil(baseTokens + structuralTokens);
+    }
+    getModelContextLimit(modelSelectionInfo) {
+        const DEFAULT_LIMIT = 8000;
+        if (!modelSelectionInfo) {
+            this.logStatus(`No model selection info available, using default limit: ${DEFAULT_LIMIT}`, true);
+            return DEFAULT_LIMIT;
+        }
+        try {
+            const modelSelected = modelSelectionInfo.modelSelected;
+            const vendorSelected = modelSelectionInfo.vendorSelected;
+            if (!modelSelected) {
+                this.logStatus(`No model selected in model selection info, using default limit: ${DEFAULT_LIMIT}`, true);
+                return DEFAULT_LIMIT;
+            }
+            if (!vendorSelected) {
+                this.logStatus(`No vendor selected, using default limit: ${DEFAULT_LIMIT}`, true);
+                return DEFAULT_LIMIT;
+            }
+            const modelVendors = modelSelected.ModelVendors;
+            if (!modelVendors || modelVendors.length === 0) {
+                this.logStatus(`No ModelVendors array found on model, using default limit: ${DEFAULT_LIMIT}`, true);
+                return DEFAULT_LIMIT;
+            }
+            const vendorEntry = modelVendors.find((mv) => mv.VendorID === vendorSelected.ID);
+            if (!vendorEntry) {
+                this.logStatus(`No matching vendor entry found in ModelVendors, using default limit: ${DEFAULT_LIMIT}`, true);
+                return DEFAULT_LIMIT;
+            }
+            const maxInputTokens = vendorEntry.MaxInputTokens;
+            if (!maxInputTokens || maxInputTokens <= 0) {
+                this.logStatus(`MaxInputTokens not set or invalid on vendor entry, using default limit: ${DEFAULT_LIMIT}`, true);
+                return DEFAULT_LIMIT;
+            }
+            this.logStatus(`Using vendor-specific MaxInputTokens: ${maxInputTokens} (Model: ${modelSelected.Name}, Vendor: ${vendorSelected.Name})`, true);
+            return maxInputTokens;
+        }
+        catch (error) {
+            this.logStatus(`Error extracting model context limit: ${error}, using default limit: ${DEFAULT_LIMIT}`, true);
+            return DEFAULT_LIMIT;
+        }
+    }
+    estimateConversationTokens(messages) {
+        return messages.reduce((total, msg) => {
+            return total + this.estimateTokens(msg.content);
+        }, 0);
     }
     emitMessageLifecycleEvent(event) {
         if (this._messageLifecycleCallback) {