Investigate and apply a change to when the librechat gets

api/app/clients/BaseClient.js

@@ -371,6 +371,47 @@ class BaseClient {
     }, '');
   }
 
+  /**
+   * Assigns priority scores to messages based on content type and recency
+   * @param {TMessage[]} messages - Array of messages
+   * @returns {Array<{message: TMessage, priority: number, index: number}>}
+   */
+  assignMessagePriorities(messages) {
+    return messages.map((message, index) => {
+      let priority = 1.0; // Base priority
+
+      // Recency bonus (more recent = higher priority)
+      // Note: messages are ordered oldest to newest, so higher index = more recent
+      const recencyFactor = index / Math.max(messages.length - 1, 1);
+      priority += recencyFactor * 0.3;
+
+      // Check for tool calls
+      if (message.content && Array.isArray(message.content)) {
+        const hasToolCalls = message.content.some((item) => item.type === 'tool_call');
+        const hasMCPToolCalls = message.content.some(
+          (item) =>
+            item.type === 'tool_call' &&
+            item.tool_call?.name?.includes?.(Constants.mcp_delimiter),
+        );
+
+        if (hasToolCalls) {
+          priority += 0.5; // Tool calls are important
+        }
+
+        if (hasMCPToolCalls) {
+          priority += 0.3; // MCP tool calls are extra important
+        }
+      }
+
+      // User messages slightly higher priority than assistant
+      if (message.role === 'user') {
+        priority += 0.2;
+      }
+
+      return { message, priority, index };
+    });
+  }
+
   /**
    * This method processes an array of messages and returns a context of messages that fit within a specified token limit.
    * It iterates over the messages from newest to oldest, adding them to the context until the token limit is reached.
@@ -395,42 +436,66 @@ class BaseClient {
     // start with 3 tokens for the label after all messages have been counted.
     let currentTokenCount = 3;
     const instructionsTokenCount = instructions?.tokenCount ?? 0;
-    let remainingContextTokens =
+    const maxTokensForContext =
       (maxContextTokens ?? this.maxContextTokens) - instructionsTokenCount;
-    const messages = [..._messages];
-
-    const context = [];
 
-    if (currentTokenCount < remainingContextTokens) {
-      while (messages.length > 0 && currentTokenCount < remainingContextTokens) {
-        if (messages.length === 1 && instructions) {
-          break;
-        }
-        const poppedMessage = messages.pop();
-        const { tokenCount } = poppedMessage;
-
-        if (poppedMessage && currentTokenCount + tokenCount <= remainingContextTokens) {
-          context.push(poppedMessage);
-          currentTokenCount += tokenCount;
-        } else {
-          messages.push(poppedMessage);
-          break;
-        }
+    // Combine messages with instructions if instructions exist
+    const orderedMessages = instructions
+      ? this.addInstructions(_messages, instructions)
+      : [..._messages];
+
+    // Assign priorities to messages (excluding instructions from priority calculation)
+    // Map original indices when instructions are present
+    const messagesToPrioritize = instructions ? orderedMessages.slice(1) : orderedMessages;
+    const prioritizedMessages = this.assignMessagePriorities(messagesToPrioritize).map((item) => ({
+      ...item,
+      originalIndex: instructions ? item.index + 1 : item.index, // Adjust index if instructions were added
+    }));
+
+    // Sort by priority (descending) but keep track of original order
+    const sortedByPriority = [...prioritizedMessages].sort((a, b) => b.priority - a.priority);
+
+    const selectedMessages = [];
+    const selectedOriginalIndices = new Set();
+
+    // Select messages based on priority until we hit token limit
+    for (const { message, originalIndex } of sortedByPriority) {
+      const tokenCount = message.tokenCount || 0;
+      if (currentTokenCount + tokenCount <= maxTokensForContext) {
+        selectedMessages.push({ message, originalIndex });
+        selectedOriginalIndices.add(originalIndex);
+        currentTokenCount += tokenCount;
       }
     }
 
+    // Re-sort by original order
+    selectedMessages.sort((a, b) => a.originalIndex - b.originalIndex);
+
+    const context = selectedMessages.map(({ message }) => message);
+    const messagesToRefine = prioritizedMessages
+      .filter(({ originalIndex }) => !selectedOriginalIndices.has(originalIndex))
+      .map(({ message }) => message);
+
+    // Add instructions back to context if they exist
     if (instructions) {
-      context.push(_messages[0]);
-      messages.shift();
+      context.unshift(instructions);
     }
 
-    const prunedMemory = messages;
-    remainingContextTokens -= currentTokenCount;
+    const remainingContextTokens = maxTokensForContext - currentTokenCount;
+
+    logger.debug('[BaseClient] Priority-based context selection:', {
+      total: _messages.length,
+      selected: context.length - (instructions ? 1 : 0),
+      refined: messagesToRefine.length,
+      tokenCount: currentTokenCount,
+      maxTokens: maxTokensForContext,
+      instructionsTokens: instructionsTokenCount,
+    });
 
     return {
-      context: context.reverse(),
+      context,
       remainingContextTokens,
-      messagesToRefine: prunedMemory,
+      messagesToRefine,
     };
   }
 
@@ -456,14 +521,25 @@ class BaseClient {
     }
 
     if (this.clientName === EModelEndpoint.agents) {
+      const hasMCPTools = this.options?.agent?.tools?.some(tool =>
+        tool.name?.includes?.(Constants.mcp_delimiter)
+      );
+
       const { dbMessages, editedIndices } = truncateToolCallOutputs(
         orderedMessages,
         this.maxContextTokens,
         this.getTokenCountForMessage.bind(this),
+        {
+          threshold: 0.75,
+          mcpPriorityBoost: hasMCPTools
+        }
       );
 
       if (editedIndices.length > 0) {
-        logger.debug('[BaseClient] Truncated tool call outputs:', editedIndices);
+        logger.debug('[BaseClient] Truncated tool call outputs:', {
+          indices: editedIndices,
+          stats
+        });
         for (const index of editedIndices) {
           formattedMessages[index].content = dbMessages[index].content;
         }

api/app/clients/memory/summaryBuffer.js

@@ -22,11 +22,45 @@ const summaryBuffer = async ({
   previous_summary = '',
   prompt = SUMMARY_PROMPT,
   signal,
+  preserveToolCalls = false,
 }) => {
   if (previous_summary) {
     logger.debug('[summaryBuffer]', { previous_summary });
   }
 
+  let toolCallSummary = '';
+  if(preserveToolCalls) {
+    const Constants = require('librechat-data-provider').Constants;
+    const toolCalls = context
+      .filter(msg => msg.tool_calls || msg.content?.some?.(c => c,type ===
+      'tool_call'))
+      .map(msg => {
+        const calls = msg.tool_calls ||
+          msg.content?.filter?.(c => c.type === 'tool_call') || [];
+
+        return calls.map(call => {
+          const isMCP = call.name?.includes?.(Constants.mcp_delimiter);
+          return {
+            name: call.name,
+            isMCP,
+            input: call.input,
+            output: call.output ?
+              (typeof call.output === 'string' ? call.output.slice(0, 200) :
+                JSON.stringify(call.output).slice(0, 200)) : null
+          };
+        });
+      })
+      .flat()
+      .filter(Boolean);
+
+    if(toolCalls.length > 0) {
+      toolCallSummary = '\n\nTool calls in this conversation:\n' +
+        toolCalls.map(tc =>
+          `-${tc.name}${tc.isMCP ? ' (MCP)' : ''}: ${tc.output || 'pending'}`
+        ).join('\n');
+    }
+  }
+
   const formattedMessages = formatLangChainMessages(context, formatOptions);
   const memoryOptions = {
     llm,
@@ -60,7 +94,9 @@ const summaryBuffer = async ({
     logger.debug('[summaryBuffer]', { summary: predictSummary });
   }
 
-  return { role: 'system', content: predictSummary };
+  const finalSummary = predictSummary + toolCallSummary;
+
+  return { role: 'system', content: finalSummary };
 };
 
 module.exports = { createSummaryBufferMemory, summaryBuffer };