@librechat/agents 3.0.29 → 3.0.31

package/src/llm/bedrock/index.ts

@@ -0,0 +1,128 @@
+/**
+ * Optimized ChatBedrockConverse wrapper that fixes contentBlockIndex conflicts
+ *
+ * Bedrock sends the same contentBlockIndex for both text and tool_use content blocks,
+ * causing LangChain's merge logic to fail with "field[contentBlockIndex] already exists"
+ * errors. This wrapper simply strips contentBlockIndex from response_metadata to avoid
+ * the conflict.
+ *
+ * The contentBlockIndex field is only used internally by Bedrock's streaming protocol
+ * and isn't needed by application logic - the index field on tool_call_chunks serves
+ * the purpose of tracking tool call ordering.
+ */
+
+import { ChatBedrockConverse } from '@langchain/aws';
+import type { ChatBedrockConverseInput } from '@langchain/aws';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+
+export class CustomChatBedrockConverse extends ChatBedrockConverse {
+  constructor(fields?: ChatBedrockConverseInput) {
+    super(fields);
+  }
+
+  static lc_name(): string {
+    return 'LibreChatBedrockConverse';
+  }
+
+  /**
+   * Override _streamResponseChunks to strip contentBlockIndex from response_metadata
+   * This prevents LangChain's merge conflicts when the same index is used for
+   * different content types (text vs tool calls)
+   */
+  async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const baseStream = super._streamResponseChunks(
+      messages,
+      options,
+      runManager
+    );
+
+    for await (const chunk of baseStream) {
+      // Only process if we have response_metadata
+      if (
+        chunk.message instanceof AIMessageChunk &&
+        (chunk.message as Partial<AIMessageChunk>).response_metadata &&
+        typeof chunk.message.response_metadata === 'object'
+      ) {
+        // Check if contentBlockIndex exists anywhere in response_metadata (top level or nested)
+        const hasContentBlockIndex = this.hasContentBlockIndex(
+          chunk.message.response_metadata
+        );
+
+        if (hasContentBlockIndex) {
+          const cleanedMetadata = this.removeContentBlockIndex(
+            chunk.message.response_metadata
+          ) as Record<string, unknown>;
+
+          yield new ChatGenerationChunk({
+            text: chunk.text,
+            message: new AIMessageChunk({
+              ...chunk.message,
+              response_metadata: cleanedMetadata,
+            }),
+            generationInfo: chunk.generationInfo,
+          });
+          continue;
+        }
+      }
+
+      yield chunk;
+    }
+  }
+
+  /**
+   * Check if contentBlockIndex exists at any level in the object
+   */
+  private hasContentBlockIndex(obj: unknown): boolean {
+    if (obj === null || obj === undefined || typeof obj !== 'object') {
+      return false;
+    }
+
+    if ('contentBlockIndex' in obj) {
+      return true;
+    }
+
+    for (const value of Object.values(obj)) {
+      if (typeof value === 'object' && value !== null) {
+        if (this.hasContentBlockIndex(value)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Recursively remove contentBlockIndex from all levels of an object
+   */
+  private removeContentBlockIndex(obj: unknown): unknown {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.removeContentBlockIndex(item));
+    }
+
+    if (typeof obj === 'object') {
+      const cleaned: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key !== 'contentBlockIndex') {
+          cleaned[key] = this.removeContentBlockIndex(value);
+        }
+      }
+      return cleaned;
+    }
+
+    return obj;
+  }
+}
+
+export type { ChatBedrockConverseInput };

package/src/llm/providers.ts

@@ -1,8 +1,5 @@
 // src/llm/providers.ts
 import { ChatMistralAI } from '@langchain/mistralai';
-import { ChatBedrockConverse } from '@langchain/aws';
-// import { ChatAnthropic } from '@langchain/anthropic';
-// import { ChatVertexAI } from '@langchain/google-vertexai';
 import type {
   ChatModelConstructorMap,
   ProviderOptionsMap,
@@ -15,6 +12,7 @@ import {
   ChatXAI,
 } from '@/llm/openai';
 import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { ChatVertexAI } from '@/llm/vertexai';
@@ -32,7 +30,7 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.MISTRAL]: ChatMistralAI,
   [Providers.ANTHROPIC]: CustomAnthropic,
   [Providers.OPENROUTER]: ChatOpenRouter,
