@librechat/agents 3.0.776 → 3.1.0

package/src/llm/bedrock/utils/message_outputs.ts

@@ -0,0 +1,310 @@
+/**
+ * Utility functions for converting Bedrock Converse responses to LangChain messages.
+ * Ported from @langchain/aws common.js
+ */
+import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import type {
+  BedrockMessage,
+  ConverseResponse,
+  ContentBlockDeltaEvent,
+  ConverseStreamMetadataEvent,
+  ContentBlockStartEvent,
+  ReasoningContentBlock,
+  ReasoningContentBlockDelta,
+  MessageContentReasoningBlock,
+  MessageContentReasoningBlockReasoningTextPartial,
+  MessageContentReasoningBlockRedacted,
+} from '../types';
+
+/**
+ * Convert a Bedrock reasoning block delta to a LangChain partial reasoning block.
+ */
+export function bedrockReasoningDeltaToLangchainPartialReasoningBlock(
+  reasoningContent: ReasoningContentBlockDelta
+):
+  | MessageContentReasoningBlockReasoningTextPartial
+  | MessageContentReasoningBlockRedacted {
+  const { text, redactedContent, signature } =
+    reasoningContent as ReasoningContentBlockDelta & {
+      text?: string;
+      redactedContent?: Uint8Array;
+      signature?: string;
+    };
+
+  if (typeof text === 'string') {
+    return {
+      type: 'reasoning_content',
+      reasoningText: { text },
+    };
+  }
+  if (signature != null) {
+    return {
+      type: 'reasoning_content',
+      reasoningText: { signature },
+    };
+  }
+  if (redactedContent != null) {
+    return {
+      type: 'reasoning_content',
+      redactedContent: Buffer.from(redactedContent).toString('base64'),
+    };
+  }
+  throw new Error('Invalid reasoning content');
+}
+
+/**
+ * Convert a Bedrock reasoning block to a LangChain reasoning block.
+ */
+export function bedrockReasoningBlockToLangchainReasoningBlock(
+  reasoningContent: ReasoningContentBlock
+): MessageContentReasoningBlock {
+  const { reasoningText, redactedContent } =
+    reasoningContent as ReasoningContentBlock & {
+      reasoningText?: { text?: string; signature?: string };
+      redactedContent?: Uint8Array;
+    };
+
+  if (reasoningText != null) {
+    return {
+      type: 'reasoning_content',
+      reasoningText: reasoningText,
+    };
+  }
+  if (redactedContent != null) {
+    return {
+      type: 'reasoning_content',
+      redactedContent: Buffer.from(redactedContent).toString('base64'),
+    };
+  }
+  throw new Error('Invalid reasoning content');
+}
+
+/**
+ * Convert a Bedrock Converse message to a LangChain message.
+ */
+export function convertConverseMessageToLangChainMessage(
+  message: BedrockMessage,
+  responseMetadata: Omit<ConverseResponse, 'output'>
+): AIMessage {
+  if (message.content == null) {
+    throw new Error('No message content found in response.');
+  }
+  if (message.role !== 'assistant') {
+    throw new Error(
+      `Unsupported message role received in ChatBedrockConverse response: ${message.role}`
+    );
+  }
+
+  let requestId: string | undefined;
+  if (
+    '$metadata' in responseMetadata &&
+    responseMetadata.$metadata != null &&
+    typeof responseMetadata.$metadata === 'object' &&
+    'requestId' in responseMetadata.$metadata
+  ) {
+    requestId = responseMetadata.$metadata.requestId as string;
+  }
+
+  let tokenUsage:
+    | { input_tokens: number; output_tokens: number; total_tokens: number }
+    | undefined;
+  if (responseMetadata.usage != null) {
+    const input_tokens = responseMetadata.usage.inputTokens ?? 0;
+    const output_tokens = responseMetadata.usage.outputTokens ?? 0;
+    tokenUsage = {
+      input_tokens,
+      output_tokens,
+      total_tokens:
+        responseMetadata.usage.totalTokens ?? input_tokens + output_tokens,
+    };
+  }
+
+  if (
+    message.content.length === 1 &&
+    'text' in message.content[0] &&
+    typeof message.content[0].text === 'string'
+  ) {
+    return new AIMessage({
+      content: message.content[0].text,
+      response_metadata: responseMetadata,
+      usage_metadata: tokenUsage,
+      id: requestId,
+    });
+  } else {
+    const toolCalls: Array<{
+      id?: string;
+      name: string;
+      args: Record<string, unknown>;
+      type: 'tool_call';
+    }> = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const content: any[] = [];
+
+    message.content.forEach((c) => {
+      if (
+        'toolUse' in c &&
+        c.toolUse != null &&
+        c.toolUse.name != null &&
+        c.toolUse.name !== '' &&
+        c.toolUse.input != null &&
+        typeof c.toolUse.input === 'object'
+      ) {
+        toolCalls.push({
+          id: c.toolUse.toolUseId,
+          name: c.toolUse.name,
+          args: c.toolUse.input as Record<string, unknown>,
+          type: 'tool_call',
+        });
+      } else if ('text' in c && typeof c.text === 'string') {
+        content.push({ type: 'text', text: c.text });
+      } else if ('reasoningContent' in c && c.reasoningContent != null) {
+        content.push(
+          bedrockReasoningBlockToLangchainReasoningBlock(c.reasoningContent)
+        );
+      } else {
+        content.push(c);
+      }
+    });
+
+    return new AIMessage({
+      content: content.length ? content : '',
+      tool_calls: toolCalls.length ? toolCalls : undefined,
+      response_metadata: responseMetadata,
+      usage_metadata: tokenUsage,
+      id: requestId,
+    });
+  }
+}
+
+/**
+ * Handle a content block delta event from Bedrock Converse stream.
+ */
+export function handleConverseStreamContentBlockDelta(
+  contentBlockDelta: ContentBlockDeltaEvent
+): ChatGenerationChunk {
+  if (contentBlockDelta.delta == null) {
+    throw new Error('No delta found in content block.');
+  }
+
+  if (typeof contentBlockDelta.delta.text === 'string') {
+    return new ChatGenerationChunk({
+      text: contentBlockDelta.delta.text,
+      message: new AIMessageChunk({
+        content: contentBlockDelta.delta.text,
+        response_metadata: {
+          contentBlockIndex: contentBlockDelta.contentBlockIndex,
+        },
+      }),
+    });
+  } else if (contentBlockDelta.delta.toolUse != null) {
+    const index = contentBlockDelta.contentBlockIndex;
+    return new ChatGenerationChunk({
+      text: '',
+      message: new AIMessageChunk({
+        content: '',
+        tool_call_chunks: [
+          {
+            args: contentBlockDelta.delta.toolUse.input as string,
+            index,
+            type: 'tool_call_chunk',
+          },
+        ],
+        response_metadata: {
+          contentBlockIndex: contentBlockDelta.contentBlockIndex,
+        },
+      }),
+    });
+  } else if (contentBlockDelta.delta.reasoningContent != null) {
+    const reasoningBlock =
+      bedrockReasoningDeltaToLangchainPartialReasoningBlock(
+        contentBlockDelta.delta.reasoningContent
+      );
+    // Extract the text for additional_kwargs.reasoning_content (for stream handler compatibility)
+    const reasoningText =
+      'reasoningText' in reasoningBlock
+        ? (reasoningBlock.reasoningText.text ??
+          reasoningBlock.reasoningText.signature ??
+          ('redactedContent' in reasoningBlock
+            ? reasoningBlock.redactedContent
+            : ''))
+        : '';
+    return new ChatGenerationChunk({
+      text: '',
+      message: new AIMessageChunk({
+        content: [reasoningBlock],
+        additional_kwargs: {
+          // Set reasoning_content for stream handler to detect reasoning mode
+          reasoning_content: reasoningText,
+        },
+        response_metadata: {
+          contentBlockIndex: contentBlockDelta.contentBlockIndex,
+        },
+      }),
+    });
+  } else {
+    throw new Error(
+      `Unsupported content block type(s): ${JSON.stringify(contentBlockDelta.delta, null, 2)}`
+    );
+  }
+}
+
+/**
+ * Handle a content block start event from Bedrock Converse stream.
+ */
+export function handleConverseStreamContentBlockStart(
+  contentBlockStart: ContentBlockStartEvent
+): ChatGenerationChunk | null {
+  const index = contentBlockStart.contentBlockIndex;
+
+  if (contentBlockStart.start?.toolUse != null) {
+    return new ChatGenerationChunk({
+      text: '',
+      message: new AIMessageChunk({
+        content: '',
+        tool_call_chunks: [
+          {
+            name: contentBlockStart.start.toolUse.name,
+            id: contentBlockStart.start.toolUse.toolUseId,
+            index,
+            type: 'tool_call_chunk',
+          },
+        ],
+        response_metadata: {
+          contentBlockIndex: index,
+        },
+      }),
+    });
+  }
+
+  // Return null for non-tool content block starts (text blocks don't need special handling)
+  return null;
+}
+
+/**
+ * Handle a metadata event from Bedrock Converse stream.
+ */
+export function handleConverseStreamMetadata(
+  metadata: ConverseStreamMetadataEvent,
+  extra: { streamUsage: boolean }
+): ChatGenerationChunk {
+  const inputTokens = metadata.usage?.inputTokens ?? 0;
+  const outputTokens = metadata.usage?.outputTokens ?? 0;
+  const usage_metadata = {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    total_tokens: metadata.usage?.totalTokens ?? inputTokens + outputTokens,
+  };
+
+  return new ChatGenerationChunk({
+    text: '',
+    message: new AIMessageChunk({
+      content: '',
+      usage_metadata: extra.streamUsage ? usage_metadata : undefined,
+      response_metadata: {
+        // Use the same key as returned from the Converse API
+        metadata,
+      },
+    }),
+  });
+}

package/src/messages/core.ts

@@ -41,7 +41,7 @@ User: ${userMessage[1]}
 const _allowedTypes = ['image_url', 'text', 'tool_use', 'tool_result'];
 const allowedTypesByProvider: Record<string, string[]> = {
   default: _allowedTypes,
-  [Providers.ANTHROPIC]: [..._allowedTypes, 'thinking'],
+  [Providers.ANTHROPIC]: [..._allowedTypes, 'thinking', 'redacted_thinking'],
   [Providers.BEDROCK]: [..._allowedTypes, 'reasoning_content'],
   [Providers.OPENAI]: _allowedTypes,
 };

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