@librechat/agents 3.0.775 → 3.1.0

package/src/scripts/code_exec_multi_session.ts

@@ -0,0 +1,241 @@
+// src/scripts/code_exec_multi_session.ts
+/**
+ * Tests multi-session file tracking for code execution.
+ * Verifies that:
+ * 1. Files from multiple executions are accumulated
+ * 2. Each file tracks its source session_id
+ * 3. Edited/recreated files replace older versions (latest preferred)
+ *
+ * Run with: npm run code_exec_multi_session
+ */
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type * as t from '@/types';
+import { ChatModelStreamHandler } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Constants, GraphEvents } from '@/common';
+import { Run } from '@/run';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Prints session context from the graph
+ */
+function printSessionContext(run: Run<t.IState>, label: string): void {
+  const graph = run.Graph;
+  if (!graph) {
+    console.log(`\n[${label}] No graph available`);
+    return;
+  }
+
+  const session = graph.sessions.get(Constants.EXECUTE_CODE) as
+    | t.CodeSessionContext
+    | undefined;
+
+  console.log(`\n========== ${label} ==========`);
+  if (!session) {
+    console.log('  No session context stored yet');
+    return;
+  }
+
+  console.log(`  Latest session_id: ${session.session_id}`);
+  console.log(`  Files tracked: ${session.files.length}`);
+  for (const file of session.files) {
+    console.log(`    - ${file.name} (session: ${file.session_id})`);
+  }
+}
+
+async function testMultiSessionFiles(): Promise<void> {
+  const { provider } = await getArgs();
+
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    runId: 'multi-session-test',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [createCodeExecutionTool()],
+      instructions: `You are a coding assistant. Execute code exactly as requested.
+When asked to create files, use Python and save to /mnt/data/.
+When reading files, print their contents.
+Be concise in responses.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const streamConfig: Partial<RunnableConfig> & {
+    version: 'v1' | 'v2';
+    streamMode: string;
+  } = {
+    configurable: {
+      provider,
+      thread_id: 'multi-session-test',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // ========== TEST 1: Create first file ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 1: Create first file (file_a.txt)');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Create a file called "file_a.txt" with the content:
+"This is file A, version 1"
+Print confirmation when done.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages1 = run.getRunMessages();
+  if (messages1) conversationHistory.push(...messages1);
+
+  printSessionContext(run, 'After Test 1');
+
+  // ========== TEST 2: Create second file (different session) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 2: Create second file (file_b.txt)');
+  console.log('Expecting: Both file_a.txt and file_b.txt tracked');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Create a NEW file called "file_b.txt" with the content:
+"This is file B"
+Print confirmation when done.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages2 = run.getRunMessages();
+  if (messages2) conversationHistory.push(...messages2);
+
+  printSessionContext(run, 'After Test 2');
+
+  // ========== TEST 3: Read BOTH files (verifies accumulation) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 3: Read BOTH files from previous executions');
+  console.log('This verifies multi-session file accumulation works');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Read and print the contents of BOTH files:
+1. file_a.txt
+2. file_b.txt
+
+Show me what's in each file.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages3 = run.getRunMessages();
+  if (messages3) conversationHistory.push(...messages3);
+
+  printSessionContext(run, 'After Test 3');
+
+  // ========== TEST 4: Edit file_a.txt (verifies latest-wins) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 4: Edit file_a.txt (create new version)');
+  console.log('Expecting: Old file_a.txt replaced with new version');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Create an UPDATED version of "file_a.txt" with the content:
+"This is file A, version 2 - UPDATED"
+Print confirmation when done.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages4 = run.getRunMessages();
+  if (messages4) conversationHistory.push(...messages4);
+
+  printSessionContext(run, 'After Test 4');
+
+  // ========== TEST 5: Read file_a.txt (verifies latest version) ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST 5: Read file_a.txt to verify it has the UPDATED content');
+  console.log('Expected: "version 2 - UPDATED" NOT "version 1"');
+  console.log('='.repeat(60));
+
+  conversationHistory.push(
+    new HumanMessage(`
+Read and print the contents of file_a.txt.
+Tell me what version it shows.
+`)
+  );
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const messages5 = run.getRunMessages();
+  if (messages5) conversationHistory.push(...messages5);
+
+  printSessionContext(run, 'Final Session State');
+
+  // ========== SUMMARY ==========
+  console.log('\n\n' + '='.repeat(60));
+  console.log('TEST SUMMARY');
+  console.log('='.repeat(60));
+
+  const finalSession = run.Graph?.sessions.get(Constants.EXECUTE_CODE) as
+    | t.CodeSessionContext
+    | undefined;
+
+  if (finalSession) {
+    const uniqueSessionIds = new Set(
+      finalSession.files.map((f) => f.session_id)
+    );
+    console.log(`\nTotal files tracked: ${finalSession.files.length}`);
+    console.log(`Unique session_ids: ${uniqueSessionIds.size}`);
+    console.log('\nFiles:');
+    for (const file of finalSession.files) {
+      console.log(
+        `  - ${file.name} (session: ${file.session_id?.slice(0, 20)}...)`
+      );
+    }
+
+    // Verify expectations
+    const fileACount = finalSession.files.filter(
+      (f) => f.name === 'file_a.txt'
+    ).length;
+    const fileBCount = finalSession.files.filter(
+      (f) => f.name === 'file_b.txt'
+    ).length;
+
+    console.log('\n✓ Checks:');
+    console.log(`  file_a.txt count: ${fileACount} (expected: 1, latest wins)`);
+    console.log(`  file_b.txt count: ${fileBCount} (expected: 1)`);
+
+    if (fileACount === 1 && fileBCount === 1) {
+      console.log('\n✅ All tests passed! Multi-session tracking works.');
+    } else {
+      console.log('\n❌ Test failed - unexpected file counts');
+    }
+  }
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  process.exit(1);
+});
+
+testMultiSessionFiles().catch((err) => {
+  console.error('Test failed:', err);
+  process.exit(1);
+});

package/src/scripts/thinking-bedrock.ts

@@ -0,0 +1,159 @@
+// src/scripts/thinking-bedrock.ts
+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, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+const collectedUsage: UsageMetadata[] = [];
+
+async function testBedrockThinking(): Promise<void> {
+  const { userName } = await getArgs();
+  const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+
+  // Set up event handlers
+  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 => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
+        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);
+
+  // Enable thinking with token budget for Bedrock
+  const llmConfig = {
+    ...baseLlmConfig,
+    model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    maxTokens: 5000,
+    additionalModelRequestFields: {
+      thinking: { type: 'enabled', budget_tokens: 2000 },
+    },
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-bedrock-thinking-id',
+    graphConfig: {
+      instructions,
+      type: 'standard',
+      tools: [createCodeExecutionTool()],
+      llmConfig,
+    },
+    returnContent: true,
+    customHandlers: customHandlers as t.RunConfig['customHandlers'],
+  });
+
+  const config = {
+    configurable: {
+      thread_id: 'bedrock-thinking-test-thread',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // Test 1: Regular thinking mode
+  console.log('\n\nTest 1: Bedrock Regular thinking mode');
+  const userMessage1 = `Please print 'hello world' in python`;
+  conversationHistory.push(new HumanMessage(userMessage1));
+
+  console.log('Running first query with Bedrock thinking enabled...');
+  const firstInputs = { messages: [...conversationHistory] };
+  await run.processStream(firstInputs, config);
+
+  // Extract and display thinking blocks
+  const finalMessages = run.getRunMessages();
+  console.log('\n\nFinal messages after Test 1:');
+  console.dir(finalMessages, { depth: null });
+
+  // Test 2: Try multi-turn conversation
+  console.log(
+    '\n\nTest 2: Multi-turn conversation with Bedrock thinking enabled'
+  );
+  const userMessage2 = `Given your previous analysis, what would be the most significant technical challenges in making this transition?`;
+  conversationHistory.push(new HumanMessage(userMessage2));
+
+  console.log('Running second query with Bedrock thinking enabled...');
+  const secondInputs = { messages: [...conversationHistory] };
+  await run.processStream(secondInputs, config);
+
+  // Display thinking blocks for second response
+  const finalMessages2 = run.getRunMessages();
+  console.log('\n\nBedrock thinking feature test completed!');
+  console.dir(finalMessages2, { depth: null });
+
+  console.log('\n\nContent parts:');
+  console.dir(_contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testBedrockThinking().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/scripts/thinking.ts

@@ -1,7 +1,11 @@
 // src/scripts/test-thinking.ts
 import { config } from 'dotenv';
 config();
-import { HumanMessage, SystemMessage, BaseMessage } from '@langchain/core/messages';
+import {
+  HumanMessage,
+  SystemMessage,
+  BaseMessage,
+} from '@langchain/core/messages';
 import type { UsageMetadata } from '@langchain/core/messages';
 import * as t from '@/types';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
@@ -21,17 +25,23 @@ async function testThinking(): Promise<void> {
   const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
   const { contentParts, aggregateContent } = createContentAggregator();
   _contentParts = contentParts as t.MessageContentComplex[];
-  
+
   // Set up event handlers
   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 => {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
         console.log('====== ON_RUN_STEP_COMPLETED ======');
-        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
-      }
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
     },
     [GraphEvents.ON_RUN_STEP]: {
       handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
@@ -39,29 +49,38 @@ async function testThinking(): Promise<void> {
       },
     },
     [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.RunStepDeltaEvent) => {
+      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) => {
+      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) => {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.ReasoningDeltaEvent
+      ) => {
         aggregateContent({ event, data });
       },
     },
   };
 
   const baseLlmConfig: t.LLMConfig = getLLMConfig(Providers.ANTHROPIC);
-  
+
   // Enable thinking with token budget
   const llmConfig = {
     ...baseLlmConfig,
     model: 'claude-3-7-sonnet-latest',
-    thinking: { type: "enabled", budget_tokens: 2000 }
+    thinking: { type: 'enabled', budget_tokens: 2000 },
   };
 
   const run = await Run.create<t.IState>({
@@ -93,7 +112,7 @@ async function testThinking(): Promise<void> {
   console.log('Running first query with thinking enabled...');
   const firstInputs = { messages: [...conversationHistory] };
   await run.processStream(firstInputs, config);
-  
+
   // Extract and display thinking blocks
   const finalMessages = run.getRunMessages();
 
@@ -101,30 +120,32 @@ async function testThinking(): Promise<void> {
   console.log('\n\nTest 2: Multi-turn conversation with thinking enabled');
   const userMessage2 = `Given your previous analysis, what would be the most significant technical challenges in making this transition?`;
   conversationHistory.push(new HumanMessage(userMessage2));
-  
+
   console.log('Running second query with thinking enabled...');
   const secondInputs = { messages: [...conversationHistory] };
   await run.processStream(secondInputs, config);
-  
+
   // Display thinking blocks for second response
   const finalMessages2 = run.getRunMessages();
 
   // Test 3: Redacted thinking mode
   console.log('\n\nTest 3: Redacted thinking mode');
-  const magicString = "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB";
+  const magicString =
+    'ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB';
   const userMessage3 = `${magicString}\n\nExplain how quantum computing works in simple terms.`;
-  
+
   // Reset conversation for clean test
   conversationHistory.length = 0;
   conversationHistory.push(new HumanMessage(userMessage3));
-  
+
   console.log('Running query with redacted thinking...');
   const thirdInputs = { messages: [...conversationHistory] };
   await run.processStream(thirdInputs, config);
-  
+
   // Display redacted thinking blocks
   const finalMessages3 = run.getRunMessages();
   console.log('\n\nThinking feature test completed!');
+  console.dir(finalMessages3, { depth: null });
 }
 
 process.on('unhandledRejection', (reason, promise) => {
@@ -147,4 +168,4 @@ testThinking().catch((err) => {
   console.log('Content parts:');
   console.dir(_contentParts, { depth: null });
   process.exit(1);
-});
+});

package/src/scripts/tools.ts

@@ -18,9 +18,13 @@ async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
-      return true;
-    }),
+    [GraphEvents.TOOL_END]: new ToolEndHandler(
+      undefined,
+      undefined,
+      (name?: string) => {
+        return true;
+      }
+    ),
     [GraphEvents.CHAT_MODEL_END]: {
       handle: (
         _event: string,