@librechat/agents 3.1.37 → 3.1.39

package/src/agents/AgentContext.ts

@@ -142,6 +142,8 @@ export class AgentContext {
   lastToken?: string;
   /** Token type switch state */
   tokenTypeSwitch?: 'reasoning' | 'content';
+  /** Tracks how many reasoning→text transitions have occurred (ensures unique post-reasoning step keys) */
+  reasoningTransitionCount = 0;
   /** Current token type being processed */
   currentTokenType: ContentTypes.TEXT | ContentTypes.THINK | 'think_and_text' =
     ContentTypes.TEXT;
@@ -462,6 +464,7 @@ export class AgentContext {
     this.pruneMessages = undefined;
     this.lastStreamCall = undefined;
     this.tokenTypeSwitch = undefined;
+    this.reasoningTransitionCount = 0;
     this.currentTokenType = ContentTypes.TEXT;
     this.discoveredToolNames.clear();
     this.handoffContext = undefined;

package/src/graphs/Graph.ts

@@ -314,7 +314,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     ) {
       keyList.push('reasoning');
     } else if (agentContext.tokenTypeSwitch === 'content') {
-      keyList.push('post-reasoning');
+      keyList.push(`post-reasoning-${agentContext.reasoningTransitionCount}`);
     }
 
     if (this.invokedToolIds != null && this.invokedToolIds.size > 0) {

package/src/messages/cache.test.ts

@@ -551,6 +551,47 @@ describe('addBedrockCacheControl (Bedrock cache checkpoints)', () => {
     });
     expect(secondLastContent[1]).toEqual({ cachePoint: { type: 'default' } });
   });
