@librechat/agents 3.8.0 → 3.8.2

package/src/llm/contextPressureMeter.ts

@@ -9,7 +9,8 @@ import {
   REPLY_PRIMER_TOKENS,
   isSyntheticProviderContextMessage,
 } from '@/messages';
-import { apportionTokenCounts } from '@/utils';
+import { createToolMessageUsageAccumulator } from '@/messages/budget';
+import { readTokenMetadataProperty, apportionTokenCounts } from '@/utils';
 
 interface ContextPressureUsage {
   contextBudget?: number;
@@ -19,6 +20,7 @@ interface ContextPressureUsage {
 }
 
 interface ContextPressureMeterParams {
+  provider?: t.ProviderName;
   tokenCounter?: t.TokenCounter;
   tokenCountCache?: ExactTokenCountCache;
   sourceMessages: BaseMessage[];
@@ -89,6 +91,21 @@ function readDataProperty(
     : { own: true, safe: false };
 }
 
+function readCacheMetadataProperty(
+  owner: object,
+  property: PropertyKey,
+  path: string
+): { safe: boolean; value?: unknown } {
+  try {
+    return {
+      safe: true,
+      value: readTokenMetadataProperty(owner, property, path),
+    };
+  } catch {
+    return { safe: false };
+  }
+}
+
 function getStableTokenSurface(
   message: BaseMessage
 ): StableTokenSurface | undefined {
@@ -105,10 +122,13 @@ function getStableTokenSurface(
   }
   const messageType = message.getType();
   const roleProperty = readDataProperty(message, 'role');
-  if (!roleProperty.safe || (!roleProperty.own && 'role' in message)) {
+  const resolvedRoleProperty = roleProperty.own
+    ? roleProperty
+    : readCacheMetadataProperty(message, 'role', 'message.role');
+  if (!resolvedRoleProperty.safe) {
     return undefined;
   }
-  const role = roleProperty.value;
+  const role = resolvedRoleProperty.value;
   if (role != null && typeof role !== 'string') {
     return undefined;
   }
@@ -129,6 +149,14 @@ function getStableTokenSurface(
     return undefined;
   }
   const additionalKwargs = rawAdditionalKwargs;
+  const rawToolCalls = readCacheMetadataProperty(
+    additionalKwargs,
+    'tool_calls',
+    'additional_kwargs.tool_calls'
+  );
+  if (!rawToolCalls.safe || rawToolCalls.value != null) {
+    return undefined;
+  }
   const typeProperty = readDataProperty(additionalKwargs, 'type');
   if (!typeProperty.safe) {
     return undefined;
@@ -138,16 +166,16 @@ function getStableTokenSurface(
       message as AIMessage,
       'tool_calls'
     );
-    if (
-      !toolCallsProperty.safe ||
-      (!toolCallsProperty.own && 'tool_calls' in message)
-    ) {
+    const resolvedToolCallsProperty = toolCallsProperty.own
+      ? toolCallsProperty
+      : readCacheMetadataProperty(message, 'tool_calls', 'message.tool_calls');
+    if (!resolvedToolCallsProperty.safe) {
       return undefined;
     }
-    const toolCalls = toolCallsProperty.value;
+    const toolCalls = resolvedToolCallsProperty.value;
     if (
       toolCalls != null &&
-      (!Array.isArray(toolCalls) || isProxy(toolCalls) || toolCalls.length > 0)
+      (isProxy(toolCalls) || !Array.isArray(toolCalls) || toolCalls.length > 0)
     ) {
       return undefined;
     }
@@ -230,6 +258,7 @@ function getProviderMessageOriginKey(message: BaseMessage): string | undefined {
 
 /** Measures repeated provider projections while tokenizing each message object once. */
 export function createContextPressureMeter({
+  provider,
   tokenCounter,
   tokenCountCache,
   sourceMessages,
@@ -382,6 +411,22 @@ export function createContextPressureMeter({
         ? availableMessageTokens -
           Math.min(availableMessageTokens, Math.max(0, baselineRemaining))
         : undefined;
+    const toolUsage = createToolMessageUsageAccumulator(provider);
+    const toolUsageState: { error?: Error } = {};
+    const addToolUsage = (
+      message: BaseMessage,
+      getRawTokens: () => number
+    ): void => {
+      if (toolUsageState.error != null) {
+        return;
+      }
+      try {
+        toolUsage.add(message, getRawTokens);
+      } catch (error) {
+        toolUsageState.error =
+          error instanceof Error ? error : new Error(String(error));
+      }
+    };
 
     let projectedMessageTokens: number;
     if (
@@ -423,15 +468,18 @@ export function createContextPressureMeter({
       const usedOrigins = new Set<number>();
       for (const message of messages) {
         const origin = origins.get(message);
+        let rawTokens: number | undefined;
+        const getRawTokens = (): number => (rawTokens ??= count(message));
+        addToolUsage(message, getRawTokens);
         if (origin == null || usedOrigins.has(origin)) {
-          newRawTokens += count(message);
+          newRawTokens += getRawTokens();
           continue;
         }
         usedOrigins.add(origin);
         const projectionDelta =
           message === baseline[origin].message
             ? 0
-            : count(message) - baseline[origin].rawTokens;
+            : getRawTokens() - baseline[origin].rawTokens;
         projectedMessageTokens += Math.max(
           0,
           attribution.attributedByOrigin[origin] +
@@ -442,16 +490,36 @@ export function createContextPressureMeter({
     } else {
       let rawTokens = REPLY_PRIMER_TOKENS;
       for (const message of messages) {
-        rawTokens += count(message);
+        const messageTokens = count(message);
+        addToolUsage(message, () => messageTokens);
+        rawTokens += messageTokens;
       }
       projectedMessageTokens = Math.round(rawTokens * usageRatio);
     }
+    let measuredToolUsage:
+      | Pick<
+          t.TokenBudgetBreakdown,
+          'toolMessageTokens' | 'toolMessageTokenCounts'
+        >
+      | undefined;
+    try {
+      measuredToolUsage =
+        toolUsageState.error == null ? toolUsage.finish(usageRatio) : undefined;
+    } catch (error) {
+      toolUsageState.error =
+        error instanceof Error ? error : new Error(String(error));
+      measuredToolUsage = undefined;
+    }
     return {
       fits: projectedMessageTokens <= availableMessageTokens,
       projectedMessageTokens,
       availableMessageTokens,
       contextBudget,
       effectiveInstructionTokens,
+      ...measuredToolUsage,
+      ...(toolUsageState.error == null
+        ? {}
+        : { toolMessageUsageError: toolUsageState.error }),
     };
   };
 

package/src/llm/openai/utils/index.ts

@@ -56,6 +56,7 @@ import {
   serializeToolCallInput,
 } from '@/messages/prune';
 import { toLangChainContent } from '@/messages/langchain';
+import { isAnthropicThinkingContentBlock } from '@/messages/reasoningTypes';
 
 export type { OpenAICallOptions, OpenAIChatInput };
 
@@ -361,7 +362,7 @@ export function _convertMessagesToOpenAIParams(
       role = 'developer';
     }
 
-    let hasAnthropicThinkingBlock: boolean = false;
+    let hasReasoningBlock = false;
 
     let content: unknown;
     if (
@@ -384,8 +385,8 @@ export function _convertMessagesToOpenAIParams(
       content = message.content;
     } else {
       content = message.content.map((m) => {
-        if ('type' in m && m.type === 'thinking') {
-          hasAnthropicThinkingBlock = true;
+        if (isAnthropicThinkingContentBlock(m)) {
+          hasReasoningBlock = true;
           return m;
         }
         if (isDataContentBlock(m)) {
@@ -416,7 +417,7 @@ export function _convertMessagesToOpenAIParams(
       completionParam.tool_calls = message.tool_calls.map(
         convertLangChainToolCallToBoundedOpenAI
       );
-      completionParam.content = hasAnthropicThinkingBlock ? content : '';
+      completionParam.content = hasReasoningBlock ? content : '';
       if (
         options?.includeReasoningDetails === true &&
         message.additional_kwargs.reasoning_details != null

package/src/llm/prepareProviderRequest.ts

@@ -7,6 +7,7 @@ import type {
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
+import type { ToolHistoryPreparation } from '@/messages/toolHistoryProjection';
 import {
   projectCacheControlledToolOutputsToText,
   projectComputerCallOutputsToText,
@@ -27,15 +28,12 @@ import {
   stripBedrockCacheControl,
   cloneMessage,
 } from '@/messages/cache';
-import {
-  isAnthropicLike,
-  isGoogleLike,
-  isOpenAILike,
-} from '@/utils/llm';
+import { isAnthropicLike, isGoogleLike, isOpenAILike } from '@/utils/llm';
 import { annotateMessagesForLLM } from '@/tools/toolOutputReferences';
 import { providerRequiresStrictAlternation } from '@/llm/providers';
 import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
+import { createToolHistoryPreparation } from '@/messages/toolHistoryProjection';
 
 const preparedProviderRequestBrand = Symbol('PreparedProviderRequest');
 const OMITTED_ATTACHMENT_TEXT =
@@ -90,6 +88,9 @@ export interface ProviderPayloadMeasurement {
   readonly availableMessageTokens?: number;
   readonly contextBudget?: number;
   readonly effectiveInstructionTokens?: number;
+  readonly toolMessageTokens?: number;
+  readonly toolMessageTokenCounts?: Record<string, number>;
+  readonly toolMessageUsageError?: Error;
 }
 
 export interface PreparedProviderRequest {
@@ -120,6 +121,7 @@ export interface PrepareProviderRequestParams {
   config?: RunnableConfig;
   maxToolResultChars?: number;
   measure?: (messages: BaseMessage[]) => ProviderPayloadMeasurement;
+  toolHistory?: ToolHistoryPreparation;
 }
 
 export function usesNativeOpenAIResponses(
@@ -164,11 +166,8 @@ export function usesNativeOpenAIResponses(
       } else if (effectiveCallOptions == null) {
         effectiveCallOptions = runnable.defaultOptions;
       }
-      if (
-        runnable._useResponsesApi?.(effectiveCallOptions) === true ||
-        runnable._useResponsesApi?.(undefined) === true
-      ) {
-        return true;
+      if (typeof runnable._useResponsesApi === 'function') {
+        return runnable._useResponsesApi(effectiveCallOptions) === true;
       }
     } catch {
       // Continue through RunnableSequence/RunnableBinding wrappers.
@@ -208,6 +207,7 @@ interface ProjectMessagesForProviderParams {
   provider: t.ProviderName;
   maxToolResultChars?: number;
   callOptions?: unknown;
+  toolHistory?: ToolHistoryPreparation;
 }
 
 function isSerializedBuffer(value: object): value is SerializedBuffer {
@@ -380,10 +380,7 @@ function projectAttachmentsForProvider(
       }
       content ??= copyUsableContentPrefix(sourceContent, blockIndex);
       const mimeType = BEDROCK_DOCUMENT_MIME_TYPES[block.document.format];
-      if (
-        mimeType == null ||
-        !canProjectBedrockDocument(provider, mimeType)
-      ) {
+      if (mimeType == null || !canProjectBedrockDocument(provider, mimeType)) {
         continue;
       }
       const standardFile = toStandardFileBlock(block);
@@ -408,7 +405,12 @@ function projectAttachmentsForProvider(
 }
 
 function projectMessagesForProviderMode(
-  { messages, provider, maxToolResultChars }: ProjectMessagesForProviderParams,
+  {
+    messages,
+    provider,
+    maxToolResultChars,
+    toolHistory,
+  }: ProjectMessagesForProviderParams,
   projectionMode: ProviderMessageProjectionMode
 ): BaseMessage[] {
   const providerFamily = getProviderFamily(provider);
@@ -417,7 +419,8 @@ function projectMessagesForProviderMode(
     projectToolStreamContentForProvider(
       messages,
       nativeOpenAIResponses ? 'native' : 'fallback',
-      maxToolResultChars
+      maxToolResultChars,
+      toolHistory
     ),
     provider
   );
@@ -529,6 +532,7 @@ export function prepareProviderRequest({
   config,
   maxToolResultChars,
   measure,
+  toolHistory = createToolHistoryPreparation(),
 }: PrepareProviderRequestParams): PreparedProviderRequest {
   const projectionMode = resolveProviderMessageProjectionMode(
     model,
@@ -542,6 +546,7 @@ export function prepareProviderRequest({
       provider,
       maxToolResultChars,
       callOptions: config,
+      toolHistory,
     },
     projectionMode
   );

package/src/messages/alternation.ts

@@ -4,10 +4,10 @@ import type { BaseMessage, MessageContent } from '@langchain/core/messages';
 import type { ProviderMessageProvenancePart } from './provenance';
 import type { ProviderToolCallIndex } from './toolResultTypes';
 import {
+  appendProviderMessageToolCalls,
   appendProviderToolCallDescriptor,
   consumeProviderToolResultPair,
   getBoundedProviderPairingArrayProperty,
-  getProviderAIMessageToolCallDescriptor,
   getProviderToolCallPartDescriptor,
   getProviderToolResultPartDescriptor,
 } from './toolResultTypes';
@@ -42,6 +42,7 @@ export const strictAlternationProviders: ReadonlySet<Providers> = new Set([
  */
 function collectProviderToolCalls(message: BaseMessage): ProviderToolCallIndex {
   const calls: ProviderToolCallIndex = new Map();
+  appendProviderMessageToolCalls(message, calls);
   const content = getBoundedProviderPairingArrayProperty(message, 'content');
   if (content != null) {
     for (let index = 0; index < content.length; index++) {
@@ -51,20 +52,6 @@ function collectProviderToolCalls(message: BaseMessage): ProviderToolCallIndex {
       }
     }
   }
-  const toolCalls = getBoundedProviderPairingArrayProperty(
-    message,
-    'tool_calls'
-  );
-  if (toolCalls != null) {
-    for (let index = 0; index < toolCalls.length; index++) {
-      const descriptor = getProviderAIMessageToolCallDescriptor(
-        toolCalls[index]
-      );
-      if (descriptor != null) {
-        appendProviderToolCallDescriptor(calls, descriptor);
-      }
-    }
-  }
   return calls;
 }