@librechat/agents 3.1.74 → 3.1.75-dev.1

package/src/messages/cache.ts

@@ -9,11 +9,16 @@ import {
 import type { AnthropicMessage } from '@/types/messages';
 import type Anthropic from '@anthropic-ai/sdk';
 import { ContentTypes } from '@/common/enum';
+import { toLangChainContent } from './langchain';
 
 type MessageWithContent = {
   content?: string | MessageContentComplex[];
 };
 
+type MessageContentWithCacheControl = MessageContentComplex & {
+  cache_control?: unknown;
+};
+
 /**
  * Deep clones a message's content to prevent mutation of the original.
  */
@@ -41,7 +46,7 @@ function cloneMessage<T extends MessageWithContent>(
 ): T {
   if (message instanceof BaseMessage) {
     const baseParams = {
-      content,
+      content: toLangChainContent(content),
       additional_kwargs: { ...message.additional_kwargs },
       response_metadata: { ...message.response_metadata },
       id: message.id,
@@ -101,6 +106,40 @@ function cloneMessage<T extends MessageWithContent>(
   return cloned;
 }
 
+function stripAnthropicCacheControlFromBlocks(
+  content: MessageContentComplex[]
+): { content: MessageContentComplex[]; modified: boolean } {
+  let modified = false;
+  const strippedContent = content.map((block) => {
+    if (!('cache_control' in block)) {
+      return block;
+    }
+
+    const cloned: MessageContentWithCacheControl = { ...block };
+    delete cloned.cache_control;
+    modified = true;
+    return cloned;
+  });
+
+  return { content: strippedContent, modified };
+}
+
+function sanitizeBedrockSystemMessage<T extends MessageWithContent>(
+  message: T
+): T {
+  const content = message.content;
+  if (!Array.isArray(content)) {
+    return message;
+  }
+
+  const stripped = stripAnthropicCacheControlFromBlocks(content);
+  if (!stripped.modified) {
+    return message;
+  }
+
+  return cloneMessage(message, stripped.content);
+}
+
 /**
  * Anthropic API: Adds cache control to the appropriate user messages in the payload.
  * Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,
@@ -299,7 +338,7 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
  * @returns - A new array of message objects with cache points added.
  */
 export function addBedrockCacheControl<
-  T extends Partial<BaseMessage> & MessageWithContent,
+  T extends MessageWithContent & { getType?: () => string; role?: string },
 >(messages: T[]): T[] {
   if (!Array.isArray(messages) || messages.length < 2) {
     return messages;
@@ -310,11 +349,24 @@ export function addBedrockCacheControl<
 
   for (let i = updatedMessages.length - 1; i >= 0; i--) {
     const originalMessage = updatedMessages[i];
-    const isToolMessage =
+    const messageType =
       'getType' in originalMessage &&
-      typeof originalMessage.getType === 'function' &&
-      originalMessage.getType() === 'tool';
+      typeof originalMessage.getType === 'function'
+        ? originalMessage.getType()
+        : undefined;
+    const messageRole =
+      'role' in originalMessage && typeof originalMessage.role === 'string'
+        ? originalMessage.role
+        : undefined;
+
+    const isSystemMessage =
+      messageType === 'system' || messageRole === 'system';
+    if (isSystemMessage) {
+      updatedMessages[i] = sanitizeBedrockSystemMessage(originalMessage);
+      continue;
+    }
 
+    const isToolMessage = messageType === 'tool' || messageRole === 'tool';
     const content = originalMessage.content;
     const hasArrayContent = Array.isArray(content);
     const isEmptyString = typeof content === 'string' && content === '';

package/src/messages/core.ts

@@ -9,6 +9,7 @@ import {
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
 import { Providers } from '@/common';
+import { toLangChainContent } from './langchain';
 
 export function getConverseOverrideMessage({
   userMessage,
@@ -153,14 +154,18 @@ export function modifyDeltaProperties(
     : '';
 
   if (provider === Providers.BEDROCK && Array.isArray(obj.content)) {
-    obj.content = reduceBlocks(obj.content as ContentBlock[]);
+    obj.content = toLangChainContent(
+      reduceBlocks(obj.content as ContentBlock[])
+    );
   }
   if (Array.isArray(obj.content)) {
-    obj.content = modifyContent({
-      provider,
-      messageType,
-      content: obj.content,
-    }) as t.MessageContentComplex[];
+    obj.content = toLangChainContent(
+      modifyContent({
+        provider,
+        messageType,
+        content: obj.content as t.ExtendedMessageContent[],
+      }) as t.MessageContentComplex[]
+    );
   }
   if (
     (obj as Partial<AIMessageChunk>).lc_kwargs &&
@@ -182,7 +187,7 @@ export function modifyDeltaProperties(
 
 export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
   if (!message.tool_calls || message.tool_calls.length === 0) {
-    return new AIMessage({ content: message.content });
+    return new AIMessage({ content: toLangChainContent(message.content) });
   }
 
   const toolCallMap = new Map(message.tool_calls.map((tc) => [tc.id, tc]));
@@ -269,7 +274,7 @@ export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
   );
 
   return new AIMessage({
-    content: formattedContent,
+    content: toLangChainContent(formattedContent),
     tool_calls: formattedToolCalls as ToolCall[],
     additional_kwargs: {
       ...message.additional_kwargs,
@@ -437,7 +442,9 @@ export function formatArtifactPayload(messages: BaseMessage[]): void {
   }
 
   if (aggregatedContent.length > 0) {
-    messages.push(new HumanMessage({ content: aggregatedContent }));
+    messages.push(
+      new HumanMessage({ content: toLangChainContent(aggregatedContent) })
+    );
   }
 }
 

package/src/messages/format.ts

@@ -22,6 +22,7 @@ import type {
 import type { RunnableConfig } from '@langchain/core/runnables';
 import { emitAgentLog } from '@/utils/events';
 import { Providers, ContentTypes, Constants } from '@/common';
+import { toLangChainContent, toLangChainMessageFields } from './langchain';
 
 interface MediaMessageParams {
   message: {
@@ -210,7 +211,7 @@ export const formatMessage = ({
       return mediaMessage;
     }
 
-    return new HumanMessage(mediaMessage);
+    return new HumanMessage(toLangChainMessageFields(mediaMessage));
   }
 
   if (!langChain) {
@@ -218,11 +219,11 @@ export const formatMessage = ({
   }
 
   if (role === 'user') {
-    return new HumanMessage(formattedMessage);
+    return new HumanMessage(toLangChainMessageFields(formattedMessage));
   } else if (role === 'assistant') {
-    return new AIMessage(formattedMessage);
+    return new AIMessage(toLangChainMessageFields(formattedMessage));
   } else {
-    return new SystemMessage(formattedMessage);
+    return new SystemMessage(toLangChainMessageFields(formattedMessage));
   }
 };
 
@@ -413,7 +414,9 @@ function formatAssistantMessage(
       formattedMessages.push(new AIMessage({ content }));
     }
   } else if (currentContent.length > 0) {
-    formattedMessages.push(new AIMessage({ content: currentContent }));
+    formattedMessages.push(
+      new AIMessage({ content: toLangChainContent(currentContent) })
+    );
   }
 
   return formattedMessages;
@@ -1542,7 +1545,7 @@ export function ensureThinkingBlockInMessages(
         'ensureThinkingBlockInMessages: injecting [Previous agent context] HumanMessage' +
           ` (${parts.length} msgs at index ${i}, no thinking block in chain)`
       );
-      result.push(new HumanMessage({ content: parts }));
+      result.push(new HumanMessage({ content: toLangChainContent(parts) }));
       i = j;
     } else {
       // Keep the message as is

package/src/messages/langchain.ts

@@ -0,0 +1,39 @@
+import type { MessageContent } from '@langchain/core/messages';
+import type * as t from '@/types';
+
+type LibreChatMessageContent =
+  | MessageContent
+  | string
+  | t.MessageContentComplex[]
+  | t.ExtendedMessageContent[];
+
+type WithLangChainContent<T extends { content: LibreChatMessageContent }> =
+  Omit<T, 'content'> & {
+    content: MessageContent;
+  };
+
+/**
+ * Bridges LibreChat's extended content blocks to LangChain 1.x MessageContent.
+ *
+ * LangChain 1.x narrowed message constructor types around ContentBlock, while
+ * LibreChat still carries provider-specific blocks through the same content
+ * field. This helper keeps the runtime shape unchanged during the dependency
+ * upgrade; tracking issue: https://github.com/danny-avila/agents/issues/130.
+ */
+export function toLangChainContent(
+  content: LibreChatMessageContent
+): MessageContent {
+  return content as MessageContent;
+}
+
+/**
+ * Applies the same LangChain 1.x content bridge to message constructor fields.
+ *
+ * Keep this cast-only helper local to constructor boundaries so follow-up work
+ * can replace it with aligned content types or explicit conversion logic.
+ */
+export function toLangChainMessageFields<
+  T extends { content: LibreChatMessageContent },
+>(message: T): WithLangChainContent<T> {
+  return message as WithLangChainContent<T>;
+}

package/src/messages/prune.ts

@@ -19,6 +19,7 @@ import {
 import { resolveContextPruningSettings } from './contextPruningSettings';
 import { ContentTypes, Providers, Constants } from '@/common';
 import { applyContextPruning } from './contextPruning';
+import { toLangChainContent } from './langchain';
 
 function sumTokenCounts(
   tokenMap: Record<string, number | undefined>,
@@ -343,7 +344,7 @@ function stripOrphanToolUseBlocks(
 
   return new AIMessage({
     ...message,
-    content: keptContent,
+    content: toLangChainContent(keptContent),
     tool_calls: keptToolCalls.length > 0 ? keptToolCalls : undefined,
   });
 }
@@ -542,7 +543,7 @@ function addThinkingBlock(
   content.unshift(thinkingBlock);
   return new AIMessage({
     ...message,
-    content,
+    content: toLangChainContent(content),
   });
 }
 
@@ -817,7 +818,7 @@ export function getMessagesWithinTokenLimit({
 
   thinkingStartIndex = originalLength - 1 - assistantIndex;
   const thinkingTokenCount = tokenCounter(
-    new AIMessage({ content: [thinkingBlock] })
+    new AIMessage({ content: toLangChainContent([thinkingBlock]) })
   );
   const newRemainingCount = remainingContextTokens - thinkingTokenCount;
   const newMessage = addThinkingBlock(
@@ -856,7 +857,7 @@ export function getMessagesWithinTokenLimit({
     }
   }
 
-  const firstMessage: AIMessage = newContext[newContext.length - 1];
+  const firstMessage = newContext[newContext.length - 1];
   const firstMessageType = newContext[newContext.length - 1].getType();
   if (firstMessageType === 'tool') {
     startType = ['ai', 'human'];
@@ -887,7 +888,10 @@ export function getMessagesWithinTokenLimit({
   }
 
   if (firstMessageType === 'ai') {
-    const newMessage = addThinkingBlock(firstMessage, thinkingBlock);
+    const newMessage = addThinkingBlock(
+      firstMessage as AIMessage,
+      thinkingBlock
+    );
     newContext[newContext.length - 1] = newMessage;
   } else {
     newContext.push(thinkingMessage);
@@ -1178,7 +1182,7 @@ export function preFlightTruncateToolCallInputs(params: {
 
     messages[i] = new AIMessage({
       ...aiMsg,
-      content: newContent,
+      content: toLangChainContent(newContent),
       tool_calls: newToolCalls.length > 0 ? newToolCalls : undefined,
     });
     indexTokenCountMap[i] = tokenCounter(messages[i]);
@@ -1290,7 +1294,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
 
           params.messages[i] = new AIMessage({
             ...message,
-            content: [thinkingBlock],
+            content: toLangChainContent([thinkingBlock]),
             additional_kwargs: {
               ...message.additional_kwargs,
               reasoning_content: undefined,
@@ -1966,7 +1970,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
               });
               emergencyMessages[i] = new AIMessage({
                 ...aiMsg,
-                content: newContent,
+                content: toLangChainContent(newContent),
                 tool_calls: newToolCalls.length > 0 ? newToolCalls : undefined,
               });
               indexTokenCountMap[i] = factoryParams.tokenCounter(

package/src/scripts/caching.ts

@@ -50,9 +50,8 @@ ${CACHED_TEXT}`;
     },
   };
 
-  const baseLlmConfig: t.LLMConfig & t.AnthropicClientOptions = getLLMConfig(
-    Providers.ANTHROPIC
-  );
+  const baseLlmConfig = getLLMConfig(Providers.ANTHROPIC) as t.LLMConfig &
+    t.AnthropicClientOptions;
 
   if (baseLlmConfig.provider !== 'anthropic') {
     console.error(

package/src/specs/anthropic.simple.test.ts

@@ -376,6 +376,67 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     );
   });
 
+  test(`${capitalizeFirstLetter(provider)}: follow-up after assistant message with only whitespace text content`, async () => {
+    /**
+     * Regression for LibreChat discussion #12806.
+     *
+     * The Anthropic API has two distinct rejection rules (verified against
+     * the live API):
+     *   1. Strict empty `text: ''`  → rejected anywhere
+     *      "messages: text content blocks must be non-empty"
+     *   2. Whitespace-only `text: ' '` / '\n' / '\t' → rejected when the
+     *      assistant message has no other accepted blocks (no tool blocks,
+     *      no non-whitespace text)
+     *      "messages: text content blocks must contain non-whitespace text"
+     *
+     * Anthropic responses for some prompts include a whitespace-only text
+     * block as the sole text content. Re-sending that history on a
+     * follow-up turn triggers rule 2.
+     *
+     * The wire-send filter in `_formatContent` must drop any text block
+     * whose trimmed content is empty. The previous filter used strict
+     * `text === ''` only, which caught rule 1 but not rule 2.
+     */
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers1 = setupCustomHandlers();
+
+    const followUpRun = await Run.create<t.IState>({
+      runId: 'repro-12806-followup',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        instructions: 'You are a friendly AI assistant.',
+      },
+      returnContent: true,
+      skipCleanup: true,
+      customHandlers: customHandlers1,
+    });
+
+    // Build history with an assistant message whose entire content array
+    // is a single whitespace-only text block. This is the precise shape
+    // the API rejects under rule 2 above.
+    conversationHistory = [
+      new HumanMessage('hi'),
+      new (require('@langchain/core/messages').AIMessage)({
+        content: [{ type: 'text', text: ' ' }],
+      }),
+      new HumanMessage('please respond with a short greeting'),
+    ];
+
+    // With the fix: `_formatContent` drops the whitespace text block,
+    // the assistant content becomes an empty array, and the API accepts.
+    // Without the fix: the whitespace block is forwarded and the API
+    // rejects with "messages: text content blocks must contain non-whitespace text".
+    const finalContentParts = await followUpRun.processStream(
+      { messages: conversationHistory },
+      config
+    );
+    expect(finalContentParts).toBeDefined();
+    const finalMessages = followUpRun.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    expect(finalMessages?.length).toBeGreaterThan(0);
+  });
+
   test('should handle errors appropriately', async () => {
     // Test error scenarios
     await expect(async () => {

package/src/specs/summarization.test.ts

@@ -22,6 +22,8 @@ import { formatAgentMessages } from '@/messages/format';
 import { FakeListChatModel } from '@langchain/core/utils/testing';
 import * as providers from '@/llm/providers';
 
+const SUMMARY_WRAPPER_OVERHEAD_TOKENS = 33;
+
 /** Extract plain text from a SummaryContentBlock's content array (test helper). */
 function getSummaryText(summary: t.SummaryContentBlock | undefined): string {
   if (!summary) return '';
@@ -136,6 +138,7 @@ async function createSummarizationRun(opts: {
   tools?: t.GraphTools;
   indexTokenCountMap?: Record<string, number>;
   llmConfigOverride?: Record<string, unknown>;
+  maxSummaryTokens?: number;
 }): Promise<Run<t.IState>> {
   const llmConfig = {
     ...getLLMConfig(opts.agentProvider),
@@ -155,6 +158,7 @@ async function createSummarizationRun(opts: {
       summarizationConfig: {
         provider: opts.summarizationProvider,
         model: opts.summarizationModel,
+        maxSummaryTokens: opts.maxSummaryTokens,
       },
     },
     returnContent: true,
@@ -242,6 +246,33 @@ function buildIndexTokenCountMap(
   return map;
 }
 
+function sumTokenCountMap(map: Record<string, number | undefined>): number {
+  let total = 0;
+  for (const key in map) {
+    total += map[key] ?? 0;
+  }
+  return total;
+}
+
+function createSeededTokenAuditHistory(): BaseMessage[] {
+  const details =
+    'Token audit context preserves index token counts, summary replacement, calibration data, and post-summary continuity. ' +
+    'Important retained values: alpha=1024, beta=2048, gamma=4096, checksum TOKEN-AUDIT-7F3. ' +
+    'The repeated detail intentionally exceeds a compact context budget. ';
+  const padding = details.repeat(8);
+
+  return [
+    new HumanMessage(
+      `Audit turn 1: establish the accounting scenario. ${padding}`
+    ),
+    new AIMessage(`Recorded turn 1 accounting notes. ${padding}`),
+    new HumanMessage(`Audit turn 2: add more retained details. ${padding}`),
+    new AIMessage(`Recorded turn 2 accounting notes. ${padding}`),
+    new HumanMessage(`Audit turn 3: preserve final identifiers. ${padding}`),
+    new AIMessage(`Recorded turn 3 accounting notes. ${padding}`),
+  ];
+}
+
 function logTurn(
   label: string,
   conversationHistory: BaseMessage[],
@@ -1443,7 +1474,8 @@ describe('Cross-run summary lifecycle (no API keys)', () => {
     expect(completePayload.summary!.tokenCount ?? 0).toBeGreaterThan(0);
 
     const expectedTokenCount =
-      tokenCounter(new SystemMessage(KNOWN_SUMMARY)) + 33;
+      tokenCounter(new SystemMessage(KNOWN_SUMMARY)) +
+      SUMMARY_WRAPPER_OVERHEAD_TOKENS;
     expect(completePayload.summary!.tokenCount).toBe(expectedTokenCount);
 
     const summaryBlock = completePayload.summary!;
@@ -2414,10 +2446,10 @@ const hasAnyApiKey =
   test('token count map is accurate after summarization cycle', async () => {
     const spies = createSpies();
     let collectedUsage: UsageMetadata[] = [];
-    const conversationHistory: BaseMessage[] = [];
+    const conversationHistory = createSeededTokenAuditHistory();
     const tokenCounter = await createTokenCounter();
 
-    const createRun = async (maxTokens = 4000): Promise<Run<t.IState>> => {
+    const createRun = async (maxTokens = 1200): Promise<Run<t.IState>> => {
       collectedUsage = [];
       const { aggregateContent } = createContentAggregator();
       const indexTokenCountMap = buildIndexTokenCountMap(
@@ -2429,80 +2461,44 @@ const hasAnyApiKey =
         summarizationProvider,
         summarizationModel,
         maxContextTokens: maxTokens,
-        instructions: INSTRUCTIONS,
+        instructions:
+          'You are a concise assistant. Preserve checkpoint context and answer in one short sentence.',
         collectedUsage,
         aggregateContent,
         spies,
         tokenCounter,
         indexTokenCountMap,
+        maxSummaryTokens: 300,
+        tools: [],
+        llmConfigOverride: {
+          maxTokens: 128,
+        },
       });
     };
 
-    // Accumulate messages over 6 turns at generous budget
-    let run = await createRun();
-    await runTurn(
-      { run, conversationHistory },
-      'What is 42 * 58? Calculator.',
-      streamConfig
-    );
-
-    run = await createRun();
-    await runTurn(
-      { run, conversationHistory },
-      'Now compute 2436 + 1000. Calculator.',
-      streamConfig
-    );
-
-    run = await createRun();
-    await runTurn(
-      { run, conversationHistory },
-      'What is 3436 / 4? Calculator.',
-      streamConfig
-    );
-
-    run = await createRun();
-    await runTurn(
-      { run, conversationHistory },
-      'Compute 999 * 2. Calculator.',
-      streamConfig
-    );
-
-    run = await createRun();
-    await runTurn(
-      { run, conversationHistory },
-      'What is 2^10? Calculator. Also list everything.',
-      streamConfig
+    const originalMap = buildIndexTokenCountMap(
+      conversationHistory,
+      tokenCounter
     );
+    const originalTokenTotal = sumTokenCountMap(originalMap);
+    expect(originalTokenTotal).toBeGreaterThan(1200);
 
-    run = await createRun();
+    const run = await createRun();
     await runTurn(
       { run, conversationHistory },
-      'Calculate 355 / 113. Calculator.',
+      'Acknowledge the preserved token audit context in one short sentence.',
       streamConfig
     );
 
-    // Squeeze progressively to force summarization
-    for (const squeeze of [3500, 3200, 3100, 3000, 2800, 2500, 2000]) {
-      if (spies.onSummarizeStartSpy.mock.calls.length > 0) {
-        break;
-      }
-      run = await createRun(squeeze);
-      await runTurn(
-        { run, conversationHistory },
-        `What is ${squeeze} - 1000? Calculator.`,
-        streamConfig
-      );
-    }
-
-    // Verify summarization fired
     expect(spies.onSummarizeCompleteSpy).toHaveBeenCalled();
 
     const completePayload = spies.onSummarizeCompleteSpy.mock
       .calls[0][0] as t.SummarizeCompleteEvent;
-    expect(completePayload.summary!.tokenCount).toBeGreaterThan(10);
-    expect(completePayload.summary!.tokenCount).toBeLessThan(1500);
+    const summaryTokenCount = completePayload.summary!.tokenCount ?? 0;
+    expect(summaryTokenCount).toBeGreaterThan(10);
+    expect(summaryTokenCount).toBeLessThan(1500);
+    expect(summaryTokenCount).toBeLessThan(originalTokenTotal);
 
-    // Token accounting: collectedUsage should have valid entries
     const validUsage = collectedUsage.filter(
       (u: Partial<UsageMetadata>) =>
         u.input_tokens != null && u.input_tokens > 0
@@ -2510,8 +2506,8 @@ const hasAnyApiKey =
     expect(validUsage.length).toBeGreaterThan(0);
 
     console.log(
-      `  Token audit: summary=${completePayload.summary!.tokenCount} tokens, ` +
-        `usageEntries=${validUsage.length}`
+      `  Token audit: summary=${summaryTokenCount} tokens, ` +
+        `preTotal=${originalTokenTotal}, usageEntries=${validUsage.length}`
     );
   }, 180_000);
 
@@ -2605,8 +2601,9 @@ const hasAnyApiKey =
     const summaryText = getSummaryText(completePayload.summary);
     const reportedTokenCount = completePayload.summary!.tokenCount ?? 0;
 
-    // Count tokens locally using the same tokenizer
-    const localTokenCount = tokenCounter(new SystemMessage(summaryText));
+    const localTokenCount =
+      tokenCounter(new SystemMessage(summaryText)) +
+      SUMMARY_WRAPPER_OVERHEAD_TOKENS;
 
     console.log(
       `  Token match: reported=${reportedTokenCount}, local=${localTokenCount}`

package/src/tools/ToolNode.ts

@@ -33,6 +33,7 @@ import {
 } from '@/utils/truncation';
 import { safeDispatchCustomEvent } from '@/utils/events';
 import { executeHooks } from '@/hooks';
+import { toLangChainContent } from '@/messages/langchain';
 import { Constants, GraphEvents, CODE_EXECUTION_TOOLS } from '@/common';
 import {
   buildReferenceKey,
@@ -1282,7 +1283,10 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       if (msg.skillName != null) additional_kwargs.skillName = msg.skillName;
 
       converted.push(
-        new HumanMessage({ content: msg.content, additional_kwargs })
+        new HumanMessage({
+          content: toLangChainContent(msg.content),
+          additional_kwargs,
+        })
       );
     }
     return converted;