@librechat/agents 2.3.0 → 2.3.2

package/src/messages/prune.ts

@@ -1,6 +1,8 @@
-import { AIMessage } from '@langchain/core/messages';
-import type { BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import { concat } from '@langchain/core/utils/stream';
+import { AIMessage, BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { ThinkingContentText, MessageContentComplex } from '@/types/stream';
 import type { TokenCounter } from '@/types/run';
+import { ContentTypes } from '@/common';
 export type PruneMessagesFactoryParams = {
   maxTokens: number;
   startIndex: number;
@@ -11,20 +13,25 @@ export type PruneMessagesFactoryParams = {
 export type PruneMessagesParams = {
   messages: BaseMessage[];
   usageMetadata?: Partial<UsageMetadata>;
-  startOnMessageType?: ReturnType<BaseMessage['getType']>;
+  startType?: ReturnType<BaseMessage['getType']>;
+}
+
+function isIndexInContext(arrayA: BaseMessage[], arrayB: BaseMessage[], targetIndex: number): boolean {
+  const startingIndexInA = arrayA.length - arrayB.length;
+  return targetIndex >= startingIndexInA;
 }
 
 /**
  * Calculates the total tokens from a single usage object
- * 
+ *
  * @param usage The usage metadata object containing token information
  * @returns An object containing the total input and output tokens
  */
-function calculateTotalTokens(usage: Partial<UsageMetadata>): UsageMetadata {
+export function calculateTotalTokens(usage: Partial<UsageMetadata>): UsageMetadata {
   const baseInputTokens = Number(usage.input_tokens) || 0;
   const cacheCreation = Number(usage.input_token_details?.cache_creation) || 0;
   const cacheRead = Number(usage.input_token_details?.cache_read) || 0;
-  
+
   const totalInputTokens = baseInputTokens + cacheCreation + cacheRead;
   const totalOutputTokens = Number(usage.output_tokens) || 0;
 
@@ -38,273 +45,222 @@ function calculateTotalTokens(usage: Partial<UsageMetadata>): UsageMetadata {
 /**
  * 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.
- * 
+ *
  * @param options Configuration options for processing messages
  * @returns Object containing the message context, remaining tokens, messages not included, and summary index
  */
-function getMessagesWithinTokenLimit({
+export function getMessagesWithinTokenLimit({
   messages: _messages,
   maxContextTokens,
   indexTokenCountMap,
-  startOnMessageType,
+  startType: _startType,
   thinkingEnabled,
+  /** We may need to use this when recalculating */
   tokenCounter,
 }: {
   messages: BaseMessage[];
   maxContextTokens: number;
-  indexTokenCountMap: Record<string, number>;
-  startOnMessageType?: string;
+  indexTokenCountMap: Record<string, number | undefined>;
+  tokenCounter: TokenCounter;
+  startType?: string;
   thinkingEnabled?: boolean;
-  tokenCounter?: TokenCounter;
 }): {
   context: BaseMessage[];
   remainingContextTokens: number;
   messagesToRefine: BaseMessage[];
-  summaryIndex: number;
 } {
   // Every reply is primed with <|start|>assistant<|message|>, so we
   // start with 3 tokens for the label after all messages have been counted.
-  let summaryIndex = -1;
   let currentTokenCount = 3;
-  const instructions = _messages?.[0]?.getType() === 'system' ? _messages[0] : undefined;
-  const instructionsTokenCount = instructions != null ? indexTokenCountMap[0] : 0;
-  let remainingContextTokens = maxContextTokens - instructionsTokenCount;
+  const instructions = _messages[0]?.getType() === 'system' ? _messages[0] : undefined;
+  const instructionsTokenCount = instructions != null ? indexTokenCountMap[0] ?? 0 : 0;
+  const initialContextTokens = maxContextTokens - instructionsTokenCount;
+  let remainingContextTokens = initialContextTokens;
+  let startType = _startType;
+  const originalLength = _messages.length;
   const messages = [..._messages];
+  /**
+   * IMPORTANT: this context array gets reversed at the end, since the latest messages get pushed first.
+   *
+   * This may be confusing to read, but it is done to ensure the context is in the correct order for the model.
+   * */
   let context: BaseMessage[] = [];
 
+  let thinkingStartIndex = -1;
+  let thinkingEndIndex = -1;
+  let thinkingBlock: ThinkingContentText | undefined;
+  const endIndex = instructions != null ? 1 : 0;
+  const prunedMemory: BaseMessage[] = [];
+
   if (currentTokenCount < remainingContextTokens) {
     let currentIndex = messages.length;
-    while (messages.length > 0 && currentTokenCount < remainingContextTokens && currentIndex > 1) {
+    while (messages.length > 0 && currentTokenCount < remainingContextTokens && currentIndex > endIndex) {
       currentIndex--;
       if (messages.length === 1 && instructions) {
         break;
       }
       const poppedMessage = messages.pop();
       if (!poppedMessage) continue;
-      
-      const tokenCount = indexTokenCountMap[currentIndex] || 0;
+      const messageType = poppedMessage.getType();
+      if (thinkingEnabled === true && thinkingEndIndex === -1 && (currentIndex === (originalLength - 1)) && (messageType === 'ai' || messageType === 'tool')) {
+        thinkingEndIndex = currentIndex;
+      }
+      if (thinkingEndIndex > -1 && !thinkingBlock  && thinkingStartIndex < 0 && messageType === 'ai' && Array.isArray(poppedMessage.content)) {
+        thinkingBlock = (poppedMessage.content.find((content) => content.type === ContentTypes.THINKING)) as ThinkingContentText | undefined;
+        thinkingStartIndex = thinkingBlock != null ? currentIndex : -1;
+      }
+      /** False start, the latest message was not part of a multi-assistant/tool sequence of messages */
+      if (
+        thinkingEndIndex > -1
+        && currentIndex === (thinkingEndIndex - 1)
+        && (messageType !== 'ai' && messageType !== 'tool')
+      ) {
+        thinkingEndIndex = -1;
+      }
+
+      const tokenCount = indexTokenCountMap[currentIndex] ?? 0;
 
-      if ((currentTokenCount + tokenCount) <= remainingContextTokens) {
+      if (prunedMemory.length === 0 && ((currentTokenCount + tokenCount) <= remainingContextTokens)) {
         context.push(poppedMessage);
         currentTokenCount += tokenCount;
       } else {
-        messages.push(poppedMessage);
+        prunedMemory.push(poppedMessage);
+        if (thinkingEndIndex > -1) {
+          continue;
+        }
         break;
       }
     }
-    
-  // Handle startOnMessageType requirement
-  if (startOnMessageType && context.length > 0) {
-    const requiredTypeIndex = context.findIndex(msg => msg.getType() === startOnMessageType);
-    
-    if (requiredTypeIndex > 0) {
-      context = context.slice(requiredTypeIndex);
+
+    if (thinkingEndIndex > -1 && context[context.length - 1].getType() === 'tool') {
+      startType = 'ai';
+    }
+
+    if (startType != null && startType && context.length > 0) {
+      const requiredTypeIndex = context.findIndex(msg => msg.getType() === startType);
+
+      if (requiredTypeIndex > 0) {
+        context = context.slice(requiredTypeIndex);
+      }
     }
   }
-  
-  // Add system message if it exists
-  if (instructions && _messages.length > 0) {
+
+  if (instructions && originalLength > 0) {
     context.push(_messages[0] as BaseMessage);
     messages.shift();
   }
-  
-  // Handle thinking mode requirement for Anthropic
-  if (thinkingEnabled && context.length > 0 && tokenCounter) {
-    // Check if the latest message is an assistant message
-    const latestMessageIsAssistant = _messages.length > 0 && _messages[_messages.length - 1].getType() === 'ai';
-    
-    // Process only if we have an assistant message in the context
-    const firstAssistantIndex = context.findIndex(msg => msg.getType() === 'ai');
-    
-    if (firstAssistantIndex >= 0) {
-      const firstAssistantMsg = context[firstAssistantIndex];
-      
-      // Check if the first assistant message already has a thinking block
-      const hasThinkingBlock = Array.isArray(firstAssistantMsg.content) && 
-        firstAssistantMsg.content.some(item => 
-          item && typeof item === 'object' && item.type === 'thinking');
-      
-      // Only proceed if we need to add thinking blocks
-      if (!hasThinkingBlock) {
-        // Collect thinking blocks from pruned assistant messages, starting from the most recent
-        const thinkingBlocks: any[] = [];
-        
-        // Look through pruned messages for thinking blocks, starting from the end (most recent)
-        for (let i = messages.length - 1; i >= 0; i--) {
-          const msg = messages[i];
-          if (msg.getType() === 'ai' && Array.isArray(msg.content)) {
-            for (const item of msg.content) {
-              if (item && typeof item === 'object' && item.type === 'thinking') {
-                thinkingBlocks.push(item);
-                // We only need one thinking block
-                break;
-              }
-            }
-            if (thinkingBlocks.length > 0) break; // Stop after finding one thinking block
-          }
-        }
-        
-        // If we found thinking blocks, add them to the first assistant message
-        if (thinkingBlocks.length > 0) {
-          // Calculate token count of original message
-          const originalTokenCount = tokenCounter(firstAssistantMsg);
-          
-          // Create a new content array with thinking blocks at the beginning
-          let newContent: any[];
-          
-          if (Array.isArray(firstAssistantMsg.content)) {
-            // Keep the original content (excluding any existing thinking blocks)
-            const originalContent = firstAssistantMsg.content.filter(item => 
-              !(item && typeof item === 'object' && item.type === 'thinking'));
-            
-            newContent = [...thinkingBlocks, ...originalContent];
-          } else if (typeof firstAssistantMsg.content === 'string') {
-            newContent = [
-              ...thinkingBlocks,
-              { type: 'text', text: firstAssistantMsg.content }
-            ];
-          } else {
-            newContent = thinkingBlocks;
-          }
-          
-          // Create a new message with the updated content
-          const newMessage = new AIMessage({
-            content: newContent,
-            additional_kwargs: firstAssistantMsg.additional_kwargs,
-            response_metadata: firstAssistantMsg.response_metadata,
-          });
-          
-          // Calculate token count of new message
-          const newTokenCount = tokenCounter(newMessage);
-          
-          // Adjust current token count
-          currentTokenCount += (newTokenCount - originalTokenCount);
-          
-          // Replace the first assistant message
-          context[firstAssistantIndex] = newMessage;
-          
-          // If we've exceeded the token limit, we need to prune more messages
-          if (currentTokenCount > remainingContextTokens) {
-            // Build a map of tool call IDs to track AI <--> tool message correspondences
-            const toolCallIdMap = new Map<string, number>();
-            
-            // Identify tool call IDs in the context
-            for (let i = 0; i < context.length; i++) {
-              const msg = context[i];
-              
-              // Check for tool calls in AI messages
-              if (msg.getType() === 'ai' && Array.isArray(msg.content)) {
-                for (const item of msg.content) {
-                  if (item && typeof item === 'object' && item.type === 'tool_use' && item.id) {
-                    toolCallIdMap.set(item.id, i);
-                  }
-                }
-              }
-              
-              // Check for tool messages
-              if (msg.getType() === 'tool' && 'tool_call_id' in msg && typeof msg.tool_call_id === 'string') {
-                toolCallIdMap.set(msg.tool_call_id, i);
-              }
-            }
-            
-            // Track which messages to remove
-            const indicesToRemove = new Set<number>();
-            
-            // Start removing messages from the end, but preserve AI <--> tool message correspondences
-            let i = context.length - 1;
-            while (i > firstAssistantIndex && currentTokenCount > remainingContextTokens) {
-              const msgToRemove = context[i];
-              
-              // Check if this is a tool message or has tool calls
-              let canRemove = true;
-              
-              if (msgToRemove.getType() === 'tool' && 'tool_call_id' in msgToRemove && typeof msgToRemove.tool_call_id === 'string') {
-                // If this is a tool message, check if we need to keep its corresponding AI message
-                const aiIndex = toolCallIdMap.get(msgToRemove.tool_call_id);
-                if (aiIndex !== undefined && aiIndex !== i && !indicesToRemove.has(aiIndex)) {
-                  // We need to remove both the tool message and its corresponding AI message
-                  indicesToRemove.add(i);
-                  indicesToRemove.add(aiIndex);
-                  currentTokenCount -= (tokenCounter(msgToRemove) + tokenCounter(context[aiIndex]));
-                  canRemove = false;
-                }
-              } else if (msgToRemove.getType() === 'ai' && Array.isArray(msgToRemove.content)) {
-                // If this is an AI message with tool calls, check if we need to keep its corresponding tool messages
-                for (const item of msgToRemove.content) {
-                  if (item && typeof item === 'object' && item.type === 'tool_use' && item.id) {
-                    const toolIndex = toolCallIdMap.get(item.id as string);
-                    if (toolIndex !== undefined && toolIndex !== i && !indicesToRemove.has(toolIndex)) {
-                      // We need to remove both the AI message and its corresponding tool message
-                      indicesToRemove.add(i);
-                      indicesToRemove.add(toolIndex);
-                      currentTokenCount -= (tokenCounter(msgToRemove) + tokenCounter(context[toolIndex]));
-                      canRemove = false;
-                      break;
-                    }
-                  }
-                }
-              }
-              
-              // If we can remove this message individually
-              if (canRemove && !indicesToRemove.has(i)) {
-                indicesToRemove.add(i);
-                currentTokenCount -= tokenCounter(msgToRemove);
-              }
-              
-              i--;
-            }
-            
-            // Remove messages in reverse order to avoid index shifting
-            const sortedIndices = Array.from(indicesToRemove).sort((a, b) => b - a);
-            for (const index of sortedIndices) {
-              context.splice(index, 1);
-            }
-            
-            // Update remainingContextTokens to reflect the new token count
-            remainingContextTokens = maxContextTokens - currentTokenCount;
-          }
-        }
-      }
+
+  remainingContextTokens -= currentTokenCount;
+  const result = {
+    remainingContextTokens,
+    context: [] as BaseMessage[],
+    messagesToRefine: prunedMemory,
+  };
+
+  if (prunedMemory.length === 0 || thinkingEndIndex < 0 || (thinkingStartIndex > -1 && isIndexInContext(_messages, context, thinkingStartIndex))) {
+    // we reverse at this step to ensure the context is in the correct order for the model, and we need to work backwards
+    result.context = context.reverse();
+    return result;
+  }
+
+  if (thinkingEndIndex > -1 && thinkingStartIndex < 0) {
+    throw new Error('The payload is malformed. There is a thinking sequence but no "AI" messages with thinking blocks.');
+  }
+
+  if (!thinkingBlock) {
+    throw new Error('The payload is malformed. There is a thinking sequence but no thinking block found.');
+  }
+
+  // Since we have a thinking sequence, we need to find the last assistant message
+  // in the latest AI/tool sequence to add the thinking block that falls outside of the current context
+  // Latest messages are ordered first.
+  let assistantIndex = -1;
+  for (let i = 0; i < context.length; i++) {
+    const currentMessage = context[i];
+    const type = currentMessage.getType();
+    if (type === 'ai') {
+      assistantIndex = i;
     }
-    
-    // If the latest message is an assistant message, ensure an assistant message appears early in the context
-    // but maintain system message precedence
-    if (latestMessageIsAssistant && context.length > 0) {
-      // Find the first assistant message in the context
-      const assistantIndex = context.findIndex(msg => msg.getType() === 'ai');
-      if (assistantIndex > 0) {
-        // Check if there's a system message at the beginning
-        const hasSystemFirst = context[0].getType() === 'system';
-        
-        // Move the assistant message to the appropriate position
-        const assistantMsg = context[assistantIndex];
-        context.splice(assistantIndex, 1);
-        
-        if (hasSystemFirst) {
-          // Insert after the system message
-          context.splice(1, 0, assistantMsg);
-        } else {
-          // Insert at the beginning if no system message
-          context.unshift(assistantMsg);
-        }
-      }
+    if (assistantIndex > -1 && (type === 'human' || type === 'system')) {
+      break;
     }
   }
+
+  if (assistantIndex === -1) {
+    throw new Error('The payload is malformed. There is a thinking sequence but no "AI" messages to append thinking blocks to.');
   }
 
-  const prunedMemory = messages;
-  summaryIndex = prunedMemory.length - 1;
-  remainingContextTokens -= currentTokenCount;
+  thinkingStartIndex = originalLength - 1 - assistantIndex;
+  const thinkingTokenCount = tokenCounter(new AIMessage({ content: [thinkingBlock] }));
+  const newRemainingCount = remainingContextTokens - thinkingTokenCount;
 
-  return {
-    summaryIndex,
-    remainingContextTokens,
-    context: context.reverse(),
-    messagesToRefine: prunedMemory,
-  };
+  const content: MessageContentComplex[] = Array.isArray(context[assistantIndex].content)
+    ? context[assistantIndex].content as MessageContentComplex[]
+    : [{
+      type: ContentTypes.TEXT,
+      text: context[assistantIndex].content,
+    }];
+  content.unshift(thinkingBlock);
+  context[assistantIndex].content = content;
+  if (newRemainingCount > 0) {
+    result.context = context.reverse();
+    return result;
+  }
+
+  const thinkingMessage: AIMessage = context[assistantIndex];
+  // now we need to an additional round of pruning but making the thinking block fit
+  const newThinkingMessageTokenCount = (indexTokenCountMap[thinkingStartIndex] ?? 0) + thinkingTokenCount;
+  remainingContextTokens = initialContextTokens - newThinkingMessageTokenCount;
+  currentTokenCount = 3;
+  let newContext: BaseMessage[] = [];
+  const secondRoundMessages = [..._messages];
+  let currentIndex = secondRoundMessages.length;
+  while (secondRoundMessages.length > 0 && currentTokenCount < remainingContextTokens && currentIndex > thinkingStartIndex) {
+    currentIndex--;
+    const poppedMessage = secondRoundMessages.pop();
+    if (!poppedMessage) continue;
+    const tokenCount = indexTokenCountMap[currentIndex] ?? 0;
+    if ((currentTokenCount + tokenCount) <= remainingContextTokens) {
+      newContext.push(poppedMessage);
+      currentTokenCount += tokenCount;
+    } else {
+      messages.push(poppedMessage);
+      break;
+    }
+  }
+
+  const firstMessage: AIMessage = newContext[newContext.length - 1];
+  const firstMessageType = newContext[newContext.length - 1].getType();
+  if (firstMessageType === 'tool') {
+    startType = 'ai';
+  }
+
+  if (startType != null && startType && newContext.length > 0) {
+    const requiredTypeIndex = newContext.findIndex(msg => msg.getType() === startType);
+    if (requiredTypeIndex > 0) {
+      newContext = newContext.slice(requiredTypeIndex);
+    }
+  }
+
+  if (firstMessageType === 'ai') {
+    newContext[newContext.length - 1] = new AIMessage({
+      content: concat(thinkingMessage.content as MessageContentComplex[], newContext[newContext.length - 1].content as MessageContentComplex[]),
+      tool_calls: concat(firstMessage.tool_calls, thinkingMessage.tool_calls),
+    });
+  } else {
+    newContext.push(thinkingMessage);
+  }
+
+  if (instructions && originalLength > 0) {
+    newContext.push(_messages[0] as BaseMessage);
+    secondRoundMessages.shift();
+  }
+
+  result.context = newContext.reverse();
+  return result;
 }
 
-function checkValidNumber(value: unknown): value is number {
+export function checkValidNumber(value: unknown): value is number {
   return typeof value === 'number' && !isNaN(value) && value > 0;
 }
 
@@ -312,7 +268,6 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
   const indexTokenCountMap = { ...factoryParams.indexTokenCountMap };
   let lastTurnStartIndex = factoryParams.startIndex;
   let totalTokens = (Object.values(indexTokenCountMap)).reduce((a, b) => a + b, 0);
-  
   return function pruneMessages(params: PruneMessagesParams): {
     context: BaseMessage[];
     indexTokenCountMap: Record<string, number>;
@@ -334,8 +289,10 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
 
     for (let i = lastTurnStartIndex; i < params.messages.length; i++) {
       const message = params.messages[i];
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (i === lastTurnStartIndex && indexTokenCountMap[i] === undefined && currentUsage) {
         indexTokenCountMap[i] = currentUsage.output_tokens;
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       } else if (indexTokenCountMap[i] === undefined) {
         indexTokenCountMap[i] = factoryParams.tokenCounter(message);
         totalTokens += indexTokenCountMap[i];
@@ -359,16 +316,15 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
       return { context: params.messages, indexTokenCountMap };
     }
 
-    // Pass the tokenCounter to getMessagesWithinTokenLimit for token recalculation
     const { context } = getMessagesWithinTokenLimit({
       maxContextTokens: factoryParams.maxTokens,
       messages: params.messages,
       indexTokenCountMap,
-      startOnMessageType: params.startOnMessageType,
+      startType: params.startType,
       thinkingEnabled: factoryParams.thinkingEnabled,
       tokenCounter: factoryParams.tokenCounter,
     });
 
     return { context, indexTokenCountMap };
-  }
+  };
 }

package/src/messages/shiftIndexTokenCountMap.test.ts

@@ -7,56 +7,56 @@ describe('shiftIndexTokenCountMap', () => {
       1: 20,
       2: 30
     };
-    
+
     const systemMessageTokenCount = 15;
-    
+
     const result = shiftIndexTokenCountMap(originalMap, systemMessageTokenCount);
-    
+
     // Check that the system message token count is at index 0
     expect(result[0]).toBe(15);
-    
+
     // Check that all other indices are shifted by 1
     expect(result[1]).toBe(10);
     expect(result[2]).toBe(20);
     expect(result[3]).toBe(30);
-    
+
     // Check that the original map is not modified
     expect(originalMap[0]).toBe(10);
     expect(originalMap[1]).toBe(20);
     expect(originalMap[2]).toBe(30);
   });
-  
+
   it('should handle an empty map', () => {
     const emptyMap: Record<number, number> = {};
     const systemMessageTokenCount = 15;
-    
+
     const result = shiftIndexTokenCountMap(emptyMap, systemMessageTokenCount);
-    
+
     // Check that only the system message token count is in the result
     expect(Object.keys(result).length).toBe(1);
     expect(result[0]).toBe(15);
   });
-  
+
   it('should handle non-sequential indices', () => {
     const nonSequentialMap: Record<number, number> = {
       0: 10,
       2: 20,
       5: 30
     };
-    
+
     const systemMessageTokenCount = 15;
-    
+
     const result = shiftIndexTokenCountMap(nonSequentialMap, systemMessageTokenCount);
-    
+
     // Check that the system message token count is at index 0
     expect(result[0]).toBe(15);
-    
+
     // Check that all other indices are shifted by 1
     expect(result[1]).toBe(10);
     expect(result[3]).toBe(20);
     expect(result[6]).toBe(30);
   });
-  
+
   it('should handle string keys', () => {
     // TypeScript will convert string keys to numbers when accessing the object
     const mapWithStringKeys: Record<string, number> = {
@@ -64,15 +64,15 @@ describe('shiftIndexTokenCountMap', () => {
       '1': 20,
       '2': 30
     };
-    
+
     const systemMessageTokenCount = 15;
-    
+
     // Cast to Record<number, number> to match the function signature
     const result = shiftIndexTokenCountMap(mapWithStringKeys as unknown as Record<number, number>, systemMessageTokenCount);
-    
+
     // Check that the system message token count is at index 0
     expect(result[0]).toBe(15);
-    
+
     // Check that all other indices are shifted by 1
     expect(result[1]).toBe(10);
     expect(result[2]).toBe(20);

package/src/mockStream.ts

@@ -1,4 +1,4 @@
-/* eslint-disable no-console */
+
 // import { nanoid } from 'nanoid';
 import type OpenAITypes from 'openai';
 import type * as t from '@/types';

package/src/run.ts

@@ -1,5 +1,5 @@
 // src/run.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { zodToJsonSchema } from 'zod-to-json-schema';
 import { PromptTemplate } from '@langchain/core/prompts';
 import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
 import { SystemMessage } from '@langchain/core/messages';
@@ -115,7 +115,7 @@ export class Run<T extends t.BaseGraphState> {
       if (!tool.schema) {
         return acc;
       }
-  
+
       const jsonSchema = zodToJsonSchema(tool.schema.describe(tool.description ?? ''), tool.name);
       return acc + tokenCounter(new SystemMessage(JSON.stringify(jsonSchema)));
     }, 0) ?? 0) : 0;