@librechat/agents 3.8.0 → 3.8.2

package/src/messages/prune.ts

@@ -2104,7 +2104,8 @@ function projectToolCallInputsInternal(
   messages: BaseMessage[],
   maxInputChars: number,
   dropIncompleteStreamContent: boolean,
-  fromIndex = 0
+  fromIndex = 0,
+  retainRawOpenAIToolCalls = true
 ): BaseMessage[] {
   const normalizedMaxInputChars = normalizeToolInputLimit(maxInputChars);
   let projectedMessages: BaseMessage[] | undefined;
@@ -2191,15 +2192,20 @@ function projectToolCallInputsInternal(
       }
     }
 
-    const additionalKwargsChanges: Record<string, unknown> =
-      rawAdditionalToolCallsProperty.accessor ? { tool_calls: undefined } : {};
-    const rawToolCalls = projectRawOpenAIToolCalls(
-      rawAdditionalToolCalls,
-      normalizedMaxInputChars,
-      canonicalArguments
-    );
-    if (rawToolCalls.changed) {
-      additionalKwargsChanges.tool_calls = rawToolCalls.value;
+    const additionalKwargsChanges: Record<string, unknown> = {};
+    if (!retainRawOpenAIToolCalls && rawAdditionalToolCallsProperty.found) {
+      additionalKwargsChanges.tool_calls = undefined;
+    } else if (rawAdditionalToolCallsProperty.accessor) {
+      additionalKwargsChanges.tool_calls = undefined;
+    } else {
+      const rawToolCalls = projectRawOpenAIToolCalls(
+        rawAdditionalToolCalls,
+        normalizedMaxInputChars,
+        canonicalArguments
+      );
+      if (rawToolCalls.changed) {
+        additionalKwargsChanges.tool_calls = rawToolCalls.value;
+      }
     }
     const legacyFunctionCall = projectLegacyFunctionCall(
       readPropertyWithoutAccessors(
@@ -2292,9 +2298,22 @@ export function projectToolCallInputs(
  */
 export function projectToolMessagesForProvider(
   messages: BaseMessage[],
-  maxInputChars: number
+  maxInputChars: number,
+  provider?: ProviderName
 ): BaseMessage[] {
-  return projectToolCallInputsInternal(messages, maxInputChars, true);
+  const providerFamily =
+    provider == null ? undefined : getProviderFamily(provider);
+  const retainRawOpenAIToolCalls =
+    provider == null ||
+    provider === Providers.OPENAI ||
+    providerFamily === 'openai';
+  return projectToolCallInputsInternal(
+    messages,
+    maxInputChars,
+    true,
+    0,
+    retainRawOpenAIToolCalls
+  );
 }
 
 function applyToolCallInputCaps(params: {

package/src/messages/reasoningTypes.ts

@@ -0,0 +1,23 @@
+const REASONING_CONTENT_BLOCK_TYPES: ReadonlySet<string> = new Set([
+  'think',
+  'thinking',
+  'thinking_delta',
+  'redacted_thinking',
+  'reasoning',
+  'reasoning-delta',
+  'reasoning_content',
+]);
+
+/** Identifies every persisted or streamed reasoning content-block shape. */
+export function isReasoningContentBlock(block: { type?: unknown }): boolean {
+  return (
+    typeof block.type === 'string' &&
+    REASONING_CONTENT_BLOCK_TYPES.has(block.type)
+  );
+}
+
+export function isAnthropicThinkingContentBlock(block: {
+  type?: unknown;
+}): boolean {
+  return block.type === 'thinking';
+}

package/src/messages/recency.ts

@@ -1,24 +1,17 @@
-import type {
-  AIMessage,
-  BaseMessage,
-  ToolMessage,
-} from '@langchain/core/messages';
-import type {
-  ProviderToolCallIndex,
-  ProviderToolCallPartDescriptor,
-  ProviderToolResultPartDescriptor,
-} from './toolResultTypes';
-import { getProviderSourceMessageIds } from './provenance';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ProviderToolCallIndex } from './toolResultTypes';
+import type { ProviderName } from '@/types/llm';
 import {
+  appendProviderMessageToolCalls,
   appendProviderToolCallDescriptor,
   consumeProviderToolResultPair,
   getBoundedProviderPairingArray,
-  getBoundedProviderPairingArrayProperty,
-  getProviderAIMessageToolCallDescriptor,
+  getProviderMessageRole,
   getProviderToolCallPartDescriptor,
+  getProviderToolMessageResultDescriptor,
   getProviderToolResultPartDescriptor,
-  PROVIDER_TOOL_PAIRING_MAX_IDENTIFIER_CHARS,
 } from './toolResultTypes';
+import { getProviderSourceMessageIds } from './provenance';
 
 export const DEFAULT_RETAIN_RECENT_TURNS = 2;
 export const DEFAULT_INTRA_TURN_RETAIN_RATIO = 0.16;
@@ -28,6 +21,8 @@ export const DEFAULT_INTRA_TURN_RETAIN_RATIO = 0.16;
  * and a tail (to be preserved verbatim).
  */
 export interface RecencyWindowOptions {
+  /** Serving provider used to interpret generic `ChatMessage` roles. */
+  provider?: ProviderName;
   /**
    * Maximum number of recent user-led turns to keep in the tail. A "turn"
    * begins at a user-authored HumanMessage and includes every following
@@ -102,168 +97,21 @@ export function resolveIntraTurnRetainTokens({
   );
 }
 
-function readOwnString(value: unknown, key: string): string | undefined {
-  if (value == null || typeof value !== 'object' || Array.isArray(value)) {
-    return undefined;
-  }
-  try {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    return descriptor != null &&
-      'value' in descriptor &&
-      typeof descriptor.value === 'string' &&
-      descriptor.value !== '' &&
-      descriptor.value.length <= PROVIDER_TOOL_PAIRING_MAX_IDENTIFIER_CHARS
-      ? descriptor.value
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function readOwnValue(value: unknown, key: string): unknown {
-  if (value == null || typeof value !== 'object' || Array.isArray(value)) {
-    return undefined;
-  }
-  try {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    return descriptor != null && 'value' in descriptor
-      ? descriptor.value
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-const LEGACY_FUNCTION_CALL_PREFIX = 'legacy_function:';
-
-function getLegacyFunctionCallId(name: string): string | undefined {
-  const callId = `${LEGACY_FUNCTION_CALL_PREFIX}${name}`;
-  return callId.length <= PROVIDER_TOOL_PAIRING_MAX_IDENTIFIER_CHARS
-    ? callId
-    : undefined;
-}
-
-function getRawToolCallDescriptor(
-  toolCall: unknown
-): ProviderToolCallPartDescriptor | undefined {
-  const callId = readOwnString(toolCall, 'id');
-  if (callId == null) {
-    return undefined;
-  }
-  let name: string | undefined;
-  if (toolCall != null && typeof toolCall === 'object') {
-    try {
-      const property = Object.getOwnPropertyDescriptor(toolCall, 'function');
-      name =
-        property != null && 'value' in property
-          ? readOwnString(property.value, 'name')
-          : undefined;
-    } catch {
-      return undefined;
-    }
-  }
-  return {
-    callId,
-    kind: 'tool',
-    sourceType: 'raw_tool_calls',
-    ...(name == null ? {} : { name }),
-  };
-}
-
-function appendMessageToolCalls(
-  message: BaseMessage,
-  calls: ProviderToolCallIndex
-): void {
-  const messageRole = (message as BaseMessage & { role?: unknown }).role;
-  if (message.getType() !== 'ai' && messageRole !== 'assistant') {
-    return;
-  }
-
-  for (const toolCall of (message as AIMessage).tool_calls ?? []) {
-    const descriptor = getProviderAIMessageToolCallDescriptor(toolCall);
-    if (descriptor != null) {
-      appendProviderToolCallDescriptor(calls, descriptor);
-    }
-  }
-
-  const rawToolCalls = getBoundedProviderPairingArrayProperty(
-    message.additional_kwargs,
-    'tool_calls'
-  );
-  if (rawToolCalls != null) {
-    for (const toolCall of rawToolCalls) {
-      const descriptor = getRawToolCallDescriptor(toolCall);
-      if (descriptor != null) {
-        appendProviderToolCallDescriptor(calls, descriptor);
-      }
-    }
-  }
-
-  const legacyFunctionCall = readOwnValue(
-    message.additional_kwargs,
-    'function_call'
-  );
-  const legacyFunctionName = readOwnString(legacyFunctionCall, 'name');
-  const legacyFunctionCallId =
-    legacyFunctionName == null
-      ? undefined
-      : getLegacyFunctionCallId(legacyFunctionName);
-  if (legacyFunctionCallId != null) {
-    appendProviderToolCallDescriptor(calls, {
-      callId: legacyFunctionCallId,
-      kind: 'tool',
-      name: legacyFunctionName,
-      sourceType: 'legacy_function_call',
-    });
-  }
-}
-
-function getToolMessageResultDescriptor(
-  message: BaseMessage
-): ProviderToolResultPartDescriptor | undefined {
-  if (message.getType() === 'function' && message.name != null) {
-    const toolCallId = getLegacyFunctionCallId(message.name);
-    return toolCallId == null
-      ? undefined
-      : {
-        type: 'function_message',
-        toolCallId,
-        compatibleCallKinds: ['tool'],
-        expectedToolNames: [message.name],
-      };
-  }
-  if (message.getType() !== 'tool') {
-    return undefined;
-  }
-  const toolMessage = message as ToolMessage & { toolCallId?: unknown };
-  const toolCallId =
-    typeof toolMessage.tool_call_id === 'string'
-      ? toolMessage.tool_call_id
-      : toolMessage.toolCallId;
-  return typeof toolCallId === 'string' &&
-    toolCallId !== '' &&
-    toolCallId.length <= PROVIDER_TOOL_PAIRING_MAX_IDENTIFIER_CHARS
-    ? {
-      type: 'tool_message',
-      toolCallId,
-      compatibleCallKinds: ['tool'],
-    }
-    : undefined;
-}
-
 interface MessagePairingResult {
   completedToolCalls: number;
   trustedHumanToolResult: boolean;
+  userMessage: boolean;
 }
 
 function inspectMessagePairing(
   message: BaseMessage,
-  calls: ProviderToolCallIndex
+  calls: ProviderToolCallIndex,
+  provider?: ProviderName
 ): MessagePairingResult {
-  const isHuman = message.getType() === 'human';
+  const isHuman = getProviderMessageRole(message, provider) === 'user';
   const candidateCalls = isHuman ? new Map(calls) : calls;
   if (!isHuman) {
-    appendMessageToolCalls(message, candidateCalls);
+    appendProviderMessageToolCalls(message, candidateCalls, provider);
   }
   const content = getBoundedProviderPairingArray(message.content);
   let completedToolCalls = 0;
@@ -300,7 +148,10 @@ function inspectMessagePairing(
     }
   }
 
-  const toolMessageResult = getToolMessageResultDescriptor(message);
+  const toolMessageResult = getProviderToolMessageResultDescriptor(
+    message,
+    provider
+  );
   if (
     toolMessageResult != null &&
     consumeProviderToolResultPair(toolMessageResult, candidateCalls)
@@ -319,20 +170,23 @@ function inspectMessagePairing(
     }
   }
   return {
-    completedToolCalls: isHuman && !trustedHumanToolResult
-      ? 0
-      : completedToolCalls,
+    completedToolCalls:
+      isHuman && !trustedHumanToolResult ? 0 : completedToolCalls,
     trustedHumanToolResult,
+    userMessage: isHuman,
   };
 }
 
-function findTurnStarts(messages: BaseMessage[]): number[] {
+function findTurnStarts(
+  messages: BaseMessage[],
+  provider?: ProviderName
+): number[] {
   const turnStarts: number[] = [];
   const calls: ProviderToolCallIndex = new Map();
   for (let i = 0; i < messages.length; i++) {
     const message = messages[i] as BaseMessage;
-    const pairing = inspectMessagePairing(message, calls);
-    if (message.getType() !== 'human' || pairing.trustedHumanToolResult) {
+    const pairing = inspectMessagePairing(message, calls, provider);
+    if (!pairing.userMessage || pairing.trustedHumanToolResult) {
       continue;
     }
     turnStarts.push(i);
@@ -354,7 +208,8 @@ function findIntraTurnBoundary(
   messages: BaseMessage[],
   countMessageAt: (index: number) => number,
   retainTokens: number,
-  earliestRetainedTurnEndIndex: number
+  earliestRetainedTurnEndIndex: number,
+  provider?: ProviderName
 ): number | undefined {
   let remainingTokens = 0;
   for (let i = 0; i < messages.length; i++) {
@@ -387,9 +242,9 @@ function findIntraTurnBoundary(
     const message = messages[i] as BaseMessage;
     remainingTokens -= countMessageAt(i);
 
-    const pairing = inspectMessagePairing(message, pendingToolCalls);
+    const pairing = inspectMessagePairing(message, pendingToolCalls, provider);
     completedToolCalls += pairing.completedToolCalls;
-    if (message.getType() === 'human' && !pairing.trustedHumanToolResult) {
+    if (pairing.userMessage && !pairing.trustedHumanToolResult) {
       pendingToolCalls.clear();
     }
 
@@ -408,7 +263,7 @@ function findIntraTurnBoundary(
       completedToolCalls > 0 &&
       pendingToolCalls.size === 0 &&
       straddlingSourceIds.size === 0 &&
-      (message.getType() !== 'human' || pairing.trustedHumanToolResult)
+      (!pairing.userMessage || pairing.trustedHumanToolResult)
     ) {
       boundary = i + 1;
     }
@@ -450,7 +305,7 @@ export function splitAtRecencyBoundary(
     };
   }
 
-  const turnStarts = findTurnStarts(messages);
+  const turnStarts = findTurnStarts(messages, options.provider);
 
   if (turnStarts.length === 0) {
     return {
@@ -535,7 +390,8 @@ export function splitAtRecencyBoundary(
         messages,
         countMessageAt,
         intraTurnTokens,
-        turnStarts[1] ?? messages.length
+        turnStarts[1] ?? messages.length,
+        options.provider
       );
       if (intraTurnBoundary != null) {
         return {