-  [Providers.BEDROCK]: ChatBedrockConverse,
+  [Providers.BEDROCK]: CustomChatBedrockConverse,
   // [Providers.ANTHROPIC]: ChatAnthropic,
   [Providers.GOOGLE]: CustomChatGoogleGenerativeAI,
 };

package/src/scripts/ant_web_search_error_edge_case.ts

@@ -0,0 +1,148 @@
+/* eslint-disable no-console */
+// src/scripts/ant_web_search_error_edge_case.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: (t.MessageContentComplex | undefined)[] = [];
+async function testStandardStreaming(): Promise<void> {
+  const { userName, location, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts;
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        // console.dir(data, { depth: null });
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        // console.log('====== ON_MESSAGE_DELTA ======');
+        // console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (
+        _event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>
+      ): void => {
+        console.log('====== TOOL_START ======');
+        // console.dir(data, { depth: null });
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(
+    Providers.ANTHROPIC
+  ) as t.AnthropicClientOptions & t.SharedLLMConfig;
+  llmConfig.model = 'claude-haiku-4-5';
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-run-id',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [
+        {
+          type: 'web_search_20250305',
+          name: 'web_search',
+          max_uses: 5,
+        },
+      ],
+      instructions: 'You are a helpful AI research assistant.',
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config = {
+    configurable: {
+      provider: Providers.ANTHROPIC,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  console.log('Test: Web search with multiple searches (error edge case test)');
+
+  // This prompt should trigger multiple web searches which may result in errors
+  const userMessage =
+    'Do a deep deep research on CoreWeave. I need you to perform multiple searches before you generate the answer. The basis of our research should be to investigate if this is a solid long term investment.';
+
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  const inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts = await run.processStream(inputs, config);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+    console.dir(conversationHistory, { depth: null });
+  }
+  // console.dir(finalContentParts, { depth: null });
+  console.log('\n\n====================\n\n');
+  // console.dir(contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Content Parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+testStandardStreaming().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content Parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});

package/src/tools/handlers.ts

@@ -87,13 +87,27 @@ export async function handleToolCallChunks({
   const alreadyDispatched =
     prevRunStep?.type === StepTypes.MESSAGE_CREATION &&
     graph.messageStepHasToolCalls.has(prevStepId);
-  if (!alreadyDispatched && tool_calls?.length === toolCallChunks.length) {
+
+  if (prevRunStep?.type === StepTypes.TOOL_CALLS) {
+    /**
+     * If previous step is already a tool_calls step, use that step ID
+     * This ensures tool call deltas are dispatched to the correct step
+     */
+    stepId = prevStepId;
+  } else if (
+    !alreadyDispatched &&
+    prevRunStep?.type === StepTypes.MESSAGE_CREATION
+  ) {
+    /**
+     * Create tool_calls step as soon as we receive the first tool call chunk
+     * This ensures deltas are always associated with the correct step
+     */
     await graph.dispatchMessageDelta(prevStepId, {
       content: [
         {
           type: ContentTypes.TEXT,
           text: '',
-          tool_call_ids: tool_calls.map((tc) => tc.id ?? ''),
+          tool_call_ids: tool_calls?.map((tc) => tc.id ?? '') ?? [],
         },
       ],
     });
@@ -102,7 +116,7 @@ export async function handleToolCallChunks({
       stepKey,
       {
         type: StepTypes.TOOL_CALLS,
-        tool_calls,
+        tool_calls: tool_calls ?? [],
       },
       metadata
     );

package/src/types/llm.ts

@@ -1,7 +1,6 @@
 // src/types/llm.ts
 import { ChatOllama } from '@langchain/ollama';
 import { ChatMistralAI } from '@langchain/mistralai';
-import { ChatBedrockConverse } from '@langchain/aws';
 import type {
   BindToolsInput,
   BaseChatModelParams,
@@ -33,6 +32,7 @@ import {
   ChatXAI,
 } from '@/llm/openai';
 import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { ChatVertexAI } from '@/llm/vertexai';
@@ -126,7 +126,7 @@ export type ChatModelMap = {
   [Providers.MISTRALAI]: ChatMistralAI;
   [Providers.MISTRAL]: ChatMistralAI;
   [Providers.OPENROUTER]: ChatOpenRouter;
-  [Providers.BEDROCK]: ChatBedrockConverse;
+  [Providers.BEDROCK]: CustomChatBedrockConverse;
   [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
 };