@librechat/agents 3.1.36 → 3.1.38

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) {
@@ -1110,46 +1110,51 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       toolName === Constants.PROGRAMMATIC_TOOL_CALLING
     ) {
       const artifact = output.artifact as t.CodeExecutionArtifact | undefined;
-      const newFiles = artifact?.files ?? [];
-      const hasNewFiles = newFiles.length > 0;
-
-      if (
-        hasNewFiles &&
-        artifact?.session_id != null &&
-        artifact.session_id !== ''
-      ) {
-        /**
-         * Stamp each new file with its source session_id.
-         * This enables files from different executions (parallel or sequential)
-         * to be tracked and passed to subsequent calls.
-         */
-        const filesWithSession: t.FileRefs = newFiles.map((file) => ({
-          ...file,
-          session_id: artifact.session_id,
-        }));
-
+      if (artifact?.session_id != null && artifact.session_id !== '') {
+        const newFiles = artifact.files ?? [];
         const existingSession = this.sessions.get(Constants.EXECUTE_CODE) as
           | t.CodeSessionContext
           | undefined;
         const existingFiles = existingSession?.files ?? [];
 
-        /**
-         * Merge files, preferring latest versions by name.
-         * If a file with the same name exists, replace it with the new version.
-         * This handles cases where files are edited/recreated in subsequent executions.
-         */
-        const newFileNames = new Set(filesWithSession.map((f) => f.name));
-        const filteredExisting = existingFiles.filter(
-          (f) => !newFileNames.has(f.name)
-        );
-
-        this.sessions.set(Constants.EXECUTE_CODE, {
-          /** Keep latest session_id for reference/fallback */
-          session_id: artifact.session_id,
-          /** Accumulated files with latest versions preferred */
-          files: [...filteredExisting, ...filesWithSession],
-          lastUpdated: Date.now(),
-        });
+        if (newFiles.length > 0) {
+          /**
+           * Stamp each new file with its source session_id.
+           * This enables files from different executions (parallel or sequential)
+           * to be tracked and passed to subsequent calls.
+           */
+          const filesWithSession: t.FileRefs = newFiles.map((file) => ({
+            ...file,
+            session_id: artifact.session_id,
+          }));
+
+          /**
+           * Merge files, preferring latest versions by name.
+           * If a file with the same name exists, replace it with the new version.
+           * This handles cases where files are edited/recreated in subsequent executions.
+           */
+          const newFileNames = new Set(filesWithSession.map((f) => f.name));
+          const filteredExisting = existingFiles.filter(
+            (f) => !newFileNames.has(f.name)
+          );
+
+          this.sessions.set(Constants.EXECUTE_CODE, {
+            session_id: artifact.session_id,
+            files: [...filteredExisting, ...filesWithSession],
+            lastUpdated: Date.now(),
+          });
+        } else {
+          /**
+           * Store session_id even without new files for session continuity.
+           * The CodeExecutor can fall back to the /files endpoint to discover
+           * session files not explicitly returned in the exec response.
+           */
+          this.sessions.set(Constants.EXECUTE_CODE, {
+            session_id: artifact.session_id,
+            files: existingFiles,
+            lastUpdated: Date.now(),
+          });
+        }
       }
     }
 

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 };
     }