+
+  it('skips cachePoint on AI messages with only whitespace text and reasoning (tool-call scenario)', () => {
+    const messages = [
+      {
+        role: 'user',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            text: 'What can you tell me about this PR?',
+          },
+        ],
+      },
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, text: '\n\n' },
+          {
+            type: 'reasoning_content',
+            reasoningText: { text: 'Let me look into that.', signature: 'abc' },
+          },
+        ] as MessageContentComplex[],
+      },
+      {
+        role: 'user',
+        content: [{ type: ContentTypes.TEXT, text: 'tool result here' }],
+        getType: (): 'tool' => 'tool',
+      },
+    ];
+
+    const result = addBedrockCacheControl(
+      messages as Parameters<typeof addBedrockCacheControl>[0]
+    );
+    const aiContent = result[1].content as MessageContentComplex[];
+    const hasCachePoint = aiContent.some((b) => 'cachePoint' in b);
+    expect(hasCachePoint).toBe(false);
+
+    const userContent = result[0].content as MessageContentComplex[];
+    expect(userContent[userContent.length - 1]).toEqual({
+      cachePoint: { type: 'default' },
+    });
+  });
 });
 
 describe('stripAnthropicCacheControl', () => {

package/src/messages/cache.ts

@@ -331,7 +331,7 @@ export function addBedrockCacheControl<
     let hasCacheableContent = false;
     for (const block of workingContent) {
       if (block.type === ContentTypes.TEXT) {
-        if (typeof block.text === 'string' && block.text !== '') {
+        if (typeof block.text === 'string' && block.text.trim() !== '') {
           hasCacheableContent = true;
           break;
         }
@@ -349,7 +349,7 @@ export function addBedrockCacheControl<
       const type = (block as { type?: string }).type;
       if (type === ContentTypes.TEXT || type === 'text') {
         const text = (block as { text?: string }).text;
-        if (text === '' || text === undefined) {
+        if (text === '' || text === undefined || text.trim() === '') {
           continue;
         }
         workingContent.splice(j + 1, 0, {

package/src/scripts/bedrock-content-aggregation-test.ts

@@ -0,0 +1,265 @@
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { UsageMetadata } from '@langchain/core/messages';
+import * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { GraphEvents, ContentTypes, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+const collectedUsage: UsageMetadata[] = [];
+
+async function testBedrockContentAggregation(): Promise<void> {
+  const instructions =
+    'You are a helpful AI assistant with coding capabilities. When answering questions, be thorough in your reasoning.';
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        const result = (data as unknown as { result: t.ToolEndEvent }).result;
+        console.log(
+          `[ON_RUN_STEP_COMPLETED] stepId=${result.id} index=${result.index} type=${result.type} tool=${result.tool_call?.name ?? 'n/a'}`
+        );
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
+        const toolCalls =
+          data.stepDetails.type === 'tool_calls' && data.stepDetails.tool_calls
+            ? (
+                data.stepDetails.tool_calls as Array<{
+                  name?: string;
+                  id?: string;
+                }>
+              )
+                .map((tc) => `${tc.name ?? '?'}(${tc.id ?? '?'})`)
+                .join(', ')
+            : 'none';
+        console.log(
+          `[ON_RUN_STEP] stepId=${data.id} index=${data.index} type=${data.type} stepIndex=${data.stepIndex} toolCalls=[${toolCalls}]`
+        );
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.RunStepDeltaEvent
+      ) => {
+        const tcNames =
+          data.delta.tool_calls
+            ?.map(
+              (tc) =>
+                `${tc.name ?? '?'}(args=${(tc.args ?? '').substring(0, 30)}...)`
+            )
+            .join(', ') ?? 'none';
+        console.log(
+          `[ON_RUN_STEP_DELTA] stepId=${data.id} type=${data.delta.type} toolCalls=[${tcNames}]`
+        );
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.MessageDeltaEvent
+      ) => {
+        const preview = Array.isArray(data.delta.content)
+          ? data.delta.content
+              .map(
+                (c) =>
+                  `${c.type}:"${String((c as Record<string, unknown>).text ?? (c as Record<string, unknown>).think ?? '').substring(0, 40)}"`
+              )
+              .join(', ')
+          : String(data.delta.content).substring(0, 40);
+        console.log(
+          `[ON_MESSAGE_DELTA] stepId=${data.id} content=[${preview}]`
+        );
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.ReasoningDeltaEvent
+      ) => {
+        const preview = Array.isArray(data.delta.content)
+          ? data.delta.content
+              .map(
+                (c) =>
+                  `${c.type}:"${String((c as Record<string, unknown>).think ?? '').substring(0, 40)}"`
+              )
+              .join(', ')
+          : '?';
+        console.log(
+          `[ON_REASONING_DELTA] stepId=${data.id} content=[${preview}]`
+        );
+        aggregateContent({ event, data });
+      },
+    },
+  };
+
+  const baseLlmConfig = getLLMConfig(Providers.BEDROCK);
+
+  const llmConfig = {
+    ...baseLlmConfig,
+    model: 'global.anthropic.claude-opus-4-6-v1',
+    maxTokens: 16000,
+    additionalModelRequestFields: {
+      thinking: { type: 'enabled', budget_tokens: 10000 },
+    },
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: 'bedrock-content-aggregation-test',
+    graphConfig: {
+      instructions,
+      type: 'standard',
+      tools: [createCodeExecutionTool()],
+      llmConfig,
+    },
+    returnContent: true,
+    customHandlers: customHandlers as t.RunConfig['customHandlers'],
+  });
+
+  const streamConfig = {
+    configurable: {
+      thread_id: 'bedrock-content-aggregation-thread',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  const userMessage = `im testing edge cases with our code interpreter. i know we can persist files, but what happens when we put them in directories?`;
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  console.log('Running Bedrock content aggregation test...\n');
+  console.log(`Prompt: "${userMessage}"\n`);
+
+  const inputs = { messages: [...conversationHistory] };
+  await run.processStream(inputs, streamConfig);
+
+  console.log('\n\n========== CONTENT PARTS ANALYSIS ==========\n');
+
+  let hasEmptyToolCall = false;
+  let hasReasoningOrderIssue = false;
+
+  for (let i = 0; i < _contentParts.length; i++) {
+    const part = _contentParts[i];
+    if (!part) {
+      console.log(`  [${i}] undefined`);
+      continue;
+    }
+
+    const partType = part.type;
+    if (partType === ContentTypes.TOOL_CALL) {
+      const tc = (part as t.ToolCallContent).tool_call;
+      if (!tc || !tc.name) {
+        hasEmptyToolCall = true;
+        console.log(`  [${i}] TOOL_CALL *** EMPTY (no tool_call data) ***`);
+      } else {
+        const outputPreview = tc.output
+          ? `output=${(tc.output as string).substring(0, 80)}...`
+          : 'no output';
+        console.log(`  [${i}] TOOL_CALL name=${tc.name} ${outputPreview}`);
+      }
+    } else if (partType === ContentTypes.THINK) {
+      const think = (part as t.ReasoningContentText).think ?? '';
+      console.log(
+        `  [${i}] THINK (${think.length} chars): "${think.substring(0, 80)}..."`
+      );
+    } else if (partType === ContentTypes.TEXT) {
+      const text = (part as t.MessageDeltaUpdate).text ?? '';
+      console.log(
+        `  [${i}] TEXT (${text.length} chars): "${text.substring(0, 80)}..."`
+      );
+    } else {
+      console.log(`  [${i}] ${partType}`);
+    }
+  }
+
+  /**
+   * Check reasoning ordering within a single invocation cycle.
+   * A tool_call resets the cycle — text before think across different
+   * invocations (e.g., text from invocation 2, think from invocation 3) is valid.
+   */
+  let lastTextInCycle: number | null = null;
+  for (let i = 0; i < _contentParts.length; i++) {
+    const part = _contentParts[i];
+    if (!part) continue;
+
+    if (part.type === ContentTypes.TOOL_CALL) {
+      lastTextInCycle = null;
+      continue;
+    }
+
+    if (part.type === ContentTypes.TEXT) {
+      lastTextInCycle = i;
+    } else if (part.type === ContentTypes.THINK && lastTextInCycle !== null) {
+      const prevText = _contentParts[lastTextInCycle] as t.MessageDeltaUpdate;
+      const thinkContent = (part as t.ReasoningContentText).think ?? '';
+      if (
+        prevText?.text &&
+        prevText.text.trim().length > 5 &&
+        thinkContent.length > 0
+      ) {
+        hasReasoningOrderIssue = true;
+        console.log(
+          `\n  *** ORDERING ISSUE (same invocation): TEXT at [${lastTextInCycle}] appears before THINK at [${i}]`
+        );
+        console.log(
+          `      Text ends with: "...${prevText.text.substring(prevText.text.length - 60)}"`
+        );
+        console.log(
+          `      Think starts with: "${thinkContent.substring(0, 60)}..."`
+        );
+      }
+    }
+  }
+
+  console.log('\n========== SUMMARY ==========\n');
+  console.log(`Total content parts: ${_contentParts.filter(Boolean).length}`);
+  console.log(
+    `Empty tool_call parts: ${hasEmptyToolCall ? 'YES (BUG)' : 'No'}`
+  );
+  console.log(
+    `Reasoning order issues: ${hasReasoningOrderIssue ? 'YES (BUG)' : 'No'}`
+  );
+  console.log('\nFull contentParts dump:');
+  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);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testBedrockContentAggregation().catch((err) => {
+  console.error(err);
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});

package/src/scripts/bedrock-parallel-tools-test.ts

@@ -0,0 +1,203 @@
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { UsageMetadata } from '@langchain/core/messages';
+import type { StandardGraph } from '@/graphs';
+import * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { GraphEvents, ContentTypes, Providers } from '@/common';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { Calculator } from '@/tools/Calculator';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+const collectedUsage: UsageMetadata[] = [];
+
+async function testParallelToolCalls(): Promise<void> {
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
+    [GraphEvents.CHAT_MODEL_STREAM]: {
+      handle: async (
+        event: string,
+        data: t.StreamEventData,
+        metadata?: Record<string, unknown>,
+        graph?: unknown
+      ): Promise<void> => {
+        const chunk = data.chunk as Record<string, unknown> | undefined;
+        const tcc = chunk?.tool_call_chunks as
+          | Array<{ id?: string; name?: string; index?: number }>
+          | undefined;
+        if (tcc && tcc.length > 0) {
+          console.log(
+            `[CHAT_MODEL_STREAM] tool_call_chunks: ${JSON.stringify(tcc.map((c) => ({ id: c.id, name: c.name, index: c.index })))}`
+          );
+        }
+        const handler = new ChatModelStreamHandler();
+        return handler.handle(event, data, metadata, graph as StandardGraph);
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        const result = (data as unknown as { result: t.ToolEndEvent }).result;
+        console.log(
+          `[ON_RUN_STEP_COMPLETED] stepId=${result.id} index=${result.index} type=${result.type} tool=${result.tool_call?.name ?? 'n/a'}`
+        );
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
+        const toolCalls =
+          data.stepDetails.type === 'tool_calls' && data.stepDetails.tool_calls
+            ? (
+                data.stepDetails.tool_calls as Array<{
+                  name?: string;
+                  id?: string;
+                }>
+              )
+                .map((tc) => `${tc.name ?? '?'}(${tc.id ?? '?'})`)
+                .join(', ')
+            : 'none';
+        console.log(
+          `[ON_RUN_STEP] stepId=${data.id} index=${data.index} type=${data.type} stepIndex=${data.stepIndex} toolCalls=[${toolCalls}]`
+        );
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.RunStepDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.MessageDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.ReasoningDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+  };
+
+  const baseLlmConfig = getLLMConfig(Providers.BEDROCK);
+
+  const llmConfig = {
+    ...baseLlmConfig,
+    model: 'global.anthropic.claude-opus-4-6-v1',
+    maxTokens: 16000,
+    additionalModelRequestFields: {
+      thinking: { type: 'enabled', budget_tokens: 10000 },
+    },
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: 'bedrock-parallel-tools-test',
+    graphConfig: {
+      instructions:
+        'You are a math assistant. When asked to calculate multiple things, use the calculator tool for ALL of them in parallel. Do NOT chain calculations sequentially.',
+      type: 'standard',
+      tools: [new Calculator()],
+      llmConfig,
+    },
+    returnContent: true,
+    customHandlers: customHandlers as t.RunConfig['customHandlers'],
+  });
+
+  const streamConfig = {
+    configurable: { thread_id: 'bedrock-parallel-tools-thread' },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  const userMessage =
+    'Calculate these 3 things at the same time using the calculator: 1) 123 * 456, 2) sqrt(144) + 7, 3) 2^10 - 24';
+  conversationHistory.push(new HumanMessage(userMessage));
+
+  console.log('Running Bedrock parallel tool calls test...\n');
+  console.log(`Prompt: "${userMessage}"\n`);
+
+  const inputs = { messages: [...conversationHistory] };
+  await run.processStream(inputs, streamConfig);
+
+  console.log('\n\n========== ANALYSIS ==========\n');
+
+  let toolCallCount = 0;
+  const toolCallNames: string[] = [];
+  let hasUndefined = false;
+
+  for (let i = 0; i < _contentParts.length; i++) {
+    const part = _contentParts[i];
+    if (!part) {
+      hasUndefined = true;
+      console.log(`  [${i}] *** UNDEFINED ***`);
+      continue;
+    }
+    if (part.type === ContentTypes.TOOL_CALL) {
+      toolCallCount++;
+      const tc = (part as t.ToolCallContent).tool_call;
+      const hasData = tc && tc.name;
+      if (!hasData) {
+        console.log(`  [${i}] TOOL_CALL *** EMPTY ***`);
+      } else {
+        toolCallNames.push(tc.name ?? '');
+        console.log(
+          `  [${i}] TOOL_CALL name=${tc.name} id=${tc.id} output=${String(tc.output ?? '').substring(0, 40)}`
+        );
+      }
+    } else if (part.type === ContentTypes.THINK) {
+      const think = (part as t.ReasoningContentText).think ?? '';
+      console.log(`  [${i}] THINK (${think.length} chars)`);
+    } else if (part.type === ContentTypes.TEXT) {
+      const text = (part as t.MessageDeltaUpdate).text ?? '';
+      console.log(
+        `  [${i}] TEXT (${text.length} chars): "${text.substring(0, 80)}..."`
+      );
+    }
+  }
+
+  console.log('\n========== SUMMARY ==========\n');
+  console.log(`Total content parts: ${_contentParts.filter(Boolean).length}`);
+  console.log(`Tool calls found: ${toolCallCount}`);
+  console.log(`Tool call names: [${toolCallNames.join(', ')}]`);
+  console.log(`Undefined gaps: ${hasUndefined ? 'YES (BUG)' : 'No'}`);
+  console.log(
+    `Expected 3 tool calls: ${toolCallCount >= 3 ? 'PASS' : 'FAIL (only ' + toolCallCount + ')'}`
+  );
+  console.log('\nFull contentParts dump:');
+  console.dir(_contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+testParallelToolCalls().catch((err) => {
+  console.error(err);
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});

package/src/scripts/tools.ts

@@ -25,16 +25,7 @@ async function testStandardStreaming(): Promise<void> {
         return true;
       }
     ),
-    [GraphEvents.CHAT_MODEL_END]: {
-      handle: (
-        _event: string,
-        _data: t.StreamEventData,
-        metadata?: Record<string, unknown>
-      ): void => {
-        console.log('\n====== CHAT_MODEL_END METADATA ======');
-        console.dir(metadata, { depth: null });
-      },
-    },
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_START]: {
       handle: (
         _event: string,
@@ -158,9 +149,9 @@ async function testStandardStreaming(): Promise<void> {
     conversationHistory.push(...finalMessages);
     console.dir(conversationHistory, { depth: null });
   }
-  console.dir(finalContentParts, { depth: null });
+  // console.dir(finalContentParts, { depth: null });
   console.log('\n\n====================\n\n');
-  // console.dir(contentParts, { depth: null });
+  console.dir(contentParts, { depth: null });
 }
 
 process.on('unhandledRejection', (reason, promise) => {

package/src/stream.ts

@@ -411,6 +411,7 @@ hasToolCallChunks: ${hasToolCallChunks}
     ) {
       agentContext.currentTokenType = ContentTypes.TEXT;
       agentContext.tokenTypeSwitch = 'content';
+      agentContext.reasoningTransitionCount++;
     } else if (
       chunk.content != null &&
       typeof chunk.content === 'string' &&
@@ -465,7 +466,7 @@ export function createContentAggregator(): t.ContentAggregatorResult {
       return;
     }
 
-    if (!contentParts[index]) {
+    if (!contentParts[index] && partType !== ContentTypes.TOOL_CALL) {
       contentParts[index] = { type: partType };
     }
 

package/src/tools/CodeExecutor.ts

@@ -33,6 +33,7 @@ const SUPPORTED_LANGUAGES = [
   'd',
   'f90',
   'r',
+  'bash',
 ] as const;
 
 export const CodeExecutionToolSchema